C/C++笔记总结——构造函数，析构函数，深拷贝与浅拷贝（含解决浅拷贝带来的问题）

一、基本概念

1.特点

构造函数：

        1.没有返回值，不用写void

        2.函数名与类名相同

        3.构造函数可以有参数，可以发生重载

        4.创建对象的时候，构造函数会自动调用，而且只调用一次

        5.语法：类名(){}

析构函数：

        1.没有返回值，不写void

        2.函数名和类名相同，在名称前加“~”

        3.析构函数不可以有参数，不可以发生重载

        4.对象在销毁前，会自动调用析构函数，而且只会调用一次

        5.语法：~类名(){}

2.举例：

#include<iostream>
#include<string>
using namespace std;

class person {
public:
	person() {
		cout << "调用构造函数" << endl;
	}

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

void text() {
	person p;
}

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

       这里有两种情况，本文展示的是第一种，第二种可以自己尝试：

       在main函数中通过调用text函数，只是创建了一个person对象p，也会执行person的构造函数和析构函数。因为构造函数是在创建对象的时候自动调用的，析构函数是在对象销毁的时候自动调用的。

        但是，如果不调用text函数，直接在main函数中创建person对象，就会只执行构造函数，在按下任意键结束运行的瞬间会看到析构函数执行，因为按下“任意键”结束之后才算运行到了main函数中的“return 0”，person对象才销毁。这个大家可以自己试一下。

二、析构函数的分类及调用

1.分类

        按参数分：有参构造和无参构造。

        按类型分：普通构造和拷贝构造。（拷贝构造函数下个部分讲）

2.调用方式：

        括号法、显示法、隐式转换法。

示例代码：

#include<iostream>
using namespace std;

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;

	}
	int age;
};
void text01() {
	Person p1;		//调用无参构造函数
}	
void text02() {
	Person p1(10);				//括号法，常用
	Person p3 = Person(10);		//显式法
	Person p4 = 10;				//隐式转换法
	Person p2(p1);
}

int main() {
	text01();
	text02();
	return 0;
}

        代码中的拷贝构造函数部分的参数前加了const，是为了防止修改原来p中的参数。

        运行 text01 会调用“默认构造函数”和“析构函数”，这个在上一部分已经讲过了。

        运行 text02 之前把p3和p4的那两行删掉或注释掉再运行，因为他们和定义p1是一样的，只是不同的调用方法而已，注释掉再运行方便我们查看结果。运行结果如下：

         我们分析一下这个运行结果：首先定义了一个 Person 对象 p1，并给 p1 的年龄赋值为 10，这就调用了有参构造函数；然后定义了另一个 Person 对象 p2，并令 p2和p1 相等，这就调用了拷贝构造函数；接下来 text02 就运行结束了，要依次销毁 p1 和 p2，而“对象在销毁前，会自动调用析构函数，而且只会调用一次”（最开头的概念），所以有两次“调用析构函数”。

3.构造函数的调用规则

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

        1.默认构造函数（无参，函数体为空）

        2.默认析构函数（无参，函数体为空）

        3.默认拷贝构造函数，对属性进行值拷贝（浅拷贝）

        4.赋值运算符operater=，对属性进行拷贝（这个目前先不用管）

规则如下：

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

        如果用户定义拷贝构造函数，c++不会再提供其他构造函数。

三、拷贝构造函数

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

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

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

        3）.以值方式返回局部对象。

2.深拷贝和浅拷贝

        浅拷贝：简单的赋值拷贝操作。但是浅拷贝容易出现“堆区重复释放”的问题，如果属性有在堆区开辟的，就要自己提供拷贝构造函数，即深拷贝来解决浅拷贝带来的问题。

        深拷贝：在堆区重新申请空间，进行拷贝操作。能解决浅拷贝带来的“堆区重复释放”的问题。

3.浅拷贝带来的问题以及解决方法

#include<iostream>
#include<string>
using namespace std;

class Person {
public:
	Person() {
		cout << "调用默认构造函数" << endl;
	}

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

void text() {
	Person p1(10);
	Person p2(p1);
	cout << "p1的年龄为：" << p1.m_Age << endl;
	cout << "p2的年龄为：" << p2.m_Age << endl;
}

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

