四、 拷贝构造函数
前言：想在创建对象时，创建一个与已存在对象一某一样的新对象
- 问题再现
- C 中原生版本
想要创建一个与已存在对象一某一样的新对象，但在下面的创建过程中，会出现什么问题？
但 类 Stack stk1 在调用的时候，还能否像上面 类Date（）那样 的传参拷贝? - 问题分析：对于如果有自己开辟的空间，浅拷贝/值拷贝会出现二次析构的风险 。传值传参（值拷贝），形参st（ st1 的一份临时拷贝（形参对实参没有影响），既然是拷贝，那么a指针都指向同一地址）。
- st出了func2会自动调用一次析构函数【临时拷贝（形参对实参没有影响）st里的a析构置空nullPtr，并不影响原实参里的指针a还指向原来的地址】。
- 当 Stack st1 出main函数时，又还会自动调用一次析构函数 。
则对于Stack来说，那还是 浅拷贝，赋的指针还是跟原来一样，指向同一块地方，那就重演刚刚同一块空间发生两次析构，则会出现 函数崩溃 的情况。
而且这也并不是在创建新对象，指针都指向的是同一块内存空间，这并不是真正意义上的创建一个新对象。
真正的创建新对象是：另外再开辟一个跟原来相同大小的空间，这两个对象都分别指向自己对应的空间，而不是指向同一个。指向同一个的，那只是 浅拷贝/值拷贝 。
C++里浅拷贝/值拷贝 在会有风险，深拷贝才能解决问题。
- 如何解决问题：
传参 拷贝时，拷贝构造（深拷贝）
默认生成 的 值拷贝
【对于 需要自己开的空间 的，都需要 深拷贝（另外再开辟一个跟原来相同大小的空间）】
类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
所以也就有了 C++中拷贝构造函数 的引入。
☆ C++规定，自定义类型对象传参拷贝，必须调用拷贝构造
默认成员函数，会对 类里 内置成员函数 完成 值拷贝，自定义类型 调用其 拷贝构造
- Date都是内置类型，都只需要用默认生成拷贝（默认拷贝构造函数）完成值拷贝即可【兼容C语言，C就是传值传参完成 值拷贝】
- MyQueue 则因为是由栈Stack来实现，Stack里面本身就写好了拷贝构造函数，每传参 调用一次Stack类就需要经过一次拷贝构造。
- 而Stack （为基础单元时，指针所指向的 开辟的空间 需要深拷贝，所以要自己写拷贝构造）则需要自己写拷贝构造，完成深拷贝
顺序表（和栈的拷贝差不多）、链表（一个节点那样开辟，数据拷贝）、二叉树【自己开的空间的，都需要深拷贝】
（一）拷贝构造函数 的概念
★ 拷贝构造：调用同类型的对象来赋值初始化这个对象 。
拷贝构造函数：
- 只有单个形参
- 该形参是 对本类类型对象的引用 (一般常用const修饰)
- 在用已存在的类类型对象 创建新对象时 由编译器自动调用。
（二）拷贝构造函数 的特征
拷贝构造函数也是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 ，使用传值方式编译器直接报错，因为会引发无穷递归调用。
- 若未显式定义 ，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝 ，这种拷贝叫做 浅拷贝，或者 值拷贝 。
【注意：在 编译器生成的默认拷贝构造函数中，内置类型按照字节方式直接拷贝，而自定义类型 调用其拷贝构造函数 完成拷贝的 。】
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; }
- 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
这里需要看情况：
1. 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；
2. 一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
【 详细用例就在我们前面说的四、拷贝构造函数 二次析构，同一块空间多次释放会造成程序崩溃 的问题 】
明白了就不用在看这部分的例子了。
// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。 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; }
- 拷贝构造函数典型调用场景：
- 使用已存在对象 创建新对象
- 函数参数类型 为类类型对象
- 函数返回值类型 为类类型对象
（ 完整代码放后面了 ）
1）尽可能传引用
尽管C++传值拷贝，有拷贝构造函数进行初始化，碰到的像 Date d2（d1）这样的还好，只需要传12个字节的内容，而要是像 Tree（） 这样的结构进行传值拷贝，拷贝构造，效率则会极其低下。
能用 传引用就用传引用（ 底层本质就是用指针实现，在代码运行上和指针效率一样，引用更多的是方便了程序员进行代码敲写 时的 ）
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用 尽量使用引用。
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; }
temp出了作用域，函数栈帧销毁【只能用传值返回】， return temp；
返回类型Date ，temp传回的是temp的一份临时拷贝（ 需要调用创建一个新的 Date（）对象，并将temp赋值给其，就得 再经历一次拷贝构造【 效率就已经极其低下了 】）
要是加上static，出了作用域没有销毁，就能用 传引用返回 了，【 就少一次拷贝构造，效率嘎嘎高 】
更正
Date& Test(Date d) { static Date temp(d); return temp; } int main() { Date d1(2022,1,13); Test(d1); return 0; }
五、赋值运算符重载
前言：运算符重载（运算符重载出现的意义）
- 内置类型对象，计算机中本身就自带的类型，了解各内置类型的定义，可根据计算机的大小比较规则进行。（内置类型对象可以直接用各种运算符，内置类型都是简单类型，语言自己定义的，编译直接转换成指令）
- 自定义类型，人为定义的类型，编译器不知道你 定义的类型中各项大小的比较的比较规则【自定义类型比较用函数来实现（存在逻辑）】，所以无法用使用各种运算符 。
自定义类型 运算符默认不支持（ 想支持就 运算符重载 ）。
C++ 为了增强代码的可读性引入了运算符重载
（一）运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
（1）运算符重载 基本概念
- 关键字operator
- 函数名字：关键字operator后面接需要重载的运算符符号 。
- 函数原型：返回值类型 operator操作符(参数列表)
注意：
- 不能通过连接 其他符号 来 创建新的操作符 ：比如operator@
- 重载操作符 必须有一个 类 类型参数 —> 不能通过重载运算符，而改变内置类型的运算规则
- 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.*::[ 域 ]sizeof[ 大小 ]?:[ 三目运算符 ].[ 对象变量(结构体)取其成员 ]
注意 以上5个运算符不能重载。这个经常在笔试选择题中出现。.*这个了解一下就好，这个用的真的太少了
* 可以重载，不要混淆了
* : 1. 乘 2. 解引用 （ 双重含义 ） ==> 祖师爷顺着这个思路启发，运算符可以有多重含义 => 运算符重载
【C++】C++入门详解 I 中，的 （二）C++输入输出 的特性：可自动识别变量类型
- << 流运算符 自动识别类型（实际上是通过 运算符重载 operate << （）, 函数重载 ，参数（类型）匹配， 函数名修饰规则，去调用对应的函数 ，这个函数别人在库里面已经写好了，内置类型能支持，自定义类型就是函数重载 ）
- 放在类里面，默认第一个参数就是 this指针指向的类对象 （Date对象默认占据第一个位置），<< 实现的成员函数 不符合可读性， 换方向后不知道是 流插入 还是 流提取 了
- 双操作数的运算符，第一个参数是左操作数（ this 指针，隐藏的默认参数 ），第二个参数是右操作符
- 放到全局，就不用Date对象默认占据第一个位置了
- private 暂且 不设置私有
但 将成员函数 private 设置为 public 公有 ，这种是 不可取 的
- Java :访问私有访问不了，=> get 和 set
- C++：友元函数
- 总结：
- 其他运算符一般是实现成 成员函数
>><<流运算符必须是实现到全局，这样才能让流对象做第一个参数，才符合可读性。
- 分析：
- 流的本质 是为了解决，自定义类型 的输入和输出问题。
printf scanf（“%?”）[ 只能解决内置类型 ]，而无法解决自定义类型 的出入输出问题（C无法解决这个问题） 面向对象+ 运算符重载解决【 彻底解决自定义类型 】
这里是 对控制台console的 输入和输出
后面还解决了 文件file 和 字符串string 的输入和输出
<<>> 双重意义：
- 流输入和输出
- 位运算符（左移右移）=》整型才能左移右移 【 自定义类型不存在位运算（左移右移），只有整型才能运用 】
- 分清：
cin/cout +<<>>+ 自定义类型 => 流插入/流提取
cin/cout +<<>>+内置类型 => 也是 流插入/流提取 【 只不过是自动识别类型，库里已经写好了重载的函数 】<<>>+ 整型 => 位运算（左移右移）
（二）赋值运算符重载
（1） 赋值运算符重载格式
- 参数类型：const T& ，传递引用可以提高传参效率
- 返回值类型：T& ，返回引用可以提高返回的效率，有返回值目的是为了 支持连续赋值
- 检测是否自己给自己赋值
- 返回*this ：要复合 连续赋值 的含义
（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 =”必须是非静态成员
原因：赋值运算符如果不显式实现，编译器会生成一个默认的。
此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
（3）用户没有显式实现时，编译器（自动）会生成一个默认赋值运算符重载，以值的方式逐字节拷贝
注意：内置类型成员变量 是 直接赋值 的，而 自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值 。
class Time { public: Time() { _hour = 1; _minute = 1; _second = 1; } Time& operator=(const Time& t) { if (this != &t) { _hour = t._hour; _minute = t._minute; _second = t._second; } return *this; } 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; Date d2; d1 = d2; 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; s2 = s1; //没有写赋值运算符重载函数，编译器会自动生成的默认赋值运算符重载函数完成字节序的值拷贝/浅拷贝 return 0; }
六、前置++和后置++重载
七、日期类的实现
【会单独开一篇文章来今进行讲解 前置++和后置++重载 和 日期类的实现 ，到时候会把文章链接 放在这里】
八、const成员函数
语法：在成员函数后面 放 const 【 实际中的意义：const 成员函数】
将const修饰的“成员函数” 称之为 const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中 不能对类的任何成员 进行修改。
请思考下面的几个问题：
【解析如下图 的 下部分】
- const对象可以调用非const成员函数吗？
不能（权限不能放大） - 非const对象可以调用const成员函数吗？
可以（权限可缩小）
【解析如下图 的 上部分】
- const成员函数内可以调用其它的非const成员函数吗？
不能（权限不能放大） - 非const成员函数内可以调用其它的const成员函数吗？
可以（权限可缩小）
const Date * 【const this】=> 相当于const 变量被初始化【 const int i = j 】，并不会出现 权限的放大问题
- 成员函数定义的原则：
- 不进行 成员变量的修改 的 成员函数，就都加const
【是挺好的】，这样 const 对象[ 权限可平移 ] 和 非const对象[ 权限可缩小 ] 都可以调用 const成员函数
- 但也不是所有成员函数都要加 const，要进行成员变量的修改的成员函数，不能被定义成const
【带const的成员变量 就更不可能传给 非const（可被修改）的成员函数 了】 const对象不能调用（很合理）非const才能调用
【那要 注意传参时，传的顺序要对应好，不要发生权限放大 就行了】
- 成员函数才要加 const
- 特点：声明和定义都得写 const
九、取地址 及 const取地址操作符重载
6大默认成员函数中的最后两个
默认成员函数，任何类在什么都不写时（ 没有显示实现 ），编译器会自动生成 。
为了逻辑自洽，自定义类型 用运算符 都得重载 。
本质：取地址 重载（参数不同） => 函数名修饰规则
虽然重载了也没什么用，就算不重载，这两个其中一个都可以用 。
const能调用const，非const 也能调 const [ 权限缩小 ]会找更匹配的
class Date { public : //取地址操作符重载 ( 普通对象取地址 ) Date* operator&() { return this ; } //const取地址操作符重载 （ const对象取地址 ） const Date* operator&()const { return this ; } private : int _year ; // 年 int _month ; // 月 int _day ; // 日 };
编译器没有这些中间步骤，编译器不需要加上隐藏的this指针，再进行编译 ，编译器直接就转汇编了，用指令就去取了隐藏的this指针，不存在中间步骤死循环的问题。
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，
只有特殊情况，才需要重载，比如 想让别人获取到指定的内容 ！
【一般的类都不需要去重载 这个问题】
