因为在类中定义的成员函数，都在公共区，自动会在参数中带一个this指针，为该类的创建的对象的地址。而且运算符重载限定了参数个数，则参数部分：bool operator==(Data& d)即为这样，实现则为 return this->_year == d2._year
&& this->_month == d2._month
&& this->_day == d2._day;
3.加法的实现
值得注意的一点是：加 +和 加等于+=是不一样的：
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; class Data { public: Data(int year=1,int month=1,int day=1) { _year = year; _month = month; _day = day; } int Getmonthday(int year, int month) { int a[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 }; if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 4 == 0)) { return 29; } else return a[month]; } Data& operator+=(int day) { _day += day; while (_day> Getmonthday(this->_year, this->_month)) { _day -= Getmonthday(this->_year, this->_month); _month++; if (_month > 12) { _month -= 12; _year++; } } cout << _year<<_month<<_day << endl; return *this; } Data operator+(int day) { Data ret(*this); ret +=day; return ret; } private: int _year; int _month; int _day; }; int main() { Data d1(2022, 10, 11); Data d2(2023, 1, 1); d1 + 100; d1 += 100; return 0; }
还有其他运算符重载需要大家自己实现！
6.赋值运算符重载
1.赋值运算符重载格式
参数类型 ： const T& ，传递引用可以提高传参效率（赋值
返回值类型 ： T& ，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
返回 *this ：要复合连续赋值的含义
还Date& operator=(const Date& d) { if (this != &d) { _year = d._year; _month = d._month; _day = d._day; } return *this; } d1=d2;
赋值也是一样的，有两个参数，只不过第一个是隐藏的，赋值重载也是有顺序的：d1=d2；那么传参时，d1就是第一个参数，d2就是第二个参数。（像有双操作数的运算符，前后顺序就是参数顺序）
参数加const是因为原赋值对象不希望被改变，引用作为参数也可以避免拷贝；返回类型为引用是因为可以避免调用一次拷贝构造；遇到连等的情况：d1=d2=d3；链式访问（从右到左依次执行），d2=d3；会返回d2，再执行d1=d2;这就是有返回值的好处。
引用在传值传参和传值返回时，都可以减少拷贝构造的调用，节省时间空见。
返回值返回d1和d2都是可以的，只不过在返回d2时，前面返回类型就要加const，否则会扩大权限，所以为了更加方便，返回d1，即*this。
2.拷贝构造和赋值重载
d1=d2;就是把d2的值赋值给d1，那么是不是和拷贝构造也有相似之处呢？？
当然，但二者的区别是：拷贝构造：用已存在的类类型对象 创建新对象，赋值重载：已存在的两个对象之间的拷贝
他们都是会对内置类型进行处理，自定义类型会调用它的默认构造函数。
他们都是默认成员函数，自己不写，编译器就会默认生成。关键在于，编译器默认提供的，能不能符合我们的需求！
那么我们之前总结过，拷贝构造，当要调用析构函数时，就需要我们自己去写，赋值重载也是一样的。
举例说明：栈
如果使用编译器默认的赋值重载：
class Stack { public: Stack(int capacity = 4) { cout << "Stack(int capacity = )" <<capacity<<endl; _a = (int*)malloc(sizeof(int)*capacity); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _top = 0; _capacity = capacity; } // 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; } ~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 st1; st1.Push(1); Stack st2(10); st2.Push(1); st2.Push(2); st2.Push(3); st1 = st2; return 0; }
会发现和之前的拷贝构造出现的问题挺一样的，d1和d2的_a指向的空间是一样的，结果同一块空间还析构了两次，d1原本指向的空间，没人析构，造成内存泄露。当要调用析构函数时，就需要我们自己去写。
解决方案：既然是赋值，就得内存空间一样大，里面内容一样。
索性直接将d1内存空间直接释放，创建一个和d2一样大的内存空间，然后将里面内容拷贝进去。
也防止自己赋值自己，直接把自己的内存空间释放了。
代码如下：
Stack& operator=(const Stack& st) { if (this != &st) { free(_a); _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; } return *this; }
7.<<和>>运算符重载
<<在C语言中是左移的意思，但在c++中却是流插入的意思。
int i=5;
cout<<i; <<流插入运算符，这个运算符支持内置类型（int,double,char......)，是因为他在库中就已经实现了,而cout能用<<,是因为cout的类中也已经实现了使用流插入的功能。
cin和cout在库中对应的类是：istream,ostream，都已经支持自定义类型。
自定义类型要用运算符，就必须要重载，内置类型天生就可以用运算符。
void operator<<(ostream& out) { out << _year << " " << _month << " " << _day << endl; }
若写在类中，那么参数就只能这么写，因为第一个参数为隐藏this指针，第二个是ostream类。
对于双操作数的运算符，写的顺序就是参数的顺序，那么调用时，我们只能这么写：
d1<<cout;但是这样总是很怪，流插入不应该流向cout吗？那么我们放在类外依旧在.h中，写成全局函数试试：
void operator<<(const ostream& out, const Date& d) { out << _year << " " << _month << " " << _day << endl; }
问题一：
这样的话，在.cpp和其他包含.h头文件的文件里，在编译预处理时，.cpp->.o /.obj 就会在各个文件中，都有<<流插入运算符重载的定义，那么在其他文件中就会产生符号表，符号表中有重名的就会报错。
解决办法：
1.static修饰函数，会改变链接属性（是在当前文件可见），在其他文件不会产生符号表。那么不产生符号表，直接就会使用定义，不会发生冲突。
2.声明和定义分离 .h中声明，.cpp中定义，就不会发生符号表重复。
3.加inline内联，加了内联，就不会产生符号表，也是直接展开，定义到了每个有.h的文件，直接使用定义，不会链接。void operator<<(const ostream& out, const Date& d);
问题二：
既然出了类，类中的私有成员变量就不能通过对象去使用。
解决办法:
1.偷家，私有成员变量不可以用，但我可以通过公有的成员函数去使用。
2.友元：友元声明（在类和对象下我们会详细说明），在类中的声明前加一个friend.
friend void operator<<(const ostream& out, const Date& d);
那么有时候我们也会遇到这样的情况：cout<<d1<<d2;
链式访问，这就和之前的赋值重载很一样了，需要返回值，不同的是，<<的链式访问是从左到右的。而且返回值当然得是cout了
ostream& operator<<(const ostream& out, const Date& d); 你懂了吗？？
流插入是一样的！
8.const修饰的成员函数
1.const修饰的权限问题
将const修饰的“成员函数”称之为const成员函数。
而在调用的时候会经常出现 权限放大的问题。权限可以缩小，平移，但不可以放大
1.举例说明：
为什么就会报错呢？？
当d2去调用的时候&d2（即const Date*)，这里const修饰的是指针所指的对象不可以被修改，只读。但是传参的时候就成了Print(Date*const this)，可读可写（不明白可以回顾以前文章）。所以扩大了权限，无法调用。
解决方法就是在函数定义后面加一个const
就相当于 const Date*const，权限此时就相同了。
而加了const以后，d1调用时&d1，Date*,可读可写，但是Print形参中是只读，虽然权限缩小，但是可以！
2.举例说明：
日期类相减：
int Date:: operator-(const Date& d)
{
Date max = *this;
Date min = d;
int flag = 1;
//if (*this < d)
换为
if(d>*this) 可以吗？？ 当然不可以，d.operator>(*this);
{ &d ->(const Date*)d此时是只读，结果到了>运算符的参数就是
Date*const可读可写，权限放大。
max = d;
min = *this;
flag = -1;
}
int count = 0;
while (max != min)
{
max--;
count++;
}
return count * flag;;
}
所以最好的方式是：凡是内部不改变成员变量，其实也就是不改变*this对象的数据的，这些成员函数都应该加const。
2.取地址重载
六大类默认成员函数就是：自己不写，编译器会给出。
当然，取地址重载也不例外，所以在大多数的时候，我们使用取地址都不需要自己写，除非一种情况！！
就是我不想让他取出地址：
Date* operator&() { return nullptr; //return this; } //第二种返回值加const是因为，返回参数是this时，为了返回时不扩大权限 const Date* operator&() const { return nullptr; //return this; }
总结
看到这里，类和对象中篇就结束了，是不是收获满满，当然也需要反复琢磨，让我们一起期待类和对象下。跨过难关，旗开得胜！！
