二、类的默认6个成员函数
如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数，默认成员函数：用户没有显式实现，编译器会生成的函数称为默认成员函数。
构造函数主要完成初始化工作
析构函数主要完成清理工作
拷贝构造是使用同类对象初始化创建对象
赋值重载主要是把一个对象赋值给另一个对象
完成取地址重载的两个函数很少会自己实现所以就不在讲解
构造函数
构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。
构造函数的特性：1.函数名与类名相同
2.无返回值
3.对象实例化时编译器自动调用对应的构造函数
4.构造函数可以重载
class Stack { public: Stack(int capcity = 0,int top = 0) { _capcity = capcity; _top = top; } void Print() { cout << "_capcity:" << _capcity << endl; cout << "_top:" << _top << endl; } private: int* a; int _capcity; int _top; }; int main() { Stack st; Stack st1(10, 4); st.Print(); st1.Print(); return 0; }
无参构造函数和带参构造函数的调用方式是不一样的，上面的代码我们在构造函数中用了缺省值的方式，必须要说明的是无参构造函数直接Stack st;即可，也就是说对象实例化创建后就会调用，而带参的构造函数必须在后面加括号写入参数入上图中st1一样。
需要注意的是：
class Date { public: Date() { _year = 1; _month = 1; _day = 1; } Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; } public: int _year; int _month; int _day; }; int main() { Date d1; d1.Print(); return 0; }
像上图中这样的情况，语法本身并没有问题，是因为编译器无法分清无参的构造函数和带缺省参数的构造函数，解决的方法为调用是以带参构造函数的方式去调用。
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数 （原因是会产生歧义）
我们之前已经说过，在实例化对象的时候必须调用构造函数，如果我们不写编译器会给一个默认的构造函数，那么我们就看看默认的构造函数可以完成对象的初始化吗
class Date { public: void Print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; } public: int _year; int _month; int _day; }; int main() { Date d1; d1.Print(); return 0; }
可以看到我们是没有写构造函数的。
当我们调用的时候发现好像编译器默认的构造函数好像并不能完成初始化，这是怎么回事呢？这是因为c++把类型分为内置类型（基本类型）和自定义类型。内置类型就是语言提供的数据类型，如int/char...等，自定义类型就是我们使用class/struct/union等自己定义的类型，而编译器生成的默认构造函数会对自定义类型成员调用它的默认成员函数。
也就是说默认生成的构造函数，对内置类型成员不做处理。自定义类型成员会去调用它的默认构造(不用传参数的构造)
class MyQueue { public: //默认生成的构造函数对自定义类型，会调用它的默认构造函数 void Push(int x) { } Stack _pushST; Stack _popST; }; int main() { MyQueue mq; return 0; }
从上图中我们发现默认构造函数对于自定义类型会进行初始化 。析构函数作为专门初始化的函数大多人都认为应该将内置类型也初始化了而不是只针对自定义类型，针对这个问题在c++11中打入了一个补丁，就是可以直接给内置类型变量一个缺省值，什么意思呢？看下面代码：
class Date { public: void Print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; } public: int _year = 1; int _month = 1; int _day = 1; }; int main() { Date d1; d1.Print(); return 0; }
通过这个补丁就能解决内置类型初始化的问题了。
析构函数
与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的，而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数的特性：1.析构函数是在类名前加上~
2.无参数无返回值类型
3.一个类只能有一个析构函数，若未显式定义，系统会自动生成默认的析构函 数。注意：析构函数不能重载。
4.对象生命周期结束时，c++编译系统系统自动调用析构函数
class Stack { public: Stack(int capcity = 0,int top = 0) { _capcity = capcity; _top = top; } void Print() { cout << "_capcity:" << _capcity << endl; cout << "_top:" << _top << endl; } ~Stack() { cout << "这是析构函数" << endl; } private: int* a; int _capcity; int _top; }; int main() { Stack st; Stack st1(10, 4); st.Print(); st1.Print(); return 0; }
我们在return处打了一个断点然后F5跳到断点处F11进入函数发现进入到了析构函数中并且打印了
默认生成的析构函数与默认生成的构造函数一样，对内置类型成员不做处理。自定义类型成员会去调用它的默认析构函数。析构函数的调用遵循后进先出原则，也就是说后定义的对象先进行析构函数的调用。
class Time { public: Time() { cout << "Time()" << endl; } ~Time() { cout << "~Time()" << endl; } private: int _hour; int _minute; int _second; }; class Date { private: // 基本类型(内置类型) int _year = 1970; int _month = 1; int _day = 1; // 自定义类型 Time _t; }; int main() { Date d; return 0; }
在main中根本没有创建Time类的对象，但还是打印了Time和~Time，可见析构函数确实会对自定义类型调用其自己的析构函数。（构造函数同理）
拷贝构造函数
只有单个形参，该形参是本类类对象的引用（一般常用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。
1.拷贝构造函数是构造函数的一个重载形式 以下是拷贝构造函数实例：
class Date { public: Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } Date(const Date& d) { _year = d._year; _month = d._month; _day = d._day; } void Print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; } public: int _year ; int _month ; int _day ; }; int main() { Date d1; Date d2(d1); //调用拷贝构造函数 d1.Print(); d2.Print(); return 0; }
我们可以看到d2确实和d1的参数是一样的说明拷贝成功了。
const修饰能起到什么作用呢？我们都知道加const修饰就是为了不被修改，看以下代码：
这里加const其实是为了防止将谁是谁的拷贝的位置写错了，一旦写错不加const那么用来拷贝的那个类里面的东西都被修改了。
当然用const修饰还有第二个好处，那就是防止权限的放大。
就如图中我们定义了一个const的对象，再调用拷贝构造时发现报错了，原因是d1本来是const this*,到了拷贝构造函数中变成了this*权限放大了，想要解决在拷贝构造的函数参数中加上const即可。
2.拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
为什么会引发无穷递归调用呢，那是因为我们在传值传参的时候只要是自定义类型那么编译器会自动调用拷贝构造函数，举个例子：Date(Date d)如果这是拷贝构造函数，在调用这个函数的时候发现参数为自定义的Date类型那么就会调用拷贝构造函数又出现了Date(Date d)然后一直无穷递归下去，而使用引用为什么会避免呢？因为引用就是他本身再调用也是他本身不会再去调用新的拷贝构造函数。那么为什么编译器不能去拷贝自定义类型呢？
想要解决这样的问题就直接在拷贝构造函数中重新给要拷贝的对象开和被拷贝对象同样的空间，这样他们两个的地址不同在释放内存的时候就不会崩溃了。
3.日期类不需要写拷贝构造，因为内置类型编译器也会处理。
class Date { public: Date(int year = 10, int month = 10, int day = 10) { _year = year; _month = month; _day = day; } void print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2(d1); d2.print(); return 0; }
通过上面的代码我们可以发现即使我们不写拷贝构造函数编译器也能完成日期类的拷贝，那么自定义类型可以吗？
typedef int DataType; class Stack { public: Stack(size_t capacity = 10) { cout << "Stack(size_t capacity = 10)" << endl; _array = (DataType*)malloc(capacity * sizeof(DataType)); if (nullptr == _array) { perror("malloc申请空间失败"); exit(-1); } _size = 0; _capacity = capacity; } void Push(const DataType& data) { // CheckCapacity(); _array[_size] = data; _size++; } ~Stack() { cout << "~Stack()" << endl; if (_array) { free(_array); _array = nullptr; _capacity = 0; _size = 0; } } private: DataType *_array; size_t _size; size_t _capacity; }; int main() { Stack s1; Stack s2(s1); return 0; }
我们以栈为例，运行后发现程序崩溃了，这是因为编译器默认的拷贝方式是浅拷贝这里我们在上面已经讲过这个拿图来看：
我们调试发现确实两个栈的地址是一样的，所以在析构函数释放空间的时候两个对象释放两次导致崩溃了。解决方式如下：
typedef int DataType; class Stack { public: Stack(size_t capacity = 10) { cout << "Stack(size_t capacity = 10)" << endl; _array = (DataType*)malloc(capacity * sizeof(DataType)); if (nullptr == _array) { perror("malloc申请空间失败"); exit(-1); } _size = 0; _capacity = capacity; } void Push(const DataType& data) { // CheckCapacity(); _array[_size] = data; _size++; } Stack(const Stack& s) { _array = (DataType*)malloc(sizeof(DataType) * s._capacity); if (_array == nullptr) { perror("malloc:"); exit(-1); } memcpy(_array, s._array, sizeof(DataType) * s._size); _capacity = s._capacity; _size = s._size; } ~Stack() { cout << "~Stack()" << endl; if (_array) { free(_array); _array = nullptr; _capacity = 0; _size = 0; } } private: DataType *_array; size_t _size; size_t _capacity; }; int main() { Stack s1; Stack s2(s1); return 0; }
通过上面这个例子我们能得出结论，对于内置类型编译器的默认拷贝构造函数可以通过浅拷贝完成拷贝，但是像栈这样的自定义类型默认的拷贝构造函数不仅无法正确拷贝还会引发错误。
那么什么情况下需要自己写拷贝构造呢？
结论：自己实现了析构函数释放空间，就需要实现拷贝构造。
那么下面这样的代码需要自己写拷贝构造吗？
typedef int DataType; class Stack { public: Stack(size_t capacity = 10) { cout << "Stack(size_t capacity = 10)" << endl; _array = (DataType*)malloc(capacity * sizeof(DataType)); if (nullptr == _array) { perror("malloc申请空间失败"); exit(-1); } _size = 0; _capacity = capacity; } void Push(const DataType& data) { // CheckCapacity(); _array[_size] = data; _size++; } Stack(const Stack& s) { _array = (DataType*)malloc(sizeof(DataType) * s._capacity); if (_array == nullptr) { perror("malloc:"); exit(-1); } memcpy(_array, s._array, sizeof(DataType) * s._size); _capacity = s._capacity; _size = s._size; } ~Stack() { cout << "~Stack()" << endl; if (_array) { free(_array); _array = nullptr; _capacity = 0; _size = 0; } } private: DataType *_array; size_t _size; size_t _capacity; }; class MyQueue { public: // 默认生成构造 // 默认生成析构 // 默认生成拷贝构造 private: Stack _pushST; Stack _popST; int _size = 0; }; int main() { MyQueue q1; MyQueue q2(q1); return 0; }
通过上图我们就知道了答案是不需要，因为自定义类型会去调用它自己的拷贝构造，而栈的拷贝构造我们已经实现了所以不需要。
什么情况下会调用拷贝构造呢？1.显式调用（就是自己要去时候拷贝构造） 2.传值传参（比如参数是自定义类型） 3.自定义类型做返回值 。
所以为了减少空间的消耗那么能用引用尽量去用引用。
总结
c++初学者对于学习构造函数，拷贝构造，析构函数是一大难点，所以想要真正的了解必须多练习多调试多思考，只有基础好了才能建高楼！
下一期是c++前期的重点运算符重载等的学习。
