【C++从0到王者】第三站：类和对象（中）拷贝构造函数

一、拷贝构造函数的概念

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

二、拷贝构造函数的特性

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

根据以上的两个特性，那么我们先来简单的写一个拷贝构造函数

class Date
{
public:
	Date(int year = 2023, int month = 5, int day = 6)
	{
		_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(2024, 5, 6);
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

根据上面的这些，我们已经不难理解，拷贝构造函数其实就是一个构造函数。而一旦确定了拷贝构造函数，那么有没有了默认构造函数了，我们就得写一个默认构造函数。

三、深度剖析拷贝构造函数不采用引用会无限递归的原因

1.C++对于传参的两个规定

1. 如果传的是内置类型，则直接拷贝给形参
2. 如果传的是自定义类型，则通过调用拷贝构造函数拷贝给形参

根据这两条规矩，我们可以写出如下代码来进行测试

class Date
{
public:
	Date(int year = 2023, int month = 5, int day = 6)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)
	{
		cout << "Date(Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
void func(int i)
{

}
void func(Date d)
{

}
int main()
{
	//Date d1(2024, 5, 6);
	//d1.Print();
	//Date d2(d1);
	//d2.Print();
	Date d1;
	func(10);
	func(d1);
	return 0;
}

运行结果如下所示：
可见确实在传参的时候调用了拷贝构造函数

这样一来我们就明白了，一旦，我们是不采用引用，直接传值的话，那么在拷贝给形参的过程中又要去调用拷贝构造函数，这个拷贝构造又要传参去调用新的拷贝构造…所以自然就会发生无穷递归了

2.如何解开这个无穷递归

1. 采用指针，指针是内置类型，所以是直接拷贝。不会引发无穷递归，但是我们在使用拷贝构造函数的时候就需要传地址过去了
2. 采用引用，这样一来我们直接传的是它的别名。不会产生新的空间消耗，自然就不会发生无穷递归了，C++中也是最好采用这种方法，在我们使用引用的时候，最好加上const进行修饰，这样别名的权限就缩小了。使得我们不会做出一些危害原本空间的事情.

四、拷贝构造函数的其他特性

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
注意：内置类型成员变量是直接拷贝的/浅拷贝
而自定义类型成员变量需要调用它的拷贝构造函数

我们来测试一下这条规则

事实上，上面的情形是基于第一条的场景，如果对于自定义类型，如果是栈的话，会出现一些意想不到的情形

typedef int DataType;
class Stack
{
public:
	Stack()
	{
		cout << "Stack" << endl;
		_array = (DataType*)malloc(sizeof(DataType) * 4);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = 4;
		_size = 0;
	}

	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	void Pop()
	{
		if (Empty())
			return;
		_size--;
	}
	DataType Top() { return _array[_size - 1]; }
	int Empty() { return 0 == _size; }
	int Size() { return _size; }
	~Stack()
	{
		cout << "~Stack" << endl;
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
			if (temp == nullptr)
			{
				perror("realloc申请空间失败!!!");
				return;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	DataType * _array;
	int _capacity;
	int _size;
};
class Date
{
public:
	Date(int year = 2023, int month = 5, int day = 6)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Date(Date& d)
	//{
	//	cout << "Date(Date& d)" << endl;
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
void func(int i)
{

}
void func(Date d)
{

}
int main()
{
	Date d1(2024, 5, 6);
	d1.Print();
	Date d2(d1);
	d2.Print();
	//Date d1;
	//func(10);
	//func(d1);
	Stack s1;
	Stack s2(s1);
	return 0;
}

这里我们发现它报错了，具体报错的原因，我们可以通过调试分析，我们可以发现，它在析构函数中出现了错误。我们可以发现，我们调用了两次析构，一次是对是说s2的释放，一次是对是s1的释放，而巧的是，由于我们的栈中是由指针控制的数组，所以当成了值拷贝，仅仅只是拷贝了指针指向的地址。就会产生同一块空间释放两次的结果，自然就会报错了。需要注意的是，调用析构的时候，是按照栈的特性，后定义的先释放。

这也就是我们为什么所说的编译器生成的其实是浅拷贝的原因。
这时候就需要我们自己去写一个深拷贝来解决了，我们先来简单的写一个简单的深拷贝

	Stack(const Stack& s)
	{
		cout << "Stack(const Stack& s)" << endl;
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_capacity = s._capacity;
		_size = s._size;
	}

事实上，这时候我们也理解了为什么C++规定，自定义类型必须调用拷贝构造函数，如果不调用拷贝构造函数，那么如果在一个函数中传参传的是一个栈的话，就会产生将同一块空间析构两次的现象。而且也会产生一个栈的值改变了，影响另外一个栈的值的现象

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝

我们在来分析一下，对于这个队列，事实上其实就需要写自己的拷贝构造函数了，因为可以直接调用它们的拷贝构造函数

class myQueue
{
private:
	Stack push_st;
	Stack pop_st;
};

五、拷贝构造的一些使用场景

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

使用对象创建新对象和函数参数我们已经了解了。在这期间会调用拷贝构造函数来实现拷贝
那么如果是对于返回值类型为类类型对象的话

如下所示，该过程比较复杂：

1. 先进入func函数，调用s的构造函数，打印Stack
2. 打印func函数中的字符串
3. 由于是传值返回，会产生临时变量，将s的值调用拷贝构造函数给这个临时变量，打印深拷贝构造中的字符串
4. 释放s，调用析构函数，打印析构的字符串
5. 将临时变量中的数据直接拷贝给ret，然后释放临时变量调用析构函数，打印析构中的字符串
   

如果我们选择传引用返回的话，程序直接崩溃。

下面具体分析原因：

1. 进入func函数，创建s，调用构造函数
2. 打印func中的字符串
3. 由于传引用返回不创建临时变量，所以直接调用析构
4. 此时s的空间已经归还，继续将s的别名返回，相当于将s拷贝给ret，调用拷贝构造函数
5. 由于在析构函数中，已经将指针置空。我们在拷贝构造函数中的memcpy已经是野指针访问了，报错
6. 野指针访问虽然是直接原因，但如果没有这个原因的话，也会因为拷贝后的第二次析构而报错

---

好了本期内容就到这里了
如果对你有帮助的话，不要忘记点赞加收藏哦！！！