【C++类和对象Lesson2】构造函数与析构函数

朋友们好,这篇播客我们继续C++的初阶学习，现在对我们对C++非常重要的一个知识点做出总结，整理出来一篇博客供我们一起复习和学习,如果文章中有理解不当的地方,还希望朋友们在评论区指出,我们相互学习,共同进步!

对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全。C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

一：构造函数

对象的初始化和清理也是两个非常重要的安全问题，一个对象或者变量没有初始状态，对其使用后果是未知。c++利用了构造函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器也会提供，编译器提供的构造函数和析构函数是空实现。

构造函数是一个特殊的成员函数，名字与类名相同，实例化类对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次
⚠️构造函数语法：类名(){}

1.1：构造函数的特性

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

1️⃣ 1. 构造函数，没有返回值也不写void
2️⃣ 2. 函数名称与类名相同
3️⃣3. 构造函数可以有参数，因此可以发生重载
4️⃣4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

	Date(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.Print();

	Date d2(2022, 5, 15);      //调用带参的构造
	d2.Print();

	system("pause");
	return 0;
}

5️⃣ 5. 如果类中没有显式定义的构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6️⃣6. 无参的构造函数和全缺省的构造函数都被称为默认构造函数，并且默认构造函数只有一个。注意：无参构造函数、全缺省构造函数、以及我们没显式写由编译器默认生成的构造函数，都可以认为是默认构造函数。即不用传参就可以调用的函数

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//默认全缺省构造函数
	{
	_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.Print();

	Date d2(2022, 5, 15);     
	d2.Print();

	Date d3(2022);
	d3.Print();

	Date d4(2022, 10);
	d4.Print();

	system("pause");
	return 0;
}

1-1-1
2022-5-15
2022-1-1
2022-10-1
请按任意键继续. . .

7️⃣7. 默认生成构造函数对于内置类型成员变量不做处理，因为编译器默认生成的构造函数都是空实现，对于自定义类型成员变量做出处理，相当于实例化对象自动调用该类的默认构造函数！如下述代码中Date date和A _aa有什么区别呢？不都是实例化对象自动调用默认构造函数吗！！！
代码示例：

class A
{
public:
	A(){
		cout << " A()" << endl;
		_a = 0;
	}
private:
	int _a;
};

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日

	A _aa;
};

int main(){
	Date date;
	date.Print();
	system("pause");
	return 0;
}

 A()
-858993460--858993460--858993460
请按任意键继续. . .

默认构造函数不会对自己的变量初始化，会对自定义类型处理，自定义类型成员会去调用它的默认构造函数！因为这里实例化对象也只能调用默认构造函数！！！（如果自定义类型的构造函数没有显示定义，也会是随机值）。
接下来我们利用代码详细看看上面这段话：
示例1：默认生成的默认构造函数