        上述代码创建了两个Person类的对象 p1 和 p2，我们没有写拷贝构造函数，但是仍然可以将 p1的年龄赋值给 p2，这也就印证了我们前面提到的，编译器会默认给我们提供一个拷贝构造函数，实现的是浅拷贝功能，也就是简单的赋值操作。

        那么深拷贝如何体现呢？我们在上面这段代码里面添加一些东西，形成下面这段代码：

#include<iostream>
#include<string>
using namespace std;

class Person {
public:
	Person() {
		cout << "调用默认构造函数" << endl;
	}

	Person(int age,int height) {
		m_Age = age;
		m_Height = new int(height);
		cout << "Person的有参构造函数调用" << endl;
	}
	~Person() {
		cout << "调用析构函数" << endl;
	}
	int m_Age;
	int* m_Height;
};

void text() {
	Person p1(18,185);
	Person p2(p1);
	cout << "p1的年龄为：" << p1.m_Age << " 身高为：" << *p1.m_Height << endl;
	cout << "p2的年龄为：" << p2.m_Age << " 身高为：" << *p2.m_Height << endl;
}

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

        在这段代码里，我们新添加了一个变量 m_Height ，并且是个指针类型。至于为什么要用指针类型创建，是因为我们要把“身高”这个属性开辟到堆区，而浅拷贝的问题就在于会出现“堆区重复释放”。我们在有参构造函数中在堆区new一个空间 height 接收（即用指针接收堆区数据）。

        目前这段代码看似没有什么问题，但实际上有一个很重要的点：堆区开辟的数据由程序员手动开辟，也需要由程序员手动释放，并且要在该对象销毁前手动释放。那什么时候 m_Height 这个数据被销毁呢？是在 text 函数执行完毕之后销毁，而函数执行完毕之前会调用析构函数。

        哎~所以我们就可以在析构代码里面手动释放在堆区开辟的数据，程序会自动调用析构函数，简直天衣无缝！这也就是析构代码的主要用途：将堆区开辟的数据做释放操作。代码如下：

~Person() {
		if (m_Height != NULL) {
			delete m_Height;
			m_Height = NULL;
		}

        这就是我们在析构函数中做的释放堆区数据的操作，先判断指针是否为空，如果不为空，就删除并将其置为空。看似没什么问题，但是当你将这段代码放进程序里之后，你会发现程序崩了。

        原因是我们创建了两个 Person 类对象 p1 和 p2，而 p2 是通过编译器提供的浅拷贝操作搞出来的。我们在 p1 中创建了一个 int * m_Height ，它是在堆区开辟的数据，有自己的地址，假设它的地址为0x0011，那么 p2 的身高数据存放地址也是0x0011。

        代码执行规则是“先进后出”，那么在执行完 text 函数之后，p2先被释放。这时候 p2 会执行析构函数的代码，那么此时，0x0011指向的堆区内存已经释放干净了；接下来 p1 再执行析构代码，这时候0x0011已经置为空了，再去释放就是非法操作，就会报异常。这也就是浅拷贝带来的问题“堆区内存重复释放”。

        那么如何解决这个问题呢？我们可以重新在堆区再创建一块内存，自己写一个拷贝构造函数，在堆区申请一块内存，比如0x0022来存放 p2 的身高，这样 p1 和 p2 在释放各自的堆区内存的时候就不会发生冲突了。

Person(const Person& p) {
		m_Age = p.m_Age;
		m_Height = new int(*p.m_Height);
	}

        这样就很好地解决了浅拷贝带来的问题。我们做个小结。

四、小结

        本文最重要的是构造函数，以及深拷贝与浅拷贝。

        编译器在默认情况下会提供给我们四个函数，不过我们记住前三个就行，分别是默认构造函数(无参，函数体为空)，默认析构函数(无参，函数体为空)，默认拷贝构造函数(浅拷贝)。

        创建对象时，自动调用构造函数；对象销毁前，自动调用析构函数。并且都是只调用一次。

        浅拷贝会带来“堆区内存重复释放”的问题，需要我们自己写一个拷贝构造函数，利用深拷贝来解决。