引言：

上次我们主要学习了类的相关知识，今天我们就来学习类和对象(中)，今天也会用到之前学习过的东西，可以说是前面知识的结合，较前面会难一点（打个预防针）。

一：类的默认成员函数

通俗来说，默认成员函数就是我们没有自己写，但是编译器也会自动生成的一种函数，一般来说，一个类有六个默认成员函数，但是最后的两个：取地址重载不是那么重要，只需简单了解即可。其实C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面才会学到。默认成员函数很重要，也比较复杂，我们可以从以下两个方面去学习：

1. 我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。
2. 编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

下面我们就来重点学习前面这四个默认成员函数。

二：构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。
构造函数的特点：

1. 函数名与类名相同。
2. 无返回值。(什么都不用写，不用抬杠，祖师爷这么规定的)
3. 对象实例化时系统会自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是：不传实参就可以调用的构造就叫默认构造。
7. 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节才会学。
   说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

1. 构造函数形式

2. 构造函数的自动调用

解读：这里我们在实现的构造函数里面加上了一句打印语句来判断构造函数是否被调用，通过运行程序我们可以看到构造函数是自动调用的，并且通过打印这个日期也是可以看到初始化正常。

3. 构造函数重载

解读：这里我们的两个构造函数一个带参一个不带参，构成了函数重载，我们在实例化对象的时候，编译器就会自动调用对应的构造函数，这里我们通过加上输出语句也可以看到编译器确实是自动调用了相应的构造函数。这里需要注意的一个点就是，当我们想调用不带参的那个构造函数时，这里是不用加（）的，为了避免与函数声明产生冲突。

但是这里完全可以写成一个全缺省的形式，这样只需要一个就能满足需求。

4. 内置类型和自定义类型调用构造函数的区别

这里我们利用之前实现的栈来和日期类进行一个对比：

解读：明显可以看到，对于内置类型的Date，编译器生成的默认构造函数并没有对其成员进行初始化，但是对于自定义类型Mystack 中的 st1 和st2 ，编译器都对其进行了初始化。

5. 小结：

大多数的类，我们都需要自己来实现构造函数，但是对于少数的自定义类不需要自己来实现构造函数，比如Mystack可以自己使用默认生成的构造函数。

三：析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。
析构函数的特点：

1. 析构函数名是在类名前加上字符~。
2. 无参数无返回值。(这里跟构造类似，也不需要加void)
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，系统会自动调用析构函数。
5. 跟构造函数类似，我们不显示写的话，编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用他的析构函数。
6. 还需要注意的是即使我们显示写析构函数，对于定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
7. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如Stack。
8. 一个局部域的多个对象，C++规定后定义的先析构。

1. 析构函数形式

2. 析构函数的自动调用

解读：这里我们在析构函数里面加上了一个打印语句来验证编译器是否自动调用了的析构函数，通过运行程序可以看到在运行结束后编译器确实自动调用了析构函数。

3. 内置类型和自定义类型调用析构函数的区别

解读：可以看到我们在实例化阶段初始化的日期类 d1在结束时编译器生成的析构函数对没有对其进行处理，但是对于Mystack类型的 q1 在结束时，编译器调用了其成员自己的析构函数，进行了空间的释放。虽然日期类 d1 的析构函数没有对其进行处理，但其在结束时函数栈帧已经销毁，不处理其实也没事，但是像 q1 存在动态空间的申请，必须要进行处理的。

4. 析构函数的调用顺序

解读：可以看到在对象的生命周期结束之后，是后定义的st2先进行的析构。

5. 小结：

如果类里面没有申请资源，一般都不需要写析构函数，但是如果类里面涉及到了资源的申请，除了像Mystack 这种自定义类型，一般都是需要自己来写析构函数的。

四：拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是拷贝构造是一个特殊的构造函数。
拷贝构造函数的特点：

1. 拷贝构造函数是构造函数的一个重载。
2. 拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。
3. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
4. 若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。这里还有一个小技巧：如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。
6. 传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回。

1. 拷贝构造函数形式

