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-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等
