构造函数和析构函数

今天你做别人不愿意做的事情，明天你就能做别人做不到的事情

对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供

构造函数和析构函数

编译器提供的构造函数和析构函数是空实现。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数：

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

**构造函数语法：**类名(){}

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

析构函数语法： ~类名(){}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同,在名称前加上符号 ~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前会自动调用析构，无须手动调用,对象生命周期结束时，C++编译系统系统自动调用析构函数。

构造函数的分类及调用

两种分类方式：

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

三种调用方式：

括号法
显示法
隐式转换法

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

拷贝构造函数是构造函数的一个重载形式
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
//注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
//类中声明时可以给默认值
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();
    //void func();对比：函数声明
	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构  没有名字，后面代码无法使用

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器会自动去掉括号，认为是对象声明Person(p3) ===Person p3
	//Person p5(p4);
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

拷贝构造的调用时机

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

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

class person {
public:
	int _age;
	string _name;
public:
	//默认构造
	person()
	{
		cout << "person  默认构造函数" << endl;
	}
	//有参构造函数
	person(int p)
	{
		cout << "person  有参构造函数" << endl;
		_age = p;
	}
	//拷贝构造
	person(const person& p)
	{
		cout << "person  拷贝构造函数" << endl;
		_age = p._age;
		_name = p._name;
	}
	~person()
	{
		cout << "person  析构函数" << endl;

	}
	
};
//使用一个已经创建完毕的对象来初始化一个对象
void test1()
{
	person p1(100);
	person p2(p1);
	cout << "p2的年龄为：" << p2._age << endl;

}
//值传递的方式给函数参数传值  形参是实参的临时拷贝，会调用拷贝构造函数
void  work(person p2)
{

}
void test2()
{
	person p2(10);
	work(p2);
}
//值方式返回局部变量，p3会生成一份临时拷贝并返回，拷贝会调用临时拷贝
person doWork()
{
	person p2;
	person p3;
	cout << (int*)&p3 << endl;
	return p3;
}
void test3()
{
	person p4 = doWork();
	cout << (int*)&p4 << endl; // 两次的地址不同说明了p3 p4 不相同，
}
int main()
{
	//test1();
	//test2();
	test3();
	return 0;
}

##构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：

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