class Stack
{
public:
	
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue {
public:
	// 默认生成构造函数就可以用了
	void push(int x) {
	}
	int pop() {
	}

private:
	Stack _st1;
	Stack _st2;
};

int main()
{
	MyQueue q;
	q.push(1);
	//Stack st;

	system("pasue");
	return 0;
}

上面这段代码是可以编译过的，在Myqueue类中只有自定义类型，所以我们不需要写构造函数，使用默认生成的即可。然后Myqueue类中声明Stack类实例化对象时，会去调用Stack类的默认构造函数（这里是自动生成的默认构造函数），编译通过！
这里咋们看监视界面：

由于Stack的默认构造函数是默认生成的，同样不会对内置类型成员变量做初始化，所以显示是随机值！
示例2：无参默认构造

class Stack
{
public:
	Stack()
	{
	_a = nullptr;
	_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue {
public:
	// 默认生成构造函数就可以用了
	void push(int x) {
	}
	int pop() {
	}

private:
	Stack _st1;
	Stack _st2;
};

int main()
{
	MyQueue q;
	q.push(1);
	//Stack st;

	system("pasue");
	return 0;
}

这段代码也是可以编译过的，在Myqueue类中只有自定义类型，所以我们不需要写构造函数，使用默认生成的即可。然后Myqueue类中声明Stack类实例化对象时，会去调用Stack类的默认构造函数（这里是咋们自己提供的默认构造函数），编译通过！
同样的，我们看监视界面：

由于Stack的默认构造函数是是我们自己提供的，同时对内置类型做了初始化，所以这里的各个值不再是随机值！
示例3：全缺省默认构造函数

class Stack
{
public:
	Stack(int capacity = 10)
	{
	_a = (int*)malloc(sizeof(int)*capacity);
	assert(_a);

	_top = 0;
	_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue {
public:
	// 默认生成构造函数就可以用了
	void push(int x) {
	}
	int pop() {
	}

private:
	Stack _st1;
	Stack _st2;
};

int main()
{
	MyQueue q;
	q.push(1);
	//Stack st;

	system("pasue");
	return 0;
}

这段代码也是可以编译过的，在Myqueue类中只有自定义类型，所以我们不需要写构造函数，使用默认生成的即可。然后Myqueue类中声明Stack类实例化对象时，会去调用Stack类的默认构造函数（这里是咋们自己提供的全缺省默认构造函数），编译通过！
同样的，观察监视界面：

我们通过全缺省默认构造函数对各个值做出了初始化，因此不再是随机值！
错误示例：有参构造函数

class Stack
{
public:
	Stack(int capacity)
	{
	_a = (int*)malloc(sizeof(int)*capacity);
	assert(_a);

	_top = 0;
	_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue {
public:
	// 默认生成构造函数就可以用了
	void push(int x) {
	}
	int pop() {
	}

private:
	Stack _st1;
	Stack _st2;
};

int main()
{
	MyQueue q;
	q.push(1);
	//Stack st;

	system("pasue");
	return 0;
}

程序报错！

因为我们在Stack类中提供了一个有参构造函数，这时Stack类中不再有默认构造函数，因此Myqueue的默认构造函数无法调用Stack的默认构造函数，编译不通过！

C++11还支持在声明的时候给内置类型变量赋一个缺省值：

class MyQueue
{
private:
	int _size = 0;//这里不是初始化，因为这里是声明
	Stack _st1;
	Stack _st2;
};

总结：如果一个类中的成员全是自定义类型，我们就可以不写构造函数，就用默认生成的构造函数。如果有内置类型的成员，或者需要显示传参初始化，那么都要自己实现构造函数。

1.2：构造函数的分类

两种分类方式：

• 按参数分为： 有参构造和无参构造
• 按类型分为： 普通构造和拷贝构造

二：析构函数

2.1：概念

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

2.2：特性

语法：~类名(){}

1️⃣1. 析构函数，没有返回值也不写void
2️⃣ 2. 函数名称与类名相同,在名称前加上符号 ~
3️⃣ 3. 析构函数不可以有参数，因此不可以发生重载
4️⃣ 4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

class Person
{
public:
	//构造函数
	Person(){
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person(){
		cout << "Person的析构函数调用" << endl;
	}

};

void test01(){
	Person p;
}

int main() {

	test01();
	system("pause");
	return 0;
}

Person的构造函数调用
Person的析构函数调用
请按任意键继续. . .

如结果表示，在对象销毁之前编译器自动调用了析构函数。

🍊同样的，我们也可以自己提供析构函数来对类上的一些资源完成清理工作（而不是对象销毁）。
示例：

typedef int DataType;
class SeqList{
public:
	SeqList(int capacity = 10){
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}

	~SeqList(){
		if (_pData){
			free(_pData);
			_pData = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	int * _pData;
	size_t _size;
	size_t _capacity;
};

int main(){
	SeqList Sq;
	system("pause");
	return 0;
}

如上述代码，在构造函数中在堆区开辟了空间，这时就需要我们自己提供析构函数来释放对应的空间。

注意：默认生成的析构函数（空实现），内置类型成员不做处理，自定义类型成员会去调用它的析构函数

三：拷贝构造函数

3.1：概念

在现实生活中我们会遇到两个小孩长得一摸一样，我们称其为双胞胎。

拷贝构造，顾名思义就是在创建对象的时候，创建一个与原对象一摸一样的新对象。
构造函数：参数列表只有单个形参，该形参是对本类类型对象的引用（一般用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。
如下列代码：

class Person {
public:
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {      //<看这里，形参是对本类类型对象的引用
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

void test01()
{
	Person p1(18);
	//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
	Person p2(p1);  //Person p2 = Person(p1);
	cout << "p2的年龄为： " << p2.age << endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}

3.2：特性

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

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个，且必须使用引用传参，使用传值方式会引发无穷递归调用（因为传值传参也会调用拷贝构造函数）。
3. 如果没有显示定义拷贝构造函数，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种通常称为浅拷贝，或者值拷贝。

🍎浅拷贝：

• 指向一块空间，修改数据会相互影响。
• 这块空间析构时会释放两次，导致程序崩溃。

编译器生成的默认拷贝函数已经完成了字节序的值拷贝了，那我们还需要自己实现吗？我们看一段代码实例：

typedef int DataType;
class SeqList{
public:
	SeqList(int capacity = 10){
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}

	~SeqList(){
		if (_pData){
			free(_pData);
			_pData = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	int * _pData;
	size_t _size;
	size_t _capacity;
};

int main(){
	SeqList Sq1;//调用默认构造函数初始化Sq1
	SeqList Sq2(Sq1);
	system("pause");
	return 0;
}

代码解释：编译器先调用默认构造函数初始化Sq1，然后用类对象Sq1初始化类对象Sq2，我们使用编译器提供的默认拷贝构造函数实现浅拷贝，这时程序就会出现问题了！
虽然语法编译能通过：

但是运行程序终究会是报错的！

我们注意到在初始化Sq1的时候我们在堆区开辟了地址，如果我们这时浅拷贝初始化Sq2，那么在调用析构函数的时候会造成对同一块空间重复释放，所以造成程序崩溃！

3.3：拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况：

1️⃣ 1. 使用一个已经创建完毕的对象来初始化一个新对象

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
}

int main() {
	test01();
	system("pause");
	return 0;
}

2️⃣ 2. 值传递的方式给函数参数传值

//这里代码都旨在说明目的，代码不全！
void doWork(Person p1) {//相当于Person p1 = p;
	//
}
void test02() {
	Person p; //无参构造函数
	doWork(p);
}

3️⃣ 3. 以值方式返回局部对象

//这里代码都旨在说明目的，代码不全！
Person doWork2(){
	Person p1;
	cout << (int *)&p1 << endl;
	return p1;
}

void test03(){
	Person p = doWork2();
	cout << (int *)&p << endl;
}
int main() {
	test03();
	system("pause");
	return 0;
}

这里可以看作Person p = p1；也相当于调用拷贝构造函数。

3.4：构造函数调用规则

⚠️默认情况下，c++编译器至少给一个类添加3个函数：

1. 默认构造函数(无参，函数体为空)
2. 默认析构函数(无参，函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝

🍎构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造。
• 如果用户定义拷贝构造函数，c++不会再提供其他构造函数。

构造函数与析构函数的介绍就先到这里了，如果对您有帮助还希望三连支持一下 ，谢谢啦！