C++ 类与对象中的构造函数与析构函数认识（一）_c++ 逆向怎么判断构造函数和析构函数-CSDN博客

本文链接：https://blog.csdn.net/NavyGH/article/details/130209977

1.构造函数与析构函数

如果我们不创建构造函数与析构函数，那么编译器也会创建，只是编译器创建的是空实现。

例如：创建一个类Person,我们需要初始化和清理对象。

类：

class Person
{
    
   ... 

}；

构造函数：

进行初始化操作
没有返回值不用写void
函数名与类名一致
构造函数可以有参数可重载
创建对象时会自动调用且只调用一次

Person()
{
	cout << "Person 构造函数的调用" << endl;
}

析构函数

进行清理操作
没有返回值不用写void
函数名 ~+类名
构造函数无参数不可重载
销毁对象前会自动调用且只调用一次

~Person() 
{
	cout << "Person 析构函数的调用" << endl;
}

创建函数test01 测试

void test01() 
{
	Person p; //栈上的数据，test01运行完,释放这个对象
}

2.构造函数的分类和调用：

例如：类：

class Person
{
    
   int age;
}；

分类： 构造函数分为 默认构造函数（无参）、有参构造函数、拷贝构造函数

默认构造函数（无参）：

Person()
{
	cout << "Person 无参构造函数的调用" << endl;
}

有参构造函数：

Person(int a)
{
	age = a;
	cout << "Person 有参构造函数的调用" << endl;
}

Person(const Person &p)
{
	age = p.age;
	cout << "Person 拷贝构造函数的调用" << endl;
}

调用：括号法、显式法、隐式转换法

括号法：

Person p1; //默认构造（无参）函数调用
Person p2(10);//有参构造调用
Person p3(p2);//拷贝构造调用

注意：调用默认构造函数时候，不要加()
因为编译器会认为Person p1();是一个函数的声明 ,如同void func(); 而不会认为是创建对象.

显式法：

Person p1;             //默认构造
Person p2 = Person(10);//有参构造
Person p3 = Person(p2);//拷贝构造

其中，

Person(10);//匿名对象 当前执行结束后会立即销毁这个匿名对象

注意：Person(p3);是不被允许的。不可以利用拷贝对象函数来初始化匿名对象编译器认为 Person(p3) === Person p3。

隐式转换法：

Person p1;     //默认构造
Person p2 = 10;//有参构造
Person p3 = p2;//拷贝构造

3.拷贝构造函数的调用时机：

例子，类与构造、析构函数：

class Person
{
public:
	
	Person()
	{
		cout << "Person 默认构造函数的调用" << endl;
	}
	Person(int a)
	{
		m_Age = a;
		cout << "Person 有参构造函数的调用" << endl;
	}
	Person(const Person& p)
	{
		m_Age = p.m_Age;
		cout << "Person 拷贝构造函数的调用" << endl;
	}
	
	~Person() {
		cout << "Person 析构函数的调用" << endl;
	}
	int m_Age;
};

（1）使用一个已经创建完毕的对象来初始化一个新对象

void test01()
{
	Person p1(20);//有参构造函数
	Person p2(p1);//拷贝构造函数

	cout << "P2的年龄为: " << p2.m_Age << endl;
}

测试：

（2）值传递的方式给函数参数传值


void doWork(Person p) 
{
	 //形参不会修饰实参
} 

void test02()
{
	Person p; //默认构造函数
	doWork(p);//拷贝构造函数  值传递 实参传递给形参 
}

测试：

4.构造函数的调用规则

默认情况下,c++编译器至少给一个类添加3个函数
1.默认构造函数(无参,函数体为空)
2.默认析构函数(无参,函数体为空)
3.默认拷贝构造函数,对属性进行值拷贝

规则：

如果用户定义有参构造函数,c++编译器不再提供默认无参构造函数,但是会提供默认拷贝构造
/如果用户定义有拷贝构造函数,c++编译器不会再提供其他构造函数

例子，类：

class Person
{
public:

	Person()
	{
		cout << "person 的默认构造函数调用" << endl;
	}


    //定义有参则无默认，但有拷贝
	Person(int a)
	{
		m_Age = a;
		cout << "Person 的有参构造函数调用" << endl;
	}

    //定义拷贝则无默认无有参
	Person(const Person& p)
	{
		m_Age = p.m_Age;
		cout << "person 拷贝构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "Person 的析构函数调用" << endl;
	}
	int m_Age;
};

5.深拷贝与浅拷贝

浅拷贝为编译器提供的拷贝构造函数默认实现，单纯暴力的值拷贝。

深拷贝是为了解决浅拷贝带来的堆区数据重复释放的问题，深拷贝是在堆区另起炉灶，重新开辟空间来实现拷贝。

例子

Person类

class Person
{
public:

	Person()
	{
		cout << "Person 默认构造函数的调用" << endl;
	}
	Person(int a,int height)
	{
		m_Age = a;
		m_Height = new int(height); //堆区开辟空间存放身高（指针）
		cout << "Person 有参构造函数的调用" << endl;
	}

	~Person() 
    {
		cout << "Person 析构函数的调用" << endl;
	}
	int m_Age;
	int* m_Height;
};

调用：

Person p1(18,180);
Person p2(p1);
cout << "p2的年龄：" << p2.m_Age <<"\tp2的身高："<< * p2.m_Height << endl;

可以看到，我们没有自己实现拷贝构造函数，而是利用编译器自带的拷贝构造函数来实现了p2对象的初始化。在程序执行完毕前需要清理对象，由于m_Height是在堆区开辟，那么我们在析构函数中需要加上释放堆区数据的操作：

~Person() 
{
	//将堆区开辟数据释放
	if (m_Height != NULL)
	{
		delete m_Height;
		m_Height = NULL;
	}
	cout << "Person 析构函数的调用" << endl;
}

运行程序崩溃：

这是因为当前是浅拷贝，导致拷贝的p2.m_Height指向了与p1.m_Height同一块堆区地址，则清理对象时就导致重复释放。

因此，需要自己实现深拷贝操作，使得p2.m_Height指向堆区直接开辟的数据，从而避免重复释放即可。

Person(const Person& p)
	{
		cout << "Person 拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
		//m_height = p.m_height;编译器默认实现

		//深拷贝操作
		m_Height = new int(*p.m_Height);

	}

运行：