文章目录
?拷贝构造函数? 概念?特征 ?浅拷贝(值拷贝)?深拷贝 ?拷贝构造函数典型调用场景?应用时效率的思考?总结
?拷贝构造函数
? 概念
在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。
那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
还是我们熟悉的日期函数：
class Date{public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 给缺省值int _year = 1;int _month = 1;int _day = 1;};然后我们定义一个日期对象d1:
int main(){Date d1(2024, 4, 18);d1.Print();return 0;}当你想要一个d2对象与d1的对象数据一样，想拷贝过来怎么做呢？
实现方法：
int main(){Date d2(2024, 4, 9);Date d3(d2);d2.Print();d3.Print();return 0;}那拷贝构造内部细节怎么做到的呢？我们接着往下看：
拷贝构造函数的定义形式如下:
ClassName(const ClassName& other);ClassName是类的名称other是一个引用参数,表示要被拷贝的对象。const 为了保护原对象other不被更改接上面的日期例子，我们稍稍修改：
class Date{public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}//ClassName(const ClassName& other);Date(const Date& d){//this==d2//this->_year=d1.year;_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 给缺省值int _year = 1;int _month = 1;int _day = 1;};int main(){Date d1(2024, 4, 18);Date d2(d1);d1.Print();d2.Print();return 0;}这里的this是d2，而d是d1，也就是我们的other
注意：这两种写法是等价的：
// 下面这两种写法是等价的Date d3(d2);Date d4 = d2; // 这也是拷贝构造?特征
拷贝构造函数也是特殊的成员函数，其特征如下：
拷贝构造函数是构造函数的一个重载形式。class Date{public: // 默认构造函数 Date() { _year = 1; _month = 1; _day = 1; } // 带参数的构造函数 Date(int year, int month, int day) { _year = year; _month = month; _day = day; } // 拷贝构造函数 Date(const Date& other) { _year = other._year; _month = other._month; _day = other._day; } void Print() { cout << _year << "-" << _month << "-" << _day << endl; }private: int _year; int _month; int _day;};int main(){ // 使用默认构造函数创建对象 Date d1; d1.Print(); // 输出: 1-1-1 // 使用带参数的构造函数创建对象 Date d2(2023, 4, 18); d2.Print(); // 输出: 2023-4-18 // 使用拷贝构造函数创建对象 Date d3(d2); d3.Print(); // 输出: 2023-4-18 return 0;}
我们先看这个例子：
class Date{public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}//ClassName(const ClassName& other);Date(const Date& d){//this==d2//this->_year=d1.year;_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:// 给缺省值int _year = 1;int _month = 1;int _day = 1;};这里读文字有点难理解，我们先区别以下两种方式：
void func1(Date d){d.Print();}void func2(Date& d){d.Print();}int main(){Date d1(2024, 4, 18);func1(d1);func1(d1);return 0;}进行调试，按F11调试：首先进入func1函数：
但是他却跳转到拷贝构造函数：
拷贝构造函数完了后，才进入到func1函数中：
流程图：
按但是当执行func2时直接能进去func2函数，不需要跳转到拷贝构造函数。
上面是引用拷贝构造函数，如果改为传值会发生无穷递归调用，因为传值传参会调用一个新的拷贝构造
?浅拷贝(值拷贝)
若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
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 = 2024;int _month = 4;int _day = 18;// 自定义类型Time _t;};int main(){Date d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2(d1);return 0;}
这段代码演示了类的默认构造函数和拷贝构造函数的用法。
Time 类:
_hour、_minute 和 _second 初始化为 1。拷贝构造函数会打印一行 "Time::Time(const Time&)"。 Date 类:
_year、_month 和 _day 成员变量。包含一个 Time 类型的成员变量 _t。 main 函数:
Date 类型的对象 d1。由于 Date 类没有显式定义构造函数,编译器会自动生成一个默认构造函数,该构造函数会调用 Time 类的默认构造函数来初始化 _t 成员变量。创建另一个 Date 类型的对象 d2,使用 d1 对象进行拷贝构造。由于 Date 类没有显式定义拷贝构造函数,编译器会自动生成一个默认的拷贝构造函数。这个默认的拷贝构造函数会调用 Time 类的拷贝构造函数来拷贝 _t 成员变量。因此,在创建 d2 对象时,会打印出 "Time::Time(const Time&)"。 对于编译器生成的默认拷贝构造函数里，内置类型是按照字节方式直接拷贝，自定义类型是调用其自己的拷贝构造函数。
当Time的默认构造函数删除时，会发生什么？
class Time{public: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 = 2024;int _month = 4;int _day = 18;// 自定义类型Time _t;};int main(){Date d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2(d1);return 0;}出现了尝试引用已删除的函数，这是什么意思？
在 C++ 中,当一个类的成员变量没有默认构造函数时,该类的默认构造函数就会被隐式地标记为已删除。这是因为编译器无法确定如何初始化这些成员变量。
好的,我来解释一下为什么 Date 类的默认构造函数会被标记为已删除(deleted)。
在代码中,Date 类有一个成员变量 _t 是 Time 类型的。而 Time 类没有提供默认构造函数,这就导致 Date 类的默认构造函数无法正确初始化 _t 成员变量。为了解决这个问题,编译器会将 Date 类的默认构造函数标记为已删除(deleted)。这意味着你无法在代码中直接调用 Date 类的默认构造函数,否则会产生编译错误。
如果把Time的构造函数删掉，那么Time的默认构造函数还原，那么编译器就会生成Time的拷贝构造函数来完成拷贝：
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
?深拷贝
编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？
// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。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);s1.Push(3);s1.Push(4);Stack s2(s1);return 0;}运行截图：
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
在 C++ 中,浅拷贝和深拷贝是两种不同的对象复制方式,它们之间有以下区别:
浅拷贝(Shallow Copy): 浅拷贝是默认的复制行为,当使用赋值运算符(=)或者拷贝构造函数(T(const T&))复制一个对象时,会发生浅拷贝。浅拷贝只复制对象的成员变量,但不会复制动态分配的内存。也就是说,浅拷贝后的两个对象共享同一块动态内存。如果原对象的动态内存被释放或修改,拷贝对象也会受到影响。这可能会导致严重的内存问题,如野指针、内存泄漏等。 深拷贝(Deep Copy): 深拷贝会创建一个新的对象,并将原对象的所有成员变量(包括动态分配的内存)都复制一遍。深拷贝后的两个对象是完全独立的,互不影响。即使原对象的动态内存被释放或修改,拷贝对象也不会受到影响。深拷贝需要自定义拷贝构造函数和赋值运算符,手动分配和复制动态内存。这样可以确保对象之间的独立性。 深拷贝实现：
typedef int DataType;class Stack{public:Stack(size_t capacity = 3){cout << "Stack(size_t capacity = 3)" << endl;_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}// Stack st2 = st1;Stack(const Stack& st){_array = (DataType*)malloc(sizeof(DataType) * st._capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}memcpy(_array, st._array, sizeof(DataType) * st._size);_size = st._size;_capacity = st._capacity;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}bool Empty(){return _size == 0;}DataType Top(){return _array[_size - 1];}void Pop(){--_size;}// 其他方法...~Stack(){cout << "~Stack()" << endl;if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}private:DataType* _array;int _capacity;int _size;};int main(){Stack st1;st1.Push(1);st1.Push(2);// 拷贝构造Stack st2(st1);return 0;}
深拷贝利用栈实现队列的拷贝构造运用：
class MyQueue {private:Stack _st1;Stack _st2;int _size = 0;};int main(){MyQueue q1;MyQueue q2(q1);return 0;}
?拷贝构造函数典型调用场景
使用已存在对象创建新对象:
MyClass obj1("Hello");MyClass obj2(obj1); // 调用拷贝构造函数这种情况下,会调用拷贝构造函数来创建新的 obj2 对象,并将 obj1 的状态复制到 obj2 中。
函数参数类型为类类型对象:
void printObject(MyClass obj) { obj.print();}MyClass obj("Hello");printObject(obj); // 调用拷贝构造函数在这个例子中,当 printObject() 函数被调用时,会先调用拷贝构造函数来创建一个临时的 MyClass 对象,并将 obj 的状态复制到这个临时对象上。然后,这个临时对象作为函数参数传递给 printObject()。
函数返回值类型为类类型对象:
MyClass createObject() { MyClass obj("Hello"); return obj; // 调用拷贝构造函数}MyClass newObj = createObject();在这种情况下,当 createObject() 函数返回时,会调用拷贝构造函数来创建一个新的 MyClass 对象,并将 obj 的状态复制到这个新对象上。这个新对象最终被赋值给 newObj。
?应用时效率的思考
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。
class Date{public:Date(int year, int minute, int day){cout << "Date(int,int,int):" << this << endl;}Date(const Date& d){cout << "Date(const Date& d):" << this << endl;}~Date(){cout << "~Date():" << this << endl;}private:int _year;int _month;int _day;};Date Test(Date d){Date temp(d);return temp;}int main(){Date d1(2022, 1, 13);Test(d1);return 0;}
?总结
实践中总结:
1、如果没有管理资源，一般情况不需要写拷贝构造，默认生成的拷贝构造就可以。如:Date
2、如果都是自定义类型成员，内置类型成员没有指向资源，也类似默认生成的拷贝构造就可以。如: MyQueue3、一般情况下，不需要显示写析构函数，就不需要写拷贝构造
4、如果内部有指针或者一些值指向资源，需要显示写析构释放，通常就需要显示写构造完成深拷贝。如:Stack Queue List等