4.拷贝构造函数
1.概念
首先要知道，拷贝构造函数也是构造函数的重载。
那在创建对象时，可否创建一个与已存在对象一模一样的新对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。
举例：日期类：
class Date { public: //构造函数 Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } void print() { cout << _year << " " << _month << " " << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1(2022, 10, 10); Date d2(d1); //拷贝d1 d1.print(); d2.print(); return 0; }
2.特性
拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。函数名相同，参数不同。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
发生递归的原因：
Date(Date d) //去掉引用，就是传值调用
{
_year = d._year;
_month = d._month;
_day = d._day;
}
传值调用：当调用拷贝构造函数时，形参是实参的一份临时拷贝
调用拷贝构造Date d2(d1);，先得传参，传参调用完拷贝构造以后，本身又要调用拷贝构造，而后又要传参，然后一直自己调用自己，导致一直递归下去......
那么传地址可不可以？可以，但不就麻烦了吗？
Date(Date *d) //去掉引用，就是传值调用
{
_year = d->_year;
_month = d->_month;
_day = d->_day;
}
所以还是引用是最好的方式！
3.拷贝构造函数只有单个形参，该形参是对本类类型对象的引用，一般常用const修饰
为什么要加const呢？
Date(const Date & d) //去掉引用，就是传值调用
{
_year = d._year;
d._month=_month ; //有时候会写反，而改变了原本对象的值。
_day = d._day;
}
Date d2(d1); //拷贝d1
所以加了const以后，就不能改变d1原对象了
4. 若未显示定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。所以内置类型处理，自定义类型不处理，自定义类型可能复杂多变，需要自己写拷贝函数，这样就叫 深拷贝。
浅拷贝： 自己没有写，使用默认的 （日期类）
class Date { public: //构造函数 Date(int year = 1900, int month = 1, int day = 1) { cout << "构造函数" << endl; //验证调用所需 _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; int main() { Date d1(2022, 10, 10); Date d2(d1); //拷贝d1 return 0; }
是可以实现我们想要的功能的，所以不需要我们自己写。
举例：（栈类）
class Stack { public: Stack(int capacity = 4) { cout << "Stack(int capacity = 4)" << endl; _a = (int*)malloc(sizeof(int)*capacity); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _top = 0; _capacity = capacity; } //析构函数 ~Stack() { cout << "~Stack()" << endl; free(_a); _a = nullptr; _top = _capacity = 0; } void Push(int x) { // .... // 扩容 _a[_top++] = x; } private: int* _a; int _top; int _capacity; }; int main() { Stack s1; s1.Push(1); s1.Push(2); Stack s2(s1); }
当使用默认拷贝函数时，是否能实现我们想要的需求：
这是怎么了？？编译器自己提供的默认拷贝构造函数居然把s1拷贝到s2类中时，两个类中的指针变量指向了同一块空间！！
那么，栈的特性就是先进后出，所以s2先调用析构函数，把空间清理了，然后s1再去调用析构函数，又去清理，这不是瞎搞嘛，造成内存重复释放！
所以默认的拷贝构造函数解决不了我们的需求，需要我们自己写。
//st2(st1)拷贝构造 Stack(const Stack& st) { cout << "Stack(const Stack& st)" << endl; _a = (int*)malloc(sizeof(int)*st._capacity); if (_a == nullptr) { perror("malloc fail"); exit(-1); } memcpy(_a, st._a, sizeof(int)*st._top); _top = st._top; _capacity = st._capacity; }
即解决了指针重复指向一块空间，又把已经创建好的s1对象和其中的内容都拷贝到了s2。
总结：需要写析构函数的类，都需要写深拷贝的拷贝构造，如：Stack
不需要写析构函数的类，默认生成的浅拷贝的拷贝构造就可以用 。如：Date/MyQueue
类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
5.运算符重载
1.为什么要重载运算符
为了让自定义类型可以使用 运算符
对于日期类，我们会经常用到，某个日期加多少天来得到另一个日期。
所以日期需要加减，也需要比较，那么使用+ = - ，在C++中，就需要运算符重载，与函数重载没有关系。
2.赋值运算符重载格式
返回值+operator+运算符 +（所需参数），参数个数就是参与运算符的参数个数
class Data { public: Data(int year=1,int month=1,int day=1) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; bool operator==(Data& d1，Data& d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day; } int main() { Data d1(2022, 10, 11); Data d2(2023, 1, 1); d1==d2;//可以显式调用 operator==(d1,d2); cout << (d1 == d2) << endl; cout << (d1 > d2) << endl; }
1.定义运算符重载时，参数为引用的好处是，不需要调用拷贝函数，若是传值,参数为对象，则需要拷贝对象，调用拷贝函数。
2.定义在类外，需要将类的成员变量设置为公开，会造正麻烦，那么我们直接就定义到了类的内部。
3.若直接放入类的内部定义运算符重载，则会出现问题：
class Data { public: Data(int year=1,int month=1,int day=1) { _year = year; _month = month; _day = day; } bool operator==(Data& d) { return this->_year == d2._year && this->_month == d2._month && this->_day == d2._day; } private: int _year; int _month; int _day; }; int main() { Data d1(2022, 10, 11); Data d2(2023, 1, 1); d1==d2;//可以显式调用 operator==(d1,d2); cout << (d1 == d2) << endl; cout << (d1 > d2) << endl; }
那为什么在类中，显示的是一个参数呢？
bool operator==(Data& d)
{
return this->_year == d2._year
&& this->_month == d2._month
&& this->_day == d2._day;
}
