🔥博客主页：小王又困了
📚系列专栏：C++
🌟人之为学，不日近则日退
❤️感谢大家点赞👍收藏⭐评论✍️
目录
一、拷贝构造函数
📒1.1拷贝构造函数的概念
📒1.2拷贝构造函数的写法
📒1.3编译器生成的拷贝构造
📒1.4拷贝构造函数的用法
📒1.5拷贝构造函数典型调用场景
一、拷贝构造函数
📒1.1拷贝构造函数的概念
拷贝构造函数，是一种特殊的构造函数。这种构造函数由编译器用，用于基于同一类的其他对象的构建及初始化，也就是是创建对象的时候，用一个已存在的对象，去初始化待创建的对象。拷贝构造函数的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。
例如，如果我们有一个名为Date的类，并且我们希望创建一个新的Date对象作为现有Date对象的副本，我们可以使用拷贝构造函数来实现这一点。在这种情况下，新的Date对象将具有与现有对象相同的属性值。
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
};
Data d1;//定义一个日期类对象d1
Data d2(d1);//会去调用拷贝构造函数
拷贝构造函数是针对自定义类型的，自定义类型的对象在拷贝的时候，C++规定必须要调用拷贝构造函数。
📒1.2拷贝构造函数的写法
在上面的概念中提到，拷贝构造函数的形参必须是引用，这是为什么呢？
🎀形参不是引用的情况：
Data(Data d)//错误的拷贝构造 { _year = d._year; _month = d._month; _day = d._day; } Test() { Date d1(2023, 11, 20); Date d2(d1); }我们创建一个d2对象，把实参d1传递过去，然后用形参 d 接收，最后把形参 d 的值赋给this指针（this指针指向的是d2），到这里我们觉得一切正常，但是这段代码有很大的错误。
🗒️为什么错误
问题就在于，我们传参时没有使用引用，上面代码传参使用的是值传递，值传递形参是实参的一份临时拷贝，拷贝也就是要形参d与实参d1有相同的属性值，所以还要调用拷贝构造，这里就会引发无穷递归调用。
形参 d 在接收实参d1的时候，又要去调用拷贝构造来创建 d ，这次调用拷贝构造，又会有一个形参 d ，这个形参d 又需要调用拷贝构造才能创建，一直递归调用。为了避免出现这种无穷递归，编译器会自行检查，如果拷贝构造函数的形参是值传递，编译时会直接报错。
🎀形参是引用的情况：
为了使代码不在无穷递归，拷贝构造函数的形参只能有一个，并且必须是类类型对象的引用。下面才是正确的拷贝构造函数：
Data(Data& d)//正确的拷贝构造 { _year = d._year; _month = d._month; _day = d._day; } Data d1(2023, 7, 20);//定义一个日期类对象d1 Data d2(d1);这里形参 d 是d1的别名，它两共用一块空间，此时就不会再去无穷无尽的调用拷贝构造。
📒1.3编译器生成的拷贝构造
拷贝构造是一种默认成员函数，我们不写编译器会自动生成。默认的拷贝构造函数对内置类型按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝；对自定义类型是调用其拷贝构造函数完成拷贝。
class Time//定义时间类
{
public:
Time()//普通构造函数
{
_hour = 1;
_minute = 1;
_second = 1;
}
Time(const Time& t)//拷贝构造函数
{
_hour = t._hour;
_minute = t._minute;
_second = t._second;
cout << "Time::Time(const Time&)" << endl;
}
private://成员变量
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d1;
// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
Date d2(d1);
return 0;
}
📒1.4拷贝构造函数的用法
编译器默认生成的构造函数对内置类型和自定义类型都做了处理。那我们是不是就可以不写拷贝构造函数了呢？答案是否定的，对于日期类，我们可以不写，用编译器自己生成的，但是对于一些需要自己开辟空间对象，要进行深拷贝，构造函数是非写不可的。栈就是一个典型的需要我们自己写构造函数的例子：
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;
}
void Push(const DataType& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
~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);
Stack s2(s1);
return 0;
}
如上代码，定义了一个Stack类，栈中的成员变量都是内置类型。我们没有写它的拷贝构造函数，编译器默认生成的拷贝构造函数会对这三个成员变量都完成值拷贝（浅拷贝）。
🗒️浅拷贝：
浅拷贝是创建一个新的对象，并把原有的对象属性值完整地拷贝过来。这种拷贝方式既包括了原始类型的值，也包括了引用类型的内存地址。对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
s2调用拷贝构造函数，Stack类中没有显示定义的拷贝构造函数，则调用编译器默认生成的拷贝构造函数，将s1的值拷贝到s2中，因此s1和s2指向同一块内存空间。当程序退出，s1和s2要销毁，s2先销毁，s2销毁时调用析构函数，已经将0x11223344这块空间释放了，但是s1并不知道，到s1销毁的时候，会将0x11223344这块空间再释放一次，一块内存空间多次释放，最终就会导致程序崩溃。
🗒️深拷贝：
通过上面的分析可以看出，简单的浅拷贝不能满足栈的需求，因此，对于栈，我们需要自己写一个拷贝构造函数，来实现深拷贝。深拷贝是对对象具体内容进行复制，它会创建一个新的对象实例，并复制所有属性以及这些属性指向的动态分配的内存。
//自己写的拷贝构造函数，实现深拷贝 Stack(const Stack& st) { DataType* tmp = (DataType*)malloc(sizeof(DataType) * st._capacity); if (nullptr == tmp) { perror("malloc申请空间失败"); return; } memcpy(tmp, st._array, sizeof(DataType) * st._size); _array = tmp; _size = st._size; _capacity = st._capacity; }
深浅拷贝的区别在于他们处理对象内存的方式不同。浅拷贝新旧对象还是共享同一块内存，改变其中一个，另一个也会受影响。而深拷贝则会复制出一个全新的对象实例，新对象跟原对象不共享内存，两者操作互不影响。因此在某些情况下，浅拷贝可能会使旧对象和新对象产生相互影响，这可能会导致数据的不一致。在这种情况下，你可能需要自定义深拷贝构造函数来创建一个新的、独立的对象实例。
注意：类中如果没有涉及资源申请时，拷贝构造函数写不写都可以；一旦涉及到资源申请时，拷贝构造函数是一定要写的，否则就是浅拷贝。
📒1.5拷贝构造函数典型调用场景
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
class Data
{
public:
Data(int year = 1, int month = 1, int day = 1)
{
cout << "调用构造函数：" << this << endl;
cout << endl;
_year = year;
_month = month;
_day = day;
}
Data(const Data& d)
{
cout << "调用拷贝构造：" << this << endl;
cout << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
~Data()
{
cout << "~Data()" << this << endl;
cout << endl;
}
private:
int _year;
int _month;
int _day;
//可以不用写析构，因为全是自定义类型，并且没有动态申请的空间，这三个成员变量会随着对象生命周期的结束而自动销毁
};
Data Text(Data x)
{
Data tmp;
return tmp;
}
int main()
{
Data d1(2023, 4, 29);
Text(d1);
return 0;
}
📖总结：
自定义类型在传参的时候，形参最好用引用来接收，这样可以避免调用拷贝构造函数，尤其是深拷贝的时候，会大大的提高效率，函数返回时，如果返回的对象在函数栈帧销毁后还在，最好也用引用返回。
🎁结语：
本次的内容到这里就结束啦。希望大家阅读完可以有所收获，同时也感谢各位读者三连支持。文章有问题可以在评论区留言，博主一定认真认真修改，以后写出更好的文章。你们的支持就是博主最大的动力。
