1. 类的6个默认的成员变量

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

注意：这里的“默认”和“缺省”的意思差不多，也就是你不写这6个函数，编译器会自动生成，你若是写了，则编译器就不生成了。

2. 构造函数

2.1 概念

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

2.2 特性

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

其特征如下:

· 函数名与类名相同
· 无返回值
· 对象实例化编译器自动调用对应的构造函数
· 构造函数可以重载

class Date
{
public:// 构造函数// 1.无参构造函数Date(){}// 2. 有参构造Date(int year, int month, int day){_year = year;_month = month;_day = day;}// 3.全缺省//Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//
private:int _year;int _month;int _day;
};
void test(){Date d1;//调用无参构造函数Date d2(2022,1,18);//调用带参的构造函数
}

注意:如果类中没有显示定义构造函数,则在类实例化的时候， C++编译器会自动生成一个无参的默认构造函数,一旦用户显示定义编译器将不再自动生成.
默认构造函数有三种:

1. 编译器默认生成的构造函数(对内置类型不会处理，还是随机值；对于自定义类型会去调用他们自己的构造函数初始化);
2. 全缺省构造函数
3. 无参构造函数

3. 析构函数

3.1 概念

概念:**局部对象销毁工作是由编译器完成的。**而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

实例化对象:(栈是后进先出 ；堆是先进先出)

例如：

class A
{
public:A(){cout << "A()" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;
};class B
{
public:B(){cout << "B()" << endl;}~B(){cout << "~B()" << endl;}
private:int _b;
};int main()
{A a;B b;return 0;
}
// 因为对象是定义在函数中，函数调用会建立栈帧，// 栈帧中的对象构造和析构也要很符合后进先出。// 所以这里的顺序是: A()->B()->~B()->~A()

运行结果：

4. 拷贝构造函数

4.1 概念

拷贝构造函数也是构造函数的一种。普通的构造函数可以是无参的，也可以是有参的。但是拷贝构造函数必须是有参的，如下所示，参数就是const类型的对象引用：

class Car
{
public:Car() // 普通的构造函数{cout << "Car()" << endl;}Car(const Car &car)	 // 拷贝构造函数，参数是const类型的对象引用{cout << "Car():(const Car &car)" << endl;}};

那什么时候调用拷贝构造函数呢？
回答:
当利用已存在的对象创建一个新对象时（拷贝对象），就会调用新对象的拷贝构造函数进行初始化新对象的成员变量。

int main()
{//创建对象，调用普通的构造函数 Car car1; //cout << "Car()" << endl;// 利用已经存在的对象，创建新对象，叫做拷贝对象，拷贝对象创建，就会调用拷贝构造函数Car car2(car1);	 // cout << "Car():(const Car &car)" << endl;getchar();return 0;
}

4.2 拷贝了什么？

拷贝了内存中的东西！也就是可瓯北了原有对象的成员。

class Car
{int m_price;int m_length;
public:Car(int price = 0 ,int length = 0): m_price(price),m_length(length)	// 普通的构造函数{cout << "Car():m_price(price),m_length(length)" << endl;}void display(){cout << "m_price = " << m_price << " m_length = " << m_length << endl;}};int main()
{Car car3(100, 20);car3.display();// 利用已经存在的对象，创建新对象，叫做拷贝对象Car car4(car3);	car4.display(); // m_price = 100 m_length =20return 0;
}

此时car4对象内存空间里，也有这两个成员变量，且都有值。这就叫对象的拷贝操作，把对象里的成员变量都拷贝过来，成员变量的值也拷贝过来。注意：此时，我在类中并没有声明拷贝构造函数。

car4依然可以把car3里的成员变量拷贝过来。就类似于下面的拷贝方式，直接把car3对象的值赋值给car4。

当我再次拷贝car3对象时，car4打印的成员变量值是乱码，意味着并没有讲car3的值拷贝过来

Car car4(car3);	
car4.display(); // m_price = -827381223 m_length =-827381223

4.3 拷贝构造函数的功能

拷贝构造函数既然是构造函数的一种，那必然是用来初始化成员变量的。既然是拷贝构造函数，那必然是用来初始化拷贝对象的成员变量的（也就是我们例子中的car4对象）。当我在类中自己定义拷贝构造函数，那也就意味着系统默认的拷贝操作不存在了，因为会调用自己默认的拷贝构造函数。

我们想要解决刚才的那个问题，只需要在拷贝构造函数里将传进来的对象的成员变量赋值给当前对象的成员变量即可（不写this也行）。

class Car
{int m_price;int m_length;
public:Car(int price = 0 ,int length = 0): m_price(price),m_length(length)	// 普通的构造函数{cout << "Car():m_price(price),m_length(length)" << endl;}Car(const Car &car)	 // 拷贝构造函数{cout << "Car():(const Car &car)" << endl;this->m_price = car.m_price;  // 将传进来的car的对象，传递给新创建的对象，不写this一样this->m_length = car.m_length;}void display(){cout << "m_price = " << m_price << " m_length = " << m_length << endl;}
};

这样再次拷贝的时候，就调用默认自定义的拷贝构造函数了。

Car car4(car3);	//将car4的地址值，传递给拷贝构造函数的this指针
car4.display(); // m_price = 100 m_length =20

4.4 为什么要有拷贝构造函数

（思考浅拷贝，深拷贝的问题）
如果我在类中定义了拷贝构造函数，那么拷贝对象创建的时候，就会直接调用自定义的拷贝构造函数。假如，此时拷贝构造函数里没有成员变量的拷贝，那结果就不会有成员变量的拷贝

如果我在类中没有定义拷贝构造函数，当我拷贝对象创建的时候，就会默认对成员变量进行拷贝，就不要额外写成员变量拷贝的代码

所以，如果重写拷贝构造函数，就必须自己手动的进行成员变量的拷贝。如果没有重写拷贝构造函数，那就啥事也没有，编译器会默认帮你拷贝类中所有的成员变量。

通过上面的例子发现，似乎不重写拷贝构造函数也能完成对象的拷贝。同时，写了拷贝构造函数之后，还需要手动的完成赋值操作，反而麻烦了。

但拷贝构造函数的奥义远不如此，我们这里先埋下一个伏笔，等我们了解了浅拷贝和深拷贝之后，再来回答这个问题。（如果类内成员变量都是基本数据类型：int、double…，不写拷贝构造函数完全没有问题）

导航回来，意味着我们了解了深拷贝和浅拷贝的区别。回答我们提出的问题：为什么要写拷贝构造函数？

当类中的成员变量有指针变量时，如果不重写拷贝构造函数，编译器默认的拷贝操作是浅拷贝操作。也就意味着仅仅将指针变量的地址值拷贝过去，而不会将指针指向存储空间里的内容拷贝过去。

所以，当类中成员变量有指针变量时，如果想要实现拷贝对象操作，则必须重写拷贝构造函数。

参考：
https://blog.csdn.net/weixin_45452278/article/details/125397565