因为在类中定义的成员函数，都在公共区，自动会在参数中带一个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;
  }

总结

看到这里，类和对象中篇就结束了，是不是收获满满，当然也需要反复琢磨，让我们一起期待类和对象下。跨过难关，旗开得胜！！