假如没有给你生命，你连失败的机会都没有。你已经得到了最珍贵的，还需要抱怨什么!💓💓💓
目录
✨说在前面
亲爱的读者们大家好！💖💖💖，我们又见面了，上一篇文章中我带大家学习了C++类和对象的第一个部分，也是比较基础的一个部分，如果大家没有掌握好，可以再回去看看，复习一下，再进入今天的内容。
今天我们将要学习类和对象里边非常重要也比较有难度的一个部分。如果大家准备好了，那就接着往下看吧~
👇👇👇
💘💘💘知识连线时刻（直接点击即可）🎉🎉🎉复习回顾🎉🎉🎉
博主主页传送门：愿天垂怜的博客
🍋知识点一：类的默认成员函数
• 🌰1.什么是默认成员函数？
默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们了解一下即可。其次就是C++11以后还会增加两个默认成员函数：移动构造和移动赋值，这个我们后面再讲解。默认成员函数很重要，也比较复杂，我们要从两个方面去学习：
🔥我们不写时，编译器默认生成的函数行为是什么？是否满足我们的要求？
🔥如果编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？
• 🌰2.构造函数
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。
构造函数的特点：
🔥函数名与类名相同。
🔥无返回值。 (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
🔥对象实例化时系统会自动调用对应的构造函数。
🔥构造函数可以重载。
🔥如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
🔥无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多人会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调用的构造就叫默认构造。
🔥我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。
说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。
示例1：构造参数的使用
#include<iostream>
using namespace std;
class Date
{
public:
//1.无参构造函数
/*Date()
{
_year = 1;
_month = 1;
_day = 1;
}*/
// 2.带参构造函数
/*Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}*/
// 3.全缺省构造函数
Date(int year = 1, 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()
{
// 如果留下三个构造中的第二个带参构造，第一个和第三个注释掉
// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可用
Date d1; // 调用默认构造函数
d1.Print();
Date d2(2025, 1, 1); // 调用带参的构造函数
/d2.Print();
// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法
// 区分这里是函数声明还是实例化对象
// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
Date d3(2024);
d3.Print();
return 0;
}示例2：使用编译器默认的无参构造函数
#include<iostream>
using namespace std;
//栈的构造函数Init
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
// ...
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue mq;
return 0;
}
• 🌰3.析构函数
析构函数与构造函数的功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，它就释放了，不需要我们管。C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以说Date是不需要析构函数的。
析构函数的特点：
🔥析构函数名是在类名前加上字符 ~。
🔥无参数无返回值。（和构造函数类似，也不需要加void）。
🔥一个类只能有一个析构函数，若未显式定义，系统会自动生成默认的析构函数。
🔥对象生命周期结束时，系统会自动调用析构函数。
🔥和构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义成员会调用它的析构函数。
🔥需要注意的是我们显式写析构函数，对自定义类型成员也会调用它的析构，也就是自定义类型成员无论什么情况都会自动调用析构函数。
🔥如果类中没有申请资源时，析构函数可以不写，直接使用编译器默认生成的析构函数，如Date；如果编译器默认的析构函数就可以用，也就不需要显式写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄露，如Stack。
🔥一个局部域的多个对象，C++规定后定义的先析构。
示例1：析构函数的使用
#include <iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
//构造函数
Stack(int n = 4)
{
_arr = (STDataType*)malloc(sizeof(STDataType) * n);
if (_arr == nullptr)
{
perror("malloc operation failed");
return;
}
_capacity = n;
_top = 0;
}
//析构函数
~Stack()
{
free(_arr);
_arr = nullptr;
_capacity = _top = 0;
}
private:
STDataType* _arr;
int _capacity;
int _top;
};
int main()
{
//先析构st2再析构st1
Stack st1;
Stack st2;
return 0;
}示例2：自定义类型成员自动调用它的析构
#include <iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
//构造函数
Stack(int n = 4)
{
_arr = (STDataType*)malloc(sizeof(STDataType) * n);
if (_arr == nullptr)
{
perror("malloc operation failed");
return;
}
_capacity = n;
_top = 0;
}
//析构函数
~Stack()
{
free(_arr);
_arr = nullptr;
_capacity = _top = 0;
}
private:
STDataType* _arr;
int _capacity;
int _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放Stack内部的资源
//显式写析构，也会自动调用Stack的析构
~MyQueue()
{
cout << "~MyQueue()" << endl;
}
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue mq;
return 0;
}🌰4.拷贝构造函数
如果一个构造函数的第一个参数是自身类类型的引用，且任何额外参数都有默认值，则此构造函数也称为拷贝构造函数，也就是说拷贝构造时一个特殊的构造函数。
🔥拷贝构造函数是构造函数的一个重载。
🔥拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。
🔥C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
🔥成员变量会完成值拷贝/浅拷贝（一个字节一个字节的拷贝），对自定义类型成员变量会调用他的拷贝构造。
🔥像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显式实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_arr指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝（对指向的资源也进行拷贝）。像MyQueue这样的类型内部主要是自定义的Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显式实现MyQueue的拷贝构造。这里还有一个小技巧，如果一个类显式实现了析构并释放资源，那么他就需要显式写拷贝构造，否则就不需要。
🔥传值返回会产生一个临时对象调用的拷贝，传值引用返回，返回的是返回对象的别名（引用），没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回时有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能引用返回。
示例1：拷贝构造函数的使用
#include <iostream>
using namespace std;
class Date
{
public:
//默认构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
//拷贝构造函数
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
//这个函数可以不写，默认的的够用
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 7, 16);
//将d1赋值给d2
Date d2(d1);
return 0;
}示例2：不能使用默认拷贝构造函数的情况
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
//默认构造函数
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
//拷贝构造函数
Stack(const Stack& st)
{
//需要对_a指向资源创建同样大的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (nullptr == _a)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
//入栈
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
//析构函数
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
//两个Stack实现队列
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
//Stack不显示实现拷⻉构造，用自动生成的拷⻉构造完成浅拷⻉
//会导致st1和st2里面的_a指针指向同一块资源，析构时会析构两次，程序崩溃
Stack st2(st1);
MyQueue mq1;
//MyQueue自动生成的拷⻉构造，会自动调用Stack拷⻉构造完成pushst/popst
//的拷⻉，只要Stack拷⻉构造自己实现了深拷⻉，他就没问题
MyQueue mq2 = mq1;
return 0;
}
警示：自定义类型用传值传参是不好的。在C语言程序中，本来传参不改变原结构体的内容，但是如果结构体中有malloc动态申请或指针相关，传值拷贝会使它们指向用一块空间，从而改变到实参，这是C语言的缺陷。为了弥补这个缺陷，在C++中，我们直接传引用，如果不希望它被改变，在前面加上const就好了。
示例3：野引用
#include <iostream>
using namespace std;
Stack& function()
{
Stack st;
return st;
}
int main()
{
Stack ret = function();
return 0;
}上面这个例子，如果是传值返回，那么st会被拷贝到另一个临时对象中，从而和st本身的生命周期无关；但如果是传引用返回，返回的是st的别名，此时和st的生命周期有关，st出函数function被销毁，所以相当于野引用，上面这样的写法是错误的。
🍋知识点二：赋值运算符重载
🌰1.运算符重载
🔥当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
🔥运算符重载是具有特别名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
🔥重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
🔥如果一个重载运算符函数是成员函数，则它的第一个运算对象默认让给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
🔥运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
🔥不能通过连接语法中没有的符号来创建新的操作符，例如operator@。
🔥 .+* :: sizeof ? ：.注意以上5个运算符不能重载。（选择题里面常考，大家要记一下）。
🔥重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如 int operator+(int x, inty)。
🔥一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就是有意义的，但是重载operator+就没有意义。
🔥重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加一个形参，跟前置++构成函数重载，方便区分。
🔥重载 << 和 >> 时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把 ostream / istream 放到第一个形参位置就可以了，第二个形参位置当类类型对象。
示例：日期类判断是否相等
#include <iostream>
using namespace std;
class Date
{
public:
//默认构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
//拷贝构造函数
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
//运算符重载函数
bool operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
//这个函数可以不写，默认的就够用
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 7, 16);
Date d2(d1);
if (d1.operator==(d2))
//if (d1 == d1)
//写d1 == d2也会自动转成d1.operator==(d2)
{
printf("Copyed succesfully!");
}
}注意：当全局域和类域中都有operator==重载函数，优先调用类域中的函数。
🌰2.赋值运算符重载
赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象的直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。
赋值运算符重载的特点：
🔥赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算符重载的参数建议写成const当前类类型引用，否则传值传参会有拷贝。
🔥有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值的场景。
🔥没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝（一个一个字节的拷贝），对自定义类型成员变量会调用他的赋值重载。
🔥像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显式地区实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_arr指向了资源，编译器自动生成的赋值重载运算符完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝（对指向的资源也进行拷贝）。像MyQueue这样的类型内部主要是自定义的Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显式实现MyQueue的赋值运算符重载。这里还有一个小技巧，如果一个类显式实现了析构并释放资源，那么他就需要显式写赋值运算符重载，否则就不需要。
#include <iostream>
using namespace std;
class Date
{
public:
//默认构造函数
Date(int year, int month, int day);
//拷贝构造函数
Date(const Date& d);
//赋值运算符重载函数 - 需要有返回值且当前类类型引用返回
Date& operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
//打印日期
void Print();
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 7, 16);
//拷贝构造
Date d2(d1);
Date d3 = d2;
//赋值重载拷贝
d2 = d3;
return 0;
}补充： .* 运算符是什么意思？
#include <iostream>
using namespace std;
class A
{
public:
void Func()
{
cout << "A::Func()" << endl;
}
};
//成员函数指针类型
typedef void(A::*PF)();
int main()
{
//void(A:: * pf)() = nullptr;
PF pf = nullptr;
//C++规定成员函数要加&才可以取到函数指针
pf = &A::Func;
A a;
(a.*pf)();
return 0;
}🌰3.日期类实现
到现在，我们已经学习了构造函数、析构函数、拷贝构造和运算符重载，我们现在可以利用这些知识实现一个完整的日期类：
🔥头文件声明
由与日期类没有申请资源，所以不需要自己写析构函数，自然也不需要自己写拷贝构造函数和赋值运算符重载。
#pragma once
#include <iostream>
using namespace std;
#include <assert.h>
class Date
{
//友元函数声明
friend istream& operator>>(istream& in, Date& d);
friend ostream& operator<<(ostream& out, const Date& d);
public:
//默认构造函数
Date(int year = 2024, int month = 7, int day = 16);
//打印日期
void Print() const;
//获得月份天数 频繁调用的短小函数，默认inline
int GetMonthDay(int year, int month) const
{
assert(month > 0 && month < 13);
static int monthDayArray[13] = { -1, 31,28,31,30,31,30,31,31,30,31,30,31 };
if ((month == 2) && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
return 29;
}
return monthDayArray[month];
}
//检查日期
bool CheckDate() const
{
if (_month < 1 || _month > 12
|| _day<1 || _day > GetMonthDay(_year, _month))
{
return false;
}
else
{
return true;
}
}
//运算符重载
bool operator<(const Date& d) const;
bool operator<=(const Date& d) const;
bool operator>(const Date& d) const;
bool operator>=(const Date& d) const;
bool operator==(const Date& d) const;
bool operator!=(const Date& d) const;
Date& operator+=(int day);
Date operator+(int day) const;
Date& operator-=(int day);
Date operator-(int day) const;
//前置++
Date& operator++();
//后置++ operator++(0)
Date operator++(int);
//前置--
Date& operator--();
//后置--
Date operator--(int);
//日期 - 日期
int operator-(const Date& d);
private:
int _year;
int _month;
int _day;
};🔥基本方法实现
#define _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"
//默认构造函数
Date::Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
if (!CheckDate())
{
cout << "Invalid Date:" ;
Print();
}
}
//打印日期
void Date::Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
//日期 += N
Date& Date::operator+=(int day)
{
if (day < 0)
{
return *this -= (-day);
}
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
_month = 1;
_year++;
}
}
return *this;
}
//日期 + N
Date Date::operator+(int day) const
{
Date temp = *this;
temp += day;
return temp;
}
//日期 -= N
Date& Date::operator-=(int day)
{
if (day < 0)
{
return *this += (-day);
}
_day -= day;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
_month = 12;
_year--;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
//日期 - N
Date Date::operator-(int day) const
{
Date temp = *this;
temp -= day;
return temp;
}
//运算符重载
bool Date::operator<(const Date& d) const
{
if (_year < d._year)
return true;
else if (_year == d._year)
{
if (_month < d._month)
return true;
else if(_month == d._month)
{
return _day < d._day;
}
}
return false;
}
bool Date::operator<=(const Date& d) const
{
return *this < d || *this == d;
}
bool Date::operator>(const Date& d) const
{
return !(*this <= d);
}
bool Date::operator>=(const Date& d) const
{
return !(*this < d);
}
bool Date::operator==(const Date& d) const
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
bool Date::operator!=(const Date& d) const
{
return !(*this == d);
}
//前置++
Date& Date::operator++()
{
*this += 1;
return *this;
}
//后置++
Date Date::operator++(int)
{
Date temp = *this;
*this += 1;
return temp;
}
//前置--
Date& Date::operator--()
{
*this -= 1;
return *this;
}
//后置--
Date Date::operator--(int)
{
Date temp = *this;
*this -= 1;
return temp;
}
//日期 - 日期
int Date::operator-(const Date& d)
{
int n = 0;
int flag = 1;
Date max = *this, min = d;
if (*this < d)
{
max = d;
min = *this;
flag = -1;
}
while (min < max)
{
++min;
++n;
}
return n * flag;
}
//流插入重载
istream& operator>>(istream& in, Date& d)
{
while(1)
{
cout << "请依次输入日期：";
in >> d._year >> d._month >> d._day;
if (!d.CheckDate())
{
cout << "Invalid Date:";
d.Print();
cout << "请重新输入!!!" << endl;
}
else
{
break;
}
}
return in;
}
//流提取重载
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return cout;
}🎉流插入流提取运算符重载
重载 << 和 >> 时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把 ostream / istream 放到第一个形参位置就可以了，第二个形参位置当类类型对象。
但是，如果重载为全局函数，那么就没办法访问年月日，因为这属于类的属性，是私有的。此时我们可以利用友元函数：
//友元函数声明
friend istream& operator>>(istream& in, Date& d);
friend ostream& operator<<(ostream& out, const Date& d);
//流插入重载
istream& operator>>(istream& in, Date& d)
{
while(1)
{
cout << "请依次输入日期：";
in >> d._year >> d._month >> d._day;
if (!d.CheckDate())
{
cout << "Invalid Date:";
d.Print();
cout << "请重新输入!!!" << endl;
}
else
{
break;
}
}
return in;
}
//流提取重载
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return cout;
}友元函数在下一章节会详细讲，其实很简单，就是在函数前面加friend，就可以访问私有属性了，可以先简单这么理解。
至于为什么是用istream&和ostream&，这是因为cin和cout是istream流和ostream流类的对象，所以他们的类型应该这么写。
可能还会有人问，在operator>>中，使用cout会不会有什么问题？其实是不用担心的。在cin注释中有这样一句话：
cin is tied to the standard output stream cout (see ios::tie), which indicates that cout's buffer is flushed (see ostream::flush) before each i/o operation performed on cin.
大致意思是，cin和cout是绑定在一起的，所以在cin执行i/o操作前会将cout的缓冲区刷新，所以不必担心。
注意：上述operator-可以复用operator-=进行实现，相反，也可以用复用operator-来实现operator-=：
operator-复用operator-=:
//日期 -= N
Date& Date::operator-=(int day)
{
_day -= day;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
_month = 12;
_year--;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
//日期 - N
Date Date::operator-(int day)
{
Date temp = *this;
temp -= day;
return temp;
}operator-=复用operator-:
//日期 -= N
Date& Date::operator-=(int day)
{
*this = *this - day;
return *this;
}
//日期 - N
Date Date::operator-(int day)
{
Date temp = *this;
temp._day -= day;
while (temp._day <= 0)
{
temp._month--;
if (temp._month == 0)
{
temp._month = 12;
temp._year--;
}
temp._day += GetMonthDay(temp._year, temp._month);
}
return temp;
}那么，哪种复用更好呢？
首先，对于operator-来说，其实没什么区别，都是在刚开始的时候创建临时变量temp，调用拷贝构造函数，return的时候，创建临时变量存储temp再返回，也用到拷贝构造函数，而中间复用operator-=的过程其实没有创建临时变量且也没有用到拷贝构造，因为是传引用。
而对于operator-=，情况就不一样了。如果在operator-=中复用operator-，由于operator-是Date类型的，不是传引用，所以会涉及到拷贝构造，就比在operator-=中复用operator-多用了两次拷贝（传参一次，返回一次）和一次赋值重载。
所以，operator-复用operator-=:更好。
🍋知识点三：取地址运算符重载
🌰1.const成员函数
🔥将const修饰的成员函数称之为const成员函数，const修饰的成员函数放到成员函数参数列表的后面。
🔥const实际修饰该成员隐含的this指针，表明在该成员函数中不能对类的成员进任何修改。const修饰Date类中的Print成员函数，Print隐含的this指针由Date* const this变为const Date* const this。
很多人在上面的日期类中不知道为什么要加const，其实就是为了确保有const修饰的日期不被修改：
🌰2.取地址运算符重载
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译器自动生成的就可以够用了，不需要去显式实现。除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回一个地址。
class Date
{
public:
Date * operator&()
{
return this;
//return nullptr;
}
const Date * operator&() const
{
return this;
//return nullptr;
}
private:
int _year; // 年
int _month; // ⽉
int _day; // ⽇
};对于这两个函数来说，他们构成重载，因为一个是Date*，而另一个是const Date*；在选择用那个重载时，编译器会选择最合适最匹配的进行调用。
• ✨SumUp结语
到这里本篇文章的内容就结束了，本节是类和对象比较核心的一节，内容也比较多。这认真学习完这一节基本上熬过了这最难的一段了，希望大家能够认真学习，打好基础，迎接接下来的挑战，希望大家继续捧场~
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
