前言：本文主要是根据MOOC网北大课程——《程序设计与算法（三）：C++面向对象程序设计》内容整理归纳而来，整理的课程大纲详见 https://www.cnblogs.com/inchbyinch/p/12398921.html
本文介绍了类和对象的基础，包括面向对象程序设计的思想、C++的一些特性和类对象的构造与析构。
1 结构化程序设计 VS 面向对象程序设计
C语言使用结构化程序设计，特点：
- 程序 = 数据结构 + 算法
- 程序由全局变量以及众多相互调用的函数组成；算法以函数的形式实现，用于对数据结构进行操作。
结构化程序设计的缺点：
- 结构化程序设计中，函数和其所操作的数据结构，没有直观的联系。这就导致了随着程序规模的增加，程序逐渐难以理解（比如一个函数可以操作哪些数据结构？某个数据结构可以被哪些函数操作？函数之间的关系是怎样的？）
- 结构化程序设计没有“封装”和“隐藏”的概念，要访问某个数据结构中的某个变量，就可以直接访问。这就带来一些问题，比如当某个变量的定义有改动的时候，就要把所有访问该变量的语句找出来修改，程序的扩展性差，且难以查错和重用代码。
为了更清晰的实现变量和函数的关系，使得程序更清晰更易于修改和维护，提出了面向对象的程序设计思想。
C++使用面向对象的程序设计：
- 面向对象的程序 = 类 + 类 + …+ 类；设计程序的过程，就是设计类的过程。
- 面向对象的程序设计具有“抽象”、“封装”、“继承”、“多态”四个基本特点。
- 抽象：将某类客观事物共同特点（属性）归纳出来，形成一个数据结构（可以用多个变量描述事物的属性）；将这类事物所能进行的行为也归纳出来，形成一个个函数，这些函数可以用来操作数据结构。
- 封装：通过某种语法形式，将数据结构和操作该数据结构的函数“捆绑”在一起，形成一个“类”，从而使得数据结构和操作该数据结构的算法呈现出显而易见的紧密关系。
2 C++一些特性
对象的内存分配：
- 和结构变量一样，对象所占用的内存空间的大小，等于所有成员变量的大小之和。
- 每个对象各有自己的存储空间。一个对象的某个成员变量被改变了，不会影响到另一个对象。
- 同类的所有对象共享一组成员函数，成员函数不占用对象空间。
对象间的运算：
- 和结构变量一样，对象之间可以用 “=”进行赋值（赋值所有成员变量），但是不能用 “==”，“!=”，“>”,“<”“>=”“<=”进行比较，除非这些运算符经过了“重载”。
类成员变量和成员函数的使用：
- 对象名.成员名
- 指针->成员名
- 引用名.成员名
类成员的可访问范围：
- 在类的定义中，用三种关键字来说明类成员可被访问的范围。关键字出现的次数和先后次序都没有限制。
- private: 私有成员，只能在成员函数内访问
- public : 公有成员，可以在任何地方访问
- protected: 保护成员，以后再说
- 如过某个成员前面没有上述关键字，则缺省地被认为是私有成员。（struct定义类，和用 "class" 的唯一区别，就是未说明是公有还是私有的成员，就是公有）
- 在类的成员函数内部（从外部空间进入可以看成是一样的），能够访问：
- 当前对象的全部属性、函数；
- 同类其它对象的全部属性、函数。
- 在类的成员函数以外的地方，只能够访问该类对象的公有成员。
设置私有成员的机制，叫“隐藏”，隐藏的目的是强制对成员变量的访问一定要通过成员函数进行，那么以后成员变量的类型等属性修改后，只需要更改成员函数即可。否则，所有直接访问成员变量的语句都需要修改。
成员函数同样可以有重载及参数缺省。
3 构造函数，复制构造函数，类型转换构造函数，析构函数
构造函数（constructor）：
- 成员函数的一种，名字与类名相同，可以有参数，不能有返回值(void也不行)
- 作用是对对象进行初始化，如给成员变量赋初值（系统给对象分配空间后，再调用构造函数，构造函数本身并没有执行分配空间的任务。形象来说，构造函数的工作就是在建好的毛坯房里装修。）
- 如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数（默认构造函数无参数，不做任何操作），如果定义了构造函数，则编译器不生成默认的无参数的构造函数（构造函数最好是public的，private构造函数不能直接用来初始化对象）
- 对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数。
- 一个类可以有多个构造函数，参数个数或类型不同。
- 构造函数在数组中的使用时，数组中每一个对象生成时都调用了一次构造函数。
//示例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）：
- 只有一个参数,即对同类对象的引用；形如 X::X( X& )或X::X(const X &), 二者选一（通常选后者）。（不允许有形如 X::X( X )的构造函数。）
- 如果没有定义复制构造函数，那么编译器生成默认复制构造函数，以完成复制功能。如果已定义，则编译器不会生成默认复制构造函数。
- 复制构造函数起作用的三种情况：
- 当用一个对象去初始化同类的另一个对象时；
- 如果某函数有一个参数是类A的对象，该函数被调用时，类A的复制构造函数将被调用；
- 如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用。
- 注意：
- 对象间赋值并不导致复制构造函数被调用
- 在第二种情况下，调用时生成形参会引发复制构造函数调用，开销比较大。所以通常会使用 (const) CMyclass & 引用类型作为参数。
- 当一个函数有类A的形参，返回值也是类A时，过程细节为：调用该函数时，实参传递给形参时会调用复制构造函数；局部对象在返回时也会调用复制构造函数，将对象值复制给一个无名的临时变量，自身消亡；这个临时对象在之后执行完赋值语句后也会消亡。
类型转换构造函数:
- 定义转换构造函数的目的是实现类型的自动转换。
- 只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数。
- 当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象(或临时变量)。
//示例：类型转换构造函数实例
class Complex {
public:
double real, imag;
Complex(int i) { // 类型转换构造函数.若前有关键词explicit，后面则需显式转换
cout << "IntConstructor1 called" << endl;
real = i; imag = 0;
}
Complex(double r, double i) {
real = r; imag = i;
cout << "IntConstructor2 called" << endl;
}
Complex(const Complex& e) { cout << "copy constructor3 called" << endl; }
~Complex() { cout << "deconstructor callled" << endl; }
};
int main() {
Complex c1(7, 8);
Complex c2 = 12; // 注意：直接调用类型转换构造函数来初始化c2
cout << "hhhhhhh" << endl;
c1 = 9; // 9被自动转换成一个临时Complex对象，以赋值给c1，语句执行完后临时变量消亡
cout << c1.real << "," << c1.imag << endl;
cout << c2.real << "," << c2.imag << endl;
cout << "main end" << endl;
return 0;
}
#输出
IntConstructor2 called
IntConstructor1 called
hhhhhhh
IntConstructor1 called
deconstructor callled
9,0
12,0
main end
deconstructor callled
deconstructor callled
析构函数（destructors）：
- 名字与类名相同，在前面加 ~ ， 没有参数和返回值，一个类最多只能有一个析构函数。
- 析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。(与构造函数类似，析构函数不负责回收空间，它的任务就是拆房子之间把家具搬走。)
- 如果定义类时没写析构函数，则编译器生成缺省析构函数，缺省析构函数什么也不做。如果定义了析构函数，则编译器不生成缺省析构函数。
- 对于数组：
- 对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。
- 若new一个对象数组，那么用delete释放时应该写 []，否则只delete一个对象(调用一次析构函数)
- new出来的空间不delete就不会消亡。
构造函数和析构函数调用时机：
//示例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消亡