四、拷贝构造函数
1.拷贝构造函数的概念
学习了构造函数可以对新对象进行赋初值后，我们可能会有一个问题：创建对象时，可否创建一个与已存在对象一某一样的新对象呢？如果可以，它又是怎么创建的？还是用构造函数进行初始化吗？
这就引出了拷贝构造函数，它只有单个形参，该形参是对本类类型对象（即，要拷贝的对象）的引用(一般常用const修饰)，用已存在的类类型对象创建新对象时由编译器自动调用。
2.拷贝构造函数的特性
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用，如果使用传值传参的方式编译器会直接报错（会引发无穷递归调用）。
举个例子：
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; }
无穷递归调用图解：
产生这个问题的原因：传值传参是将实参的一份临时拷贝作为参数传给函数，因此如果拷贝函数使用传值传参，那么在形成临时拷贝这一过程就会调用拷贝构造函数，就会导致拷贝的递归调用。
- 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
举个例子：
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; }
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
- 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面这种类呢？
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; }
运行这段代码，我们会发现程序崩溃了。
那么程序崩溃的原因是什么呢？
首先，通过调试我们发现程序崩溃是在结束程序的一瞬间，也就结束程序时出现了问题。
其次，通过上面的学习，我们知道程序结束，又或者对象在被销毁时会自动调用其析构函数，因此初步判断是析构函数出现问题。那么析构函数又为什么会出错呢？
接着，通过进一步调试分析，我们将问题锁定在拷贝构造这一部分：
如图所示，将拷贝构造这个操作注释编译器就可以成功编译。
程序分析图解：
结论：类中如果没有涉及资源申请时，拷贝构造函数写不写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
- 拷贝构造函数典型调用场景：
①使用已存在对象创建新对象
②函数参数类型为类类型对象
③函数返回值类型为类类型对象
举例：
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.运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型参数
- 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.*::sizeof?:.注意以上5个运算符不能重载。
// 全局的operator== class Date { public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } private://只有当成员变量为公有时才能编译通过 int _year; int _month; int _day; }; // 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？ bool operator==(const Date& d1, const Date& d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day; } void Test() { Date d1(2018, 9, 26); Date d2(2018, 9, 27); cout << (d1 == d2) << endl; } int main() { Test(); return 0; }
运行结果如下：
要保证这里的封装性我们有两种解决办法：
1.将全局函数声明为类的友元函数（关于友元函数之后会详细说明）；
2.直接将函数定义为成员函数。
class Date { public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } // bool operator==(Date* this, const Date& d2) // 这里需要注意的是，左操作数是this，指向调用函数的对象 bool operator==(const Date& d2) { return _year == d2._year && _month == d2._month && _day == d2._day; } private: int _year; int _month; int _day; }; void Test() { Date d1(2018, 9, 26); Date d2(2018, 9, 27); cout << (d1 == d2) << endl; } int main() { Test(); return 0; }
运行结果如下：
2.赋值运算符重载
1.赋值运算符重载格式
- 参数类型：
const T&，传递引用可以提高传参效率 - 返回值类型：
T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值 - 需要检测是否自己给自己赋值
- 返回
*this：要符合连续赋值的含义（如a=b=c=1,“=”运算符是从右至左结合,意味着先将1赋给c,再将c赋给b,再将b赋给a,此时 a,b,c都是1,即完成了连续赋值。）
class Date { public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } Date(const Date& d) { _year = d._year; _month = d._month; _day = d._day; } Date& operator=(const Date& d) { if (this != &d) { _year = d._year; _month = d._month; _day = d._day; } return *this; } private: int _year; int _month; int _day; };
2.赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date { public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } int _year; int _month; int _day; }; // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数 Date& operator=(Date& left, const Date& right) { if (&left != &right) { left._year = right._year; left._month = right._month; left._day = right._day; } return left; }
运行结果：
编译失败：error C2801: “operator =”必须是非静态成员
出错原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
