一、拷贝构造函数的概念
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
二、拷贝构造函数的特性
- 拷贝构造函数是构造函数的一个重载形式
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
根据以上的两个特性，那么我们先来简单的写一个拷贝构造函数
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++对于传参的两个规定
- 如果传的是内置类型，则直接拷贝给形参
- 如果传的是自定义类型，则通过调用拷贝构造函数拷贝给形参
根据这两条规矩，我们可以写出如下代码来进行测试
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.如何解开这个无穷递归
- 采用指针，指针是内置类型，所以是直接拷贝。不会引发无穷递归，但是我们在使用拷贝构造函数的时候就需要传地址过去了
- 采用引用，这样一来我们直接传的是它的别名。不会产生新的空间消耗，自然就不会发生无穷递归了，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; };
五、拷贝构造的一些使用场景
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
使用对象创建新对象和函数参数我们已经了解了。在这期间会调用拷贝构造函数来实现拷贝
那么如果是对于返回值类型为类类型对象的话
如下所示，该过程比较复杂：
- 先进入func函数，调用s的构造函数，打印Stack
- 打印func函数中的字符串
- 由于是传值返回，会产生临时变量，将s的值调用拷贝构造函数给这个临时变量，打印深拷贝构造中的字符串
- 释放s，调用析构函数，打印析构的字符串
- 将临时变量中的数据直接拷贝给ret，然后释放临时变量调用析构函数，打印析构中的字符串
如果我们选择传引用返回的话，程序直接崩溃。
下面具体分析原因：
- 进入func函数，创建s，调用构造函数
- 打印func中的字符串
- 由于传引用返回不创建临时变量，所以直接调用析构
- 此时s的空间已经归还，继续将s的别名返回，相当于将s拷贝给ret，调用拷贝构造函数
- 由于在析构函数中，已经将指针置空。我们在拷贝构造函数中的memcpy已经是野指针访问了，报错
- 野指针访问虽然是直接原因，但如果没有这个原因的话，也会因为拷贝后的第二次析构而报错
好了本期内容就到这里了
如果对你有帮助的话，不要忘记点赞加收藏哦！！！
