【c++初阶】拷贝构造函数太难学？带你梳理底层逻辑！！

本文链接：https://blog.youkuaiyun.com/2301_78320637/article/details/134036100

博主：一个努力敲代码的小粉象
收录专栏：《c++初阶》
欢迎点赞、评论、收藏鼓励三连~~

前言

大家学习拷贝构造函数的时候常常无法理解其深层的含义以及和构造函数之间的关系。今天这篇博文将从拷贝构造函数的概念、特征、与构造函数之间的关系这三个方面来进行讲解~~

浅拷贝与深拷贝的简单理解

在了解拷贝函数之前，我们来简单拓展一个新知识：浅拷贝与深拷贝。

我们在c语言的学习过程中了解到形参是实参的拷贝这个说法，传参的方式也有传值传参和传址传参，而浅拷贝的一个别名就叫做值拷贝，所以这里我们就能简单联想一下：浅拷贝就是简单地将数据拷贝过去。那么如果是传一个数组呢？我们来看一看这个问题。

a中存储的是数组的首地址，那么将a传给形参a‘之后，a’中存储的是数组中的数据还是地址呢？显而易见是数组的地址。所以传递地址本质上没有开辟新的空间，也是浅拷贝的范畴。而a’和a是指向同一个位置的。

我们先来看一个简单的传值拷贝的例子~~

class date
{
public:
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//private:
	int _year;
	int _month;
	int _day;
};
//浅拷贝/值拷贝
void print(date d1)
{
	cout << "print(date d1)" << endl;
}
int main()
{
	date d1(2023,10,25);
	print(d1);
}

我们看到，浅拷贝在这里使用是完全可以的，程序运行成功了。但是，浅拷贝在任何情况下都可以使用吗？答案当然是否定的。

在这里老铁们注意，当我们想传递一个数组的时候，我们一般传递的是数组的首地址，而当函数结束跳出作用域的时候，c++会自动调用析构函数，这会导致什么呢？同样的一个空间被释放了两次。

老铁们肯定还是没有太理解，我们上代码！

#include<iostream>
using namespace std;
//栈空间问题
class stack
{
public:
	stack(int capacity=10)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (nullptr == _a)
		{
			perror("malloc fail");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	~stack()
	{
		if (_a)
		{
			free(_a);
			_a = nullptr;
			_size = 0;
			_capacity = 0;
		}
	}
	//private:
		int* _a;
		int _size;
		int _capacity;
};
void Print(stack st)
{
	cout << "Print(stack st)" << endl;
}
int main()
{
	stack st1;
	Print(st1);
}

老铁们可以自行复制代码去vs上实现一下，会发现上述代码获得的结果是什么呢？

出现了警告。原因就是我们开辟的空间连续被释放了两次，导致出现问题。

我们通过图像来直观感受一下。

这里我们浅显总结一下深拷贝和浅拷贝的区别：浅拷贝是一种简单的复制，将数据复制过去，或者将地址传过去，而没有另开空间，所以函数中各种操作也是在原本空间上进行操作的；而深拷贝则是重新开辟了一块空间供函数使用，这样函数在结束时调用析构函数时就不会影响原本的空间。

所以此时，我们发现浅拷贝（值拷贝）在c++中会出现问题，那么应该怎么办呢？这里的方法就是调用拷贝构造函数。

拷贝构造函数

概念

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

特征

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

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
编译器生成的默认拷贝函数已经可以完成字节序的值拷贝了，不需要自己显示实现。
拷贝构造函数的典型调用场景：
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象

传值引发无穷递归

我们先来讲解一下为什么直接传值会引发无穷递归。

这里不妨用日期类函数举个例子。

class date
{
public:
	date(int year = 2023, int month=1, int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	date(const date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
void print(date d) {
	cout << "print(date d2)" << endl;
}

int main()
{
	date d1;
	date d2(d1);
	print(d2);
	return 0;
}