C++奇迹之旅：探索C++拷贝构造函数

请添加图片描述

文章目录

📝拷贝构造函数
🌠 概念
- 🌉特征
🌠浅拷贝(值拷贝)
- 🌉深拷贝
🌠拷贝构造函数典型调用场景
🌠应用时效率的思考
🚩总结

📝拷贝构造函数

🌠 概念

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用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-18return 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等
请添加图片描述