#define _CRT_SECURE_NO_WARNINGS  1
//一定要动手，例子不管多么简单，建议至少自己手敲一遍看看是否理解了里头的细枝末节。
//一定要学会思考，思考为什么要这样，而不是那样。还要举一反三地思考
#include<string>
#include<iostream>
using namespace std;
class person {
public:
	int _age;
	string _name;
	//创建类 c++会给每个类添加至少3个函数
	//构造函数（空实现）
	//析构函数（空实现）
	//拷贝函数（值拷贝）
	//构造函数
	person()
	{
		cout << "person 默认构造函数调用" << endl;
	}
	//有参构造
	person(int p)
	{
		cout << "person 有参构造函数调用" << endl;
		_age = p;
	}
	//拷贝构造
	person(const person& p)
	{
		_age = p._age;
		cout << "person 拷贝构造函数调用" << endl;

	}
	//析构函数
	~person()
	{
		cout << "person 析构函数调用" << endl;
	}
};
//验证：1、如果用户定义了有参构造函数，C++不再提供默认构造，但还会提供拷贝构造
//2.用户定义拷贝构造，C++不再提供其他构造函数（默认构造，，和有参构造）
void test()
{
	person p1(10);
	person p2(p1);
	cout << "p2的_age值为：" << p2._age << endl;

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

深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题

#define _CRT_SECURE_NO_WARNINGS  1
//一定要动手，例子不管多么简单，建议至少自己手敲一遍看看是否理解了里头的细枝末节。
//一定要学会思考，思考为什么要这样，而不是那样。还要举一反三地思考
#include<string>
#include<iostream>
using namespace std;
class person {
public:
	int _age;
	string _name;
	int* _height;
public:
	//默认构造函数
	person()
	{
		cout << "  person 默认构造函数" << endl;
	}
	//参数构造函数
	person(int p,int h)
	{
		_age = p;
		_height = new int(h);
		cout << "  person 参数构造函数" << endl;
	}
	//拷贝构造函数
	person(const person& p)
	{
		/*_age = p._age;
		_name = p._name;
		_height = p._height*/  //编译器拷贝构造函数实现方式   如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		_age = p._age;
		_height = new int(*p._height);
	}
	//析构函数
	~person()
	{
		//析构代码：将堆区开辟的空间是释放操作
		if (_height != NULL)
		{
			delete _height;
			_height = NULL;
		}
		cout << "  person 析构函数" << endl;
	}
};
void test1()
{
	person p1(18,160);
	person p2(p1);
	cout << "p2的年龄为：" << p2._age <<"身高:"<<*p2._height << endl;
	cout << "p2的年龄为：" << p1._age << "身高:" <<* p1._height << endl;

}
int main()
{
	test1();
	return 0;
}

图解：

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

类对象作为类成员

例如：

class person{}
class son{
    person A;
}

B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

#define _CRT_SECURE_NO_WARNINGS  1
//一定要动手，例子不管多么简单，建议至少自己手敲一遍看看是否理解了里头的细枝末节。
//一定要学会思考，思考为什么要这样，而不是那样。还要举一反三地思考
#include<string>
#include<iostream>
using namespace std;
class Phone {
public:
	string p_name;
public:
	Phone(string name)
	{
		cout << "Phone  构造函数调用" << endl;
		p_name = name;
	}
	~Phone()
	{
		cout << "Phone 析构函数调用" << endl;
	}

};
class person {
public:
	string _name;
	Phone i_name;
public:
	person(string name, string p_name):_name(name),i_name(p_name)
	{
		cout << "person 参数构造函数调用" << endl;
	}
	~person()
	{
		cout << " person 析构函数调用" << endl;
	}

};
void test1()
{
	person p1("张三","苹果ProMax");
	cout << p1._name << "拿着" << p1.i_name.p_name << endl;
}
int main()
{
	test1();
	system("pause");
	return 0;
}

结果：

结论：
当类中成员是其他类对象时，我们称该成员为 对象成员
构造的顺序是 ：先调用对象成员的构造，再调用本类构造
析构顺序与构造相反

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：

• 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化
• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

#define _CRT_SECURE_NO_WARNINGS  1
//一定要动手，例子不管多么简单，建议至少自己手敲一遍看看是否理解了里头的细枝末节。
//一定要学会思考，思考为什么要这样，而不是那样。还要举一反三地思考
#include<string>
#include<iostream>
using namespace std;
class person {
public:
	static int _age;
	static int _id;
	string _name;
public:
	static void func()
	{
		_id = 101;
		cout << "我的ID号：" << _id << endl;
		//_name = "君莫笑";静态成员函数不可以访问非静态变量，不知道——name是哪个对象上的 原因：静态成员函数可以通过类名访问，无法确定是哪一个对象
		cout << "调用静态函数" << endl;
	}
	//默认构造函数
	person()
	{
		cout << "person 默认构造函数" << endl;
	}
	//有参构造函数
	person(int p)
	{
		_age = p;
		cout << "person 有参构造函数" << endl;
	}
	~person()
	{
		cout << "person  析构函数调用" << endl;
	}
};
int person::_age = 10;//类外初始化静态成员
int person::_id = 281;//类外初始化静态成员

void test1()
{
	person p1(10);
	cout << "p1的年龄是：" << p1._age << endl;
	person p2;
	p2._age = 100;
	cout << "p1的年龄是：" << p1._age << endl;

}

void test2()
{	
//通过对象来访问
	person p2;
	p2._age = 10;
	cout << p2._age << endl;
	//通过类名来访问
	cout << person::_age << endl;
}
void test3()
{
	//通过对象来访问静态函数
	person p1;
	p1.func();
	//通过类名来访问静态函数数
	person::func();
}

int main()
{
	//test1();
	//test2();
	test3();
	system("pause");
	return 0;
}

初始化列表
虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
初始化列表解决的问题：

1. 必须在定义处初始化的属性：引用 const 自定义类型且没有默认构造时
2. 有些自定义成员想要显示初始化，自己控制
   每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
   类中包含以下成员，必须放在初始化列表位置进行初始化:

1.引用成员变量
2.const成员变量
3.自定义类型成员(且该类没有默认构造函数时)
尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，
一定会先使用初始化列表初始化。

	#include<iostream>
using namespace std;
class son {
private:
	int _a;
public:
	//有参构造，如果我们提供了有参构造，则编译器不会提供默认构造函数
	son(int a )
		:_a(a)
	{
		cout << "int a = 0" << endl;
	}
};
class time1 {
private:
	//声明
	int _year = 10; //10是缺省值//这个缺省值是给初始化列表的，
	const int _month; //const：必须在定义是初始化
	int& _day;  //引用:必须在定义是初始化
	son _abc;   //自定义类型，没有默认构造函数
public:
	time1(int year, int month, int day)
		:_month(month)
		, _day(day)
		,_abc(10)
	{
		//_year没有在初始化列表中显式的写出来定义，但是初始化列表也会定义，初始值为随机值
		// 如果是自定义类型会调用他的默认构造函数，没有默认构造函数则在初始化列表中初始化
		//函数体内初始化
		this->_year = year;
	}
};
void test01()
{
	time1 s(2023, 11, 16);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

注意：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
次序无关，建议声明属性和初始化列表的属性顺序保持一致，否则可能会导致理解问题。

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}

	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;//因为_a2先出现，所以先初始化_a2,但由于_a1此时还未显式初始化，故初始化列表将_a1初始化为随机值，故_a2为随机值。
};
int main() {
	A aa(1);
	aa.Print();
}

好啦，关于构造函数和析构函数就先学到这，如果对您有所帮助，欢迎一键三连，您的支持是我创作的最大动力