类的6个默认成员函数
如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。

构造函数

概念

对于以下的日期类：

class Date
{
public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Init(2020, 10, 9);d1.Print();return 0;
}

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法初始化信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

特性

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date
{
public://1.无参构造函数Date(){}//2.带参构造函数Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};int main()
{Date d1; //调用无参构造函数Date d2(2021, 10, 9);//调用带参的构造函数//注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明//以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象Date d3();
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Date
{
public://如果用户显示定义了构造函数，编译器将不再生成/*Date(int year, int month, int day){_year = year;_month = month;_day = day;}*/
private:int _year;int _month;int _day;
};int main()
{//没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数Date d;return 0;
}

6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。（本来是可以构成函数重载的，但他们两同时存在会出现歧义，Date d;编译器就不知道调谁了）注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数（不传参数就可以调用的就是）。 其中编译器默认生成的构造函数也可以是自定义类中我们写的构造函数

//默认构造函数
class Date
{
public:/*Date(){_year = 1900;_month = 1;_day = 1;}*///一般情况下，推荐直接写一个全缺省的构造函数，因为非常好用Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};

关于编译器生成的默认成员函数，在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象year/month/_day，依旧是随机值。那在这里编译器生成的默认构造函数有什么用？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员A调用的它的默认成员函数。

class A
{
public:A()//必须无参{_a1 = 0;_a2 = 1;cout << "A()" << endl;}
private:int _a1;int _a2;
};class Date
{
private://内置类型int _year;int _month;int _day;//自定义类型 struct/classA _aa;
};int main()
{Date d1;return 0;
}

其实这里可以看到，这种偏心的处理导致语法反而复杂了，但是因为要向前兼容，所以不能改动。C++11的时候，语法委员会为这里打了一个补丁。

class Date
{
private://内置类型int _year=0;int _month=1;int _day=1;//自定义类型 struct/classA _aa;
};

这里成员变量只是定义，不是初始化。就像函数缺省参数一样，给的是缺省值。

成员变量的命名风格：

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:Date(int year){// 这里的year到底是成员变量，还是函数形参？year = year;}
private:int year;
};
// 所以一般可以这样写
class Date
{
public:Date(int year){_year = year;}
private:int _year;
};

按照局部优先原则，year=year;左边的year会先去找形参中的year，找到了那就是函数形参。也可以在year前加this，this->year=year;这样实例化对象时year就是成员变量的year。

析构函数

概念

我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

像Date这样的类是不需要析构函数的，因为他内部没有什么资源需要清理。

特性

析构函数是特殊的成员函数。
其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。

class Stack
{
public:Stack(int capacity = 4){_a = (int*)malloc(sizeof(int) * capacity);if (_a == nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}~Stack(){//像Stack这样的类，对象中的资源需要清理工作，就用析构函数free(_a);_a = nullptr;_top = _capacity = 0;}
private:int* _a;int _top;int _capacity;
};int main()
{Stack st;return 0;
}

在我们用两个栈实现队列中，对于MyQueue，就可以不写构造函数，让编译器自动生成的构造函数和析构函数都可以完成使命。

class MyQueue
{
private:Stack _pushST;Stack _popST;
};
int main()
{//Stack st;MyQueue mq;return 0;
}

拷贝构造函数

概念

构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Date
{
public:Date(int year = 1900, 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;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;Date d2(d1);return 0;
}

3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

我们不写，编译器默认生成的拷贝构造，和构造、析构又不太一样。它不会区分内置类型和自定义类型成员，都会处理。
1.内置类型，字节序的浅拷贝（按字节序的拷贝，就像用memcpy完成拷贝）。
2.自定义类型，会调用他的拷贝构造完成拷贝。

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;Date d2(d1);return 0;

那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。
以上面的栈为例，再：Stack st1; Stack st2(st1);
编译器将会报错