C++ 类和对象篇(六) 拷贝构造函数

目录

一、 概念

1. 拷贝构造函数是什么？

2. 为什么要有拷贝构造函数？

3. 怎么用拷贝构造函数？

3.1 创建拷贝构造函数

3.2 调用拷贝构造函数

二、特征

三、合成拷贝构造函数

1. 是什么？

2. “双重删除”问题

3. 什么时候需要显示的写拷贝构造函数？

四、在拷贝构造函数中实现深拷贝

1. 自己开辟一个新空间，然后将内容拷贝到新空间。

2. 借助构造函数来实现深拷贝。

【总结】

【源代码】 

---

一、 概念

1. 拷贝构造函数是什么？

       拷贝构造函数是一个特殊的构造函数，也是用来初始化对象的，不过它是用已经存在的对象来初始化同类对象。

2. 为什么要有拷贝构造函数？

       在创建新对象时，可否用已经存在的同类对象来初始化这个新对象呢？能否快速拷贝出一个对象的副本呢？

       为解决以上问题，C++中引入了拷贝构造函数：拷贝构造函数用于实现对象的复制和初始化。

3. 怎么用拷贝构造函数？

3.1 创建拷贝构造函数

       和构造函数一样，函数名和类名相同，且没有返回值，但拷贝构造函数的参数是当前类类型对象的引用或是指向当前类类型对象的指针。不能用当前类类型对象作为参数，这样会引发无穷递归问题。

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //Date(const Date d) // 错误写法：编译报错，会引发无穷递归。
    // 正确写法，拷贝构造函数的参数必须是本类类型的引用或是指向本类类型的指针。	
    Date(const Date& d)  
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	Date(const Date* d)
	{
		_year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}
    // 拷贝构造函数可以有多个参数，但一般只以一个对象为副本进行拷贝，所以只写一个参数。
    Date(const Date& d1,const Date& d2,const Date* d3)
	{
		_year = d1._year;
		_month = d2._month;
		_day = d3->_day;
	}
private:
	int _year;
	int _month;
	int _day;
};

---

        所以拷贝构造函数的参数必须是当前类类型对象的引用或是指向本类类型的指针，不然会引起以下拷贝构造函数传值传参带来的无穷递归问题：

        拷贝构造函数如使用传值传参的方式，会引发无穷递归调用编译器会直接报错。因为使用传值传参时，编译器要调用拷贝构造函数用实参初始化形参，使用拷贝构造函数就必须得先传参，又会调用拷贝构造函数，这样就造成了造成无穷递归。

---

        在传引用传参或指针传参时，对于像拷贝构造函数的形参这类不需要修改的参数，建议加上一个const。这样做即能避免误操作导致实参被修改，也能误操作时给我们一个提示，让我们快速定位错误。

eg. 加上const后实参不能被修改。

3.2 调用拷贝构造函数

a. 参数是 对象的引用 的拷贝构造函数

int main()
{
	Date a(1,1,1);
	Date b(a);
	return 0;
}

---

b. 参数是 指向对象的指针 的拷贝构造函数

int main()
{
	Date c(3, 3, 3);
	Date d(&c);
	return 0;
}

---

c. 多个参数的拷贝构造函数

拷贝构造函数可以有多个参数，但一般只以一个对象为副本进行拷贝只写一个参数。

int main()
{
	Date a(1, 1, 1);
	Date b(2, 2, 2);
	Date c(3, 3, 3);
	Date d(a, b, &c);
	return 0;
}

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

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

2. 拷贝构造函数的参数必须是本类类型的引用或是指向本类类型的指针。使用传值传参方式编译器会直接报错，因为会引发无穷递归调用。

3. 拷贝构造函数可以有多个参数，但一般只以一个对象为副本进行拷贝，所以只写一个参数。

4. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

---

三、合成拷贝构造函数

1. 是什么？

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

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，是浅拷贝，而自定义类型是调用其拷贝构造函数完成拷贝的。

2. “双重删除”问题

        编译器生成的默认拷贝构造函数只能进行浅拷贝，无法对申请的资源（如动态开辟的空间）进行拷贝，看下面的例子：

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		if (_array)
		{
		free(_array);
		_array = nullptr;
		_capacity = 0;
		_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	
	Stack s2(s1); //调用默认拷贝构造函数
	return 0;
}

