本文目的：记录MOOC上北大C++课程学习笔记，本文为第二周：类和对象基础。
C语言使用结构化程序设计，特点：
结构化程序设计的缺点：
为了更清晰的实现变量和函数的关系，使得程序更清晰更易于修改和维护，提出了面向对象的程序设计思想。
C++使用面向对象的程序设计：
对象的内存分配：
对象间的运算：
类成员变量和成员函数的使用：
类成员的可访问范围：
设置私有成员的机制，叫“隐藏”，隐藏的目的是强制对成员变量的访问一定要通过成员函数进行，那么以后成员变量的类型等属性修改后，只需要更改成员函数即可。否则，所有直接访问成员变量的语句都需要修改。
成员函数同样可以有重载及参数缺省。
构造函数（constructor）：
//示例1
有类A如下定义：
class A {
int v;
public:
A ( int n) { v = n; }
};
下面哪条语句是编译不会出错的？
A)) A a1(3);
B) A a2;
C) A * p = new A();
//示例2：手动模拟运行结果
class CSample {
int x;
public:
CSample() {
cout << "Constructor 1 Called" << endl;
}
CSample(int n) {
x = n;
cout << "Constructor 2 Called" << endl;
}
};
int main(){
CSample array1[2];
cout << "step1"<<endl;
CSample array2[2] = {4,5};
cout << "step2"<<endl;
CSample array3[2] = {3};
cout << "step3"<<endl;
CSample * array4 =
new CSample[2];
delete []array4;
return 0;
}
//输出结果为
Constructor 1 Called
Constructor 1 Called
step1
Constructor 2 Called
Constructor 2 Called
step2
Constructor 2 Called
Constructor 1 Called
step3
Constructor 1 Called
Constructor 1 Called
//示例3：构造函数在数组中的使用
class Test {
public:
Test( int n) { } //(1)
Test( int n, int m) { } //(2)
Test() { } //(3)
};
Test array1[3] = { 1, Test(1,2) }; // 三个元素分别用(1),(2),(3)初始化
Test array2[3] = { Test(2,3), Test(1,2), 1}; // 三个元素分别用(2),(2),(1)初始化
Test * pArray[3] = { new Test(4), new Test(1,2) }; //两个元素分别用(1),(2)初始化，第三个指针未初始化复制构造函数（copy constructor）：
类型转换构造函数:
//示例：类型转换构造函数实例
class Complex {
public:
double real, imag;
Complex( int i) { // 类型转换构造函数.若前有关键词explicit，后面则需显式转换
cout << "IntConstructor called" << endl;
real = i; imag = 0;
}
Complex(double r,double i) {real = r; imag = i; }
};
int main (){
Complex c1(7,8);
Complex c2 = 12; // 12被自动转换成一个临时Complex对象，以初始化c2
c1 = 9; // 9被自动转换成一个临时Complex对象，以赋值给c1，语句执行完后临时变量消亡
cout << c1.real << "," << c1.imag << endl;
return 0;
}
析构函数（destructors）：
构造函数和析构函数调用时机：
//示例1：构造函数和析构函数调用时机
class Demo {
int id;
public:
Demo(int i) {
id = i;
cout << "id=" << id << " constructed" << endl;
}
~Demo() {
cout << "id=" << id << " destructed" << endl;
}
};
Demo d1(1);
void Func(){
static Demo d2(2);
Demo d3(3);
cout << "func" << endl;
}
int main () {
Demo d4(4);
d4 = 6;
cout << "main" << endl;
{ Demo d5(5);}
Func();
cout << "main ends" << endl;
return 0;
}
//输出结果:
id=1 constructed
id=4 constructed
id=6 constructed
id=6 destructed
main
id=5 constructed
id=5 destructed
id=2 constructed
id=3 constructed
func
id=3 destructed
main ends
id=6 destructed
id=2 destructed
id=1 destructed
//示例2：复制构造函数和析构函数
class CMyclass {
public:
CMyclass() {};
CMyclass( CMyclass & c){
cout << "copy constructor" << endl;
}
~CMyclass() { cout << "destructor" << endl; }
};
void fun(CMyclass obj_ ) {cout << "fun" << endl;}
CMyclass c;
CMyclass Test( ){
cout << "test" << endl;
return c;
}
int main(){
CMyclass c1;
fun( c1);
Test();
return 0;
}
//输出结果：
copy constructor
fun
destructor //参数消亡
test
copy constructor
destructor // 返回值临时对象消亡
destructor // 局部变量c1消亡
destructor // 全局变量c消亡原文：https://www.cnblogs.com/inchbyinch/p/12153447.html