目录
前言
拷贝构造函数
赋值运算符重载
结语
前言
在上篇文章中我们讲到了类的默认成员函数的构造函数和析构函数，这两个默认成员函数在对象的生命周期中起着至关重要的作用。而今天我们要讲的拷贝构造函数和赋值运算符重载，作为类默认成员函数的其中之二，则是在对象间的初始化和拷贝当中起着重要作用。再次强六个默认成员函数的共性，这些函数会在你不提供的情况下由编译器自动生成。接下来开始我们今天的内容。
拷贝构造函数
概念
在创建对象时，你可能需要创建一个与已经存在的对象一模一样的新对象。
拷贝构造函数的特性及用法
拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器报错，因为会引发无穷调用。
拿一个Date类来举例：
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// Date(const Date& d) // 正确写法
Date(const Date& d) // 错误写法：编译报错，会引发无穷递归
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1);
return 0;
}
在 Date d2(d1); 这句，将调用拷贝构造函数，其中d1通过传引用传参传递给函数中的d，d2以this指针的形式隐式传递。在运行完拷贝构造函数之后，d2创建好就是和d1相同的一个对象了。接下来详细讲解为什么构造中不加应用会导致无穷调用。
void Fun1(Date d)
{
cout << "Fun1" << endl;
}
int main()
{
Date d1(2024, 4, 16);
Fun1(d1);
return 0;
}
运行以上代码，会发现，在进入函数Fun1之前，会先调用一次拷贝构造，将d1的值赋给d，下面是调试观察，可以看到调试进入Fun1前先进入了拷贝构造。
说明类的传值传递在调用时会先调用类内部的拷贝构造，如果不写拷贝构造中的引用，拷贝构造的传应用传递就会变成类的传值传递，而类的传值传递又需要先调用拷贝构造，最终逻辑形成了一个闭环，导致无穷调用。
- 若未显式定义，编译器会生成默认的构造函数。默认构造函数对象按内存存储字节完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
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;
}
上述代码中Date的拷贝构造函数我们并没有提供，由编译器默认生成。
- 编译器生成的默认拷贝构造函数既然已经可以完成字节序的拷贝，那么是否还有自己实现的必要？像日期类这样的类是没什么必要的，但是当类涉及资源的打开和关闭，开辟和释放时，默认生成的浅拷贝构造就无法解决问题了。
看如下的Stack类：
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;
}
在Stack类中，我们在创建s2时使用了编译器默认生成的拷贝构造函数，在main函数代码运行的过程中，似乎并没有什么问题，但是当整个程序运行结束时，程序崩溃了。这是因为Stack类涉及到了堆中空间资源的开辟，由于编译器默认生成的拷贝构造是浅拷贝，s1和s2中的_array指针指向相同的堆空间，在程序运行到结尾会调用析构函数，s1和s2对象各调用一次析构时，会导致_array指向的堆空间被释放两次，最终程序崩溃。
- 拷贝构造函数典型应用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
代码示例：
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;
}
- 拷贝构造函数其实还有一种调用方式
类名 对象名 = 已有对象名；