---

        在以上例子中我们发现，默认的拷贝构造函数会令拷贝的类和被拷贝的类中的指针变量指向同一块空间，这样会造成同一块空间被析构函数析构两次，这通常被称为“双重删除”或“重复删除”，这是一个严重的问题，会导致程序崩溃。这个时候需要显示的写一个构造函数，并在里面完成深拷贝。

3. 什么时候需要显示的写拷贝构造函数？

        编译器生成的默认拷贝构造函数只能进行浅拷贝，无法对申请的资源（如动态开辟的空间）进行拷贝。

        所以类中如果没有涉及资源申请时，拷贝构造函数是否写都可以。一旦涉及到资源申请时，一定要显示的写拷贝构造函数，否则就是浅拷贝，可能导致“双重删除”问题。

---

四、在拷贝构造函数中实现深拷贝

1. 自己开辟一个新空间，然后将内容拷贝到新空间。

2. 借助构造函数来实现深拷贝。

       在构造函数中自然要动态成员变量开辟空间，所以在拷贝构造函数中可以使用构造函数创建一个临时对象，然后交换对象和临时对象的动态成员

---

       但这有个小问题，就是当前对象未初始化，直接交换数值可能会导致程序崩溃，所以加上初始化列表，在交换数值前先初始化。

最后再给new的失败加一个提示或抛异常。

想深入了解C/C++中深浅拷贝问题的同学，不妨看看博主的这篇文章： 「C/C++ 01」 深拷贝和浅拷贝

---

【总结】

---

【源代码】 

//class A
//{
//public:
//	int a;
//	A(int _a) { a = _a; }
//};
//class Date
//{
//public:
//	Date(int year = 2022, int month = 10, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//Date(Date d) // 错误写法：编译报错，会引发无穷递归
//	// 正确写法，拷贝构造函数的参数必须是本类类型的引用或是指向本类类型的指针。
//	Date(const A& a)
//	{
//		_year = a.a;
//		_month = a.a;
//		_day = a.a;
//	}
//	Date(const Date& d1)
//	{
//		_year = d1._year;
//		_month = d1._month;
//		_day = d1._day;
//	}
//	Date(Date& d1, Date& d2, Date* d3)
//	{
//		_year = d1._year;
//		_month = d2._month;
//		_day = d3->_day;
//	}
//	Date(const Date* d)
//	{
//		_year = d->_year;
//		_month = d->_month;
//		_day = d->_day;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	A a(1);
//	Date c(3, 3, 3);
//	Date d(&c);
//	Date e(a);
//	return 0;
//}
 
#include<iostream>
using namespace std;
 
 
class stack
{
public:
	int* _arr;
	// 构造函数
	stack(int* arr = nullptr)
	{
		_arr = new int();
		int len = sizeof(arr) / sizeof(arr[0]);
		copy(arr, arr + len, _arr);
	}
	~stack()
	{
		cout << "删除地址为：" << _arr << "的数组。" << endl;
		delete(_arr);
	}
	 1. 自己开辟一个新空间，然后将内容拷贝到新空间。
	//stack(const stack &s)
	//{
	//	//开辟新空间
	//	_arr = new int();
	//	//拷贝内容
	//	int len = sizeof(s._arr) / sizeof(s._arr[0]);
	//	copy(s._arr, s._arr + len, _arr);
	//}
 
	 2. 借助构造函数创建中间对象来实现深拷贝。
	//stack(const stack& s)
	//{
	//	//调用构造函数创建中间对象(系统会开辟好空间)
	//	stack tmp(s._arr);
	//	swap(_arr, tmp._arr);
	//}
	 但这有个小问题，就是当前对象未初始化，
	 直接交换数值可能会导致程序崩溃，所以加上初始化列表，在交换数值前先初始化。
	stack(const stack& s)
		:_arr(nullptr)
	{
		//调用构造函数创建中间对象
		stack tmp(s._arr);
		swap(_arr, tmp._arr);
	}
 
	stack& operator= (const stack& s)
	{
		// 自己给自己赋值时无需开辟新空间。
		if (this != &s)
		{
			//调用构造函数创建中间对象(系统会开辟好空间)
			stack tmp(s._arr);
			swap(_arr, tmp._arr);
		}
		return *this;
	}
};
 
int main()
{
	int* arr = new int[5];
	arr[0] = 0;
	stack st1(arr);
	stack st2 = st1;
	cout << "st1数组的地址：" << st1._arr << endl \
		 << "st2数组的地址：" << st2._arr << endl;
	return 0;
}
 

---

------------------------END-------------------------

才疏学浅，谬误难免，欢迎各位批评指正。