解读：这里是利用拷贝构造来对另一个对象进行初始化，这里其实是会将d2的地址传过去，然后在拷贝构造函数中通过this指针来对d2进行初始化。

注意：如果拷贝构造函数这里的参数不加const 的话，很可能会出现一系列的错误
下面给这样一个场景

这里我们没有加const ，因此就算出现了权限放大的情况，这里也没有进行报错，所以建议加上const 比较好。

2. 拷贝构造函数无限递归问题分析

首先来看一个较为简单的例子：

再来看一个复杂的情况：

解读：由于拷贝构造函数是传值传参，因此在每次调用拷贝构造之前都会进行传值传参，但是每次传值传参都会生成新的拷贝构造，这样就形成了无穷递归。
打个比方：其实就像一件事需要你亲自去做，但是你交给了手下的一个人，手下的这个人又交给下一个人，就这样一直重复下去，最终这件事怎么也做不成。

3. 深拷贝/浅拷贝引发的问题

错因分析：

这里我们在对栈进行拷贝构造的时候出现了问题，因为浅拷贝不适合于栈，因为栈里面存在动态申请的资源_a，因此浅拷贝的话会造成s1和s2指向了同一块空间，但是在对象的生命周期结束之后，析构函数是会调用两次，也就是说同一块空间会释放两次，这样不就出错了嘛。因此这里需要深拷贝来解决。

这里在进行拷贝构造时，先为_a申请一块空间，之后再利用memcpy进行拷贝，
这样就不会产生问题了。

4. 小结：

如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造（深拷贝），否则就不需要。

五：运算符重载

1. 当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
2. 运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
3. 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
4. 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
5. 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
6. 不能通过连接语法中没有的符号来创建新的操作符：比如.* :: sizeof ?: .
   注意以上5个运算符不能重载。(选择题里面常考，大家要记⼀下)
7. 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： intoperator+(int x, int y)
8. 一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义。
9. 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。
10. 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第二个形参位置当类类型对象。

场景一：不包含类类型形参的重载

场景二：对[] 运算符重载

这里用到了之前实现过的顺序表


解读：这里我们通过对[]的重载，让seqlist类也能像数组一样对数组元素进行操作，这里我们采取了引用返回，可以减少拷贝，提高效率，并且还可以对数组元素进行修改。

可以看到我们还可以对数组元素进行修改。

场景三：对 == 运算符的重载

一开始我们会这样写：

但是由于这些变量是类里面的私有成员，无法在外类外访问，但是我们要实现==的重载需要访问这些成员，那么该怎么办呢？

方法一：将私有成员放开

但是这样写有点不合适，因为不用const 限制的话，很有可能会出现权限放大的情况，因此还是加上const 比较好

方法二：通过公共函数来获取私有成员

这里为什么后面要加const 还无法解释，后面再讲解

方法三：将重载定义在类里面
我们刚开始可能会这样写：

但这里为什么报错参数过多呢？从前面对重载的介绍我们得知，运算符的重载的参数要和其运算对象的数量一样多，这里的==的作用对象是两个，因此这里重载的参数也应该是两个，但是这里我们不是写了两个参数吗？别忘了在类里面的函数参数第一个都默认为this指针，因此这里一共有三个参数，因此才会报错，因此只需保留一个即可，第一个类的地址会被this指针接收的。

左边其实就是this指针代表了d1来和d2作比较。

其实这里的重载写成显示的也可以：

场景四：对 = 赋值运算符重载

赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。
赋值运算符重载的特点：

1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const当前类类型引用，否则传值传参会有拷贝。
2. 有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
3. 没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。
4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载。这里还有⼀个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

初始情况我们可能写成这样：
注：有返回值是为了支持连续赋值的情况

但是这里会存在一个问题：当一个对象自己给自己赋值时是不是就没有必要再执行赋值的逻辑了呢？因此这里加上一个判断比较好。

我们知道传值返回会调用拷贝构造，因此这里用传引用返回的话可以减少拷贝，提高效率，并且this指针也不会消失，因此这里狠狠用引用返回。


赋值操作没问题。

连续赋值也没问题。

