C++的拷贝构造函数

拷贝构造函数

一、为什么用拷贝构造

日期类传值（这里是浅拷贝）

#include<iostream>
using namespace std;
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();
	return 0;
}

运行后：

这里进行了传值的拷贝，形参传给实参，进行了值拷贝，也就是浅拷贝，所以并没有出现问题。

但是栈类的结构浅拷贝会出现问题

#include<iostream>
using namespace std;

class Stack
	{
	public:
		Stack(size_t capacity = 3)
		{
			cout << "Stack(size_t capacity = 3)" << endl;

			_a = (int*)malloc(sizeof(int) * capacity);
			if (nullptr == _a)
			{
				perror("malloc申请空间失败!!!");
			}

			_capacity = capacity;
			_top = 0;
		}
		~Stack()
		{
			cout << "~Stack()" << endl;

			free(_a);
			_capacity = _top = 0;
			_a = nullptr;
		}
			private:
		int* _a;
		int _capacity;
		int _top;

		};
int main() {
	Stack st1;
	Stack st2(st1);
	return 0;
}

运行后会变成

从上面我们可以看出程序崩溃了，这是为什么呢？
原因在于我们的栈的结构体类型中有一个指针来指向下一个结构体，当我们进行浅拷贝的时候会将这个地址也拷贝过去，但是我们的c++会自动调用析构函数，那么析构函数就被调用了两次，从上面的图中我们也可以看出来析构函数被调用了两次，所以程序崩溃了。

那么如何解决这个问题呢，我们的C++祖师爷，就定义了一个拷贝构造函数 来解决这个问题。

二、拷贝构造函数

1、概念

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

2、特征

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

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数

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

下面写一个拷贝构造函数重新进行运行：

#include<iostream>
using namespace std;

class Stack
	{
	public:
		Stack(size_t capacity = 3)
		{
			cout << "Stack(size_t capacity = 3)" << endl;

			_a = (int*)malloc(sizeof(int) * capacity);//要重新开辟空间
			if (nullptr == _a)
			{
				perror("malloc申请空间失败!!!");
			}

			_capacity = capacity;
			_top = 0;
		}
		//拷贝构造函数
		Stack(const Stack& stt ) {
			_a = (int*)malloc(sizeof(int) * stt._capacity);
			if (_a == nullptr) {
				perror("malloc");
				exit(-1);
			}
			memcpy(_a, stt._a, sizeof(int) * stt._top);
			_capacity = stt._capacity;
			_top = stt._top;

		}
		~Stack()
		{
			cout << "~Stack()" << endl;

			free(_a);
			_capacity = _top = 0;
			_a = nullptr;
		}

		private:
		int* _a;
		int _capacity;
		int _top;

		};
void Func(Stack stt) {
	//....
}
int main() {
	Stack st1;
	Func(st1);
	return 0;
}

就会发现是正常运行，如下

		//拷贝构造函数
		Stack(const Stack& stt ) {
			_a = (int*)malloc(sizeof(int) * stt._capacity);
			if (_a == nullptr) {
				perror("malloc");
				exit(-1);
			}
			memcpy(_a, stt._a, sizeof(int) * stt._top);
			_capacity = stt._capacity;
			_top = stt._top;

		}

通过拷贝构造函数我们可以看出，是重新开辟了一块空间进行拷贝构造，而且我们使用了引用（&）。那么为什么要用引用呢？
下面我们用日期类函数进行演示：

#include<iostream>
using namespace std;
class Date {
public:
	Date(int year=1, int month=1, int day=1) {
		_year = year;
		_month = month;
		_day = day;
	}
	//错误的拷贝构造函数
	Date(Date d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print() {
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year ;
	int _month ;
	int _day ;
};
int main() {
	Date d1;
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

我们会发现代码没有办法运行，进行下面的报错

这是由于当我们d2要对d1进行拷贝构造时发生了以下过程：
规定传值传参都要去调用拷贝构造函数那么，中间就还有临时变量要创建和拷贝，这样一环套一环没有终点。如下：

综上，所以我们要用引用，直接将d1赋值给d，如下所示：

#include<iostream>
using namespace std;
class Date {
public:
	Date(int year=1, int month=1, int day=1) {
		_year = year;
		_month = month;
		_day = day;
	}
	//正确的拷贝构造函数
	Date(Date& d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print() {
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year ;
	int _month ;
	int _day ;
};
int main() {
	Date d1;
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

3. 若未显式定义，编译器会生成默认的拷贝构造函数。

默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

所以其实日期类是不用进行我们自己写拷贝构造函数的，因为日期类浅拷贝就够用了，我在上面用日期类进行举例是为了方便我们理解。拷贝构造还是主要用在我开始写的栈类型的程序上。

#include<iostream>
using namespace std;

class Stack
	{
	public:
		Stack(size_t capacity = 3)
		{
			cout << "Stack(size_t capacity = 3)" << endl;

			_a = (int*)malloc(sizeof(int) * capacity);//要重新开辟空间
			if (nullptr == _a)
			{
				perror("malloc申请空间失败!!!");
			}

			_capacity = capacity;
			_top = 0;
		}
		//拷贝构造函数
		Stack(const Stack& stt ) {
			_a = (int*)malloc(sizeof(int) * stt._capacity);
			if (_a == nullptr) {
				perror("malloc");
				exit(-1);
			}
			memcpy(_a, stt._a, sizeof(int) * stt._top);
			_capacity = stt._capacity;
			_top = stt._top;

		}
		~Stack()
		{
			cout << "~Stack()" << endl;

			free(_a);
			_capacity = _top = 0;
			_a = nullptr;
		}

		private:
		int* _a;
		int _capacity;
		int _top;

		};
void Func(Stack stt) {
	//....
}
int main() {
	Stack st1;
	Func(st1);
	Stack st2(st1);
	return 0;
}

通过调试上述代码我们发现，它们_a的地址不同，但是_capacity、_top的值是相同的，成功完成了拷贝构造。

运行后的结果如下：

4. 拷贝构造函数典型调用场景

使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象