场景五： 赋值运算符与拷贝构造的区分

记住这句话：赋值运算符重载是针对两个已经存在的对象，而拷贝构造是在实例化对象的时候进行的。

约定：

下面我们就在完善日期类的基础上实现其他的运算符重载。

场景六：＋=运算符重载（日期和天数）

由于这里的日期类加天数有可能会牵扯到月份以及年份的进位，但是每个月份的天数不是全部相同，因此这里我们要先实现获取每个月天数的函数。

为了方便获取每个月份的天数，这里我们创建了一个月份数组，为避免频繁创建，这里我们将其定义成了静态数组，后面只需特判一下二月的不同情况即可。
（这里的if判断条件中的小细节就是将判断是否是二月条件放在前面，能快速筛选不满足条件的情况）
重载+=运算符实现：

注：这里为了避免拷贝，这里我们采取传引用返回。

通过测试可以发现实现的+=运算符没有问题。

场景七：+运算符重载（日期和天数）

这里我们就可以通过复用上面实现的+=运算符来实现+运算符的重载。



通过测试可以看到，d2确实是d1的100天之后，而且d1也没有改变，没有问题。

场景八：+运算符重载和+=运算符重载的复用分析

前面我们通过复用+=运算符重载来实现的+运算符的重载，其实我们也可以先将+运算符的重载实现好，然后复用+运算符的重载来实现+=运算符的重载。

其实现逻辑与+=运算符重载的逻辑基本上一模一样，只是需要一个临时对象来代替其来进行运算。

注：这里需要注意的是这里因为返回的是一个临时变量，因此不能用引用返回。
复用+运算符重载来实现+=运算符重载：

分析这两种实现方式的优劣：

场景九：-=运算符重载（日期和天数）

这里的－＝是针对某个日期加上一个天数来重载的，逻辑实现和＋＝类似，先让天数减去这个天数，只要小于0就一直向月份借位。

场景十：-运算符重载（日期和天数）

这里-的重载就可以复用上面-=运算符的重载。

场景十一： + += - -=运算符重载的遗留问题

上面我们实现了这些运算符的重载，但是实现的还是不够严谨，比如这里的+=可能会加上一个负值，这时候的_day可能就是一个负值，连while循环都进不去，这里的-=也可能会减去一个负值，这时候的_day就是一个正数，连while循环都进不去，因此这里都需要特判一下：

场景十二：前置++ 和后置++ 运算符重载

首先先来看C++的一个规定：
前置＋＋重载时不带参数，后置＋＋要带参，相当于强制构成函数重载了。


由于后置＋＋返回的是一个临时变量，因此不能用引用。

可以看到测试没问题。

场景十三：前置-- 和后置-- 运算符重载

场景十四：-运算符重载（日期和日期）

对于两个日期的相减，由于月份的不统一，还要处理借位的情况，很麻烦，但是我们其实可以换一种思路，如果我们先确定两个日期的大小，让较小的那个日期一直加1，用一个计数器来记录两者相差多少天，一直到两者相等就停止，这样就可以知道两个日期的天数差了。

场景十五：比较运算符的重载

在实现完<运算符的重载之后就可以复用这个来实现其他比较运算符的重载。

六：const成员函数

我们先来看下面这个场景：

这里我们用const来修饰实例化出的对象d1时，会发现d1不能调用Print函数了，那么这是为什么呢？其实这里牵扯到了权限的放大。

但是由于this指针是隐式传参的，这里我们该怎么样来加const呢？
其实C++给出了解决方法：

只需在成员函数列表的后面加上const即可。
这样this指针就由Date* const this变为 const Date* const this

这样不管是const修饰的对象还是没有const修饰的对象都可以调用成员函数了。

小结：

1. 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后面。
2. const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this

七：取地址运算符重载

1. 取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。
2. 除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址时就可以重载取地址运算符，胡乱返回一个地址。

编译器自动生成的取地址运算符逻辑一般都是这样：

重载取地址运算符

这时候就是一个假地址。

但是这样写其实没有什么实际意义。

八：完结：

撒花！！！