11、operator<=

<= 与 > 是相反的逻辑，因此我们对 > 取反就可以实现。

// <=运算符重载
bool Date::operator<=(const Date& d) const
{
  return !(*this > d);
}

12、operator!=

!= 与 == 是相反的逻辑，因此我们对 == 取反就可以实现。

// !=运算符重载
bool Date::operator!=(const Date& d) const
{
  return !(*this == d);
}

13、operator+= （日期+=天数）

+=是在原基础上进行修改，因此隐含的this不能用const修饰，因为在原基础上修改，所以出了+=函数体，对象还在，我们使用引用返回，这样可以减少拷贝。

我们画图对 += 天数分析：

代码实现：

// 日期+=天数
Date& Date::operator+=(int day)
{
  if (day < 0)
  {
    return *this -= (-day);
  }
  _day += day;
  while (_day > GetMonthDay(_year, _month))
  {
    _day -= GetMonthDay(_year, _month);
    //月进位
    _month++;
    //月满了
    if (13 == _month)
    {
      _year++;
      _month = 1;
    }
  }
  return *this;
}

我们来测试一下：

对照看看我们写的+=是否正确

14、operator+ （日期+天数）

+与+= 的区别在于+=是对对象本身+，而+不是对对象本身的改变。所以我们需要实例化一个新的对象，将传来的对象拷贝给新的对象，存放+天数的结果并返回。

// 日期+天数
Date Date::operator+(int day) const
{
  Date tmp(*this);
  tmp += day;
  return tmp;
}

这里我们拷贝了一份之后，就能复用+=的代码。

我们这里看看传的对象与+后的对象的结果：

这里我们可以看到+并没有影响到d1的结果。

15、operator-= （日期-=天数）

-=是在原基础上进行修改，因此隐含的this不能用const修饰，因为在原基础上修改，所以出了-=函数体，对象还在，我们使用引用返回，这样可以减少拷贝。

我们画图对-=天数进行分析：

代码实现：

// 日期-=天数
Date& Date::operator-=(int day)
{
  if (day < 0)
  {
    return *this += (-day);
  }
  _day -= day;
  while (_day <= 0)
  {
    _month--;
    if (0 == _month)
    {
      _year--;
      _month = 12;
    }
    _day += GetMonthDay(_year, _month);
  }
  return *this;
}

运行结果：

对比一下，看我们实现的是否正确：

16、operator- （日期-天数）

-与+ 的逻辑是类似的，-与-= 的区别在于-=是对对象本身-，而-不是对对象本身的改变。所以我们需要实例化一个新的对象，将传来的对象拷贝给新的对象，存放-天数的结果并返回。

// 日期-天数
Date Date::operator-(int day) const
{
  Date tmp(*this);
  tmp -= day;
  return tmp;
}

这里拷贝一份this之后，就可以在拷贝的tmp上复用-=。

我们来测试一下：

17、前置++，后置++，前置--，后置--

对于前置++与后置++，前置--与后置--，它们的函数名是相同的，但是实现的功能是不同的，如果在符号表里找这怎么能分得清楚呢?

对于这样的问题，C++有自己确定的规定，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。后置--也是如此。

这样就能实现函数重载，符号表中函数名虽然相同，但是一个有参数一个没参数。

下面我们对这几个函数接口分别实现：

前置++的规则是：先++，再使用。因此前置++就相当于+=1，复用+=。

// 前置++
Date& Date::operator++() //++d1 -> d1.operator()
{
  *this += 1;
  return *this;
}

后置++的规则是：先使用，再++。这里我们先将this拷贝一份，然后对this+=1，返回拷贝的对象，这样就做到了先使用，再++。

// 后置++
Date Date::operator++(int) //d1++ -> d1.operator(0)
{
  Date tmp(*this);
  *this += 1;
  return tmp;
}

前置--的规则是：先--，再使用。因此前置++就相当于-=1，复用-=。

// 前置--
Date& Date::operator--()
{
  *this -= 1;
  return *this;
}

后置--的规则是：先使用，再--。这里我们先将this拷贝一份，然后对this-=1，返回拷贝的对象，这样就做到了先使用，再--。

// 后置--
Date Date::operator--(int)
{
  Date tmp(*this);
  *this -= 1;
  return tmp;
}

18、日期 - 日期（返回天数）

此接口是 日期-日期，这里有一个存在一个小细节，当 小日期-大日期 的时候，返回值就是负数，因此我们对这个细节要注意一点，我们来对这个接口的思路梳理一遍：

1、我们用假设法，假设this是大日期，将其赋值给max对象，第二个参数是小日期，将其赋值给min对象，并定义一个flag初始化为 1；

2、比较一下，如果this是小日期那么将max、min两个对象的内容重新赋值，并将flag赋值为 -1；

3、定义一个计数器 n，让小追大，++min一次，计数器也++，追上后就跳出循环，返回 n*flag 即可。

注意：我们让小追大的时候使用前置++，虽然前置++与后置++都可以实现，但是后置++的接口中需要拷贝两次，开始拷贝一次，返回值会再拷贝一次，前置++在大量计算的时候可以实现时间与空间双重优势。

我们来实现代码：

// 日期-日期 返回天数
int Date::operator-(const Date& d) const
{
  int flag = 1;
  Date max = *this;
  Date min = d;
  if (max < min)
  {
    max = d;
    min = *this;
    flag = -1;
  }
  int n = 0;
  while (min != max)
  {
    ++n;
    ++min;
  }
  return n * flag;
}

测试：

19、const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

这里我们使用 Print 接口来讲：

使用const修饰后，与原本的成员函数是不冲突的，因为是构成重载的。

我们来看看两种版本的 Print 接口：

void Date::Print()
{
  cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
void Date::Print() const
{
  cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

对于打印函数来讲，函数内部是不涉及修改成员的，这种就是只读函数。

因此我们使用了const修饰，还存在一种问题，当我们的对象是const修饰，如果Print函数不用const修饰，在调用的时候就存在权限放大问题。

我们先将const修饰的Print函数频闭掉：


我们再将const修饰的接口放开看看：

总结：相同函数，const修饰的this与不修饰的函数构成重载；

函数内部是不涉及修改成员的就是只读函数，const修饰后更安全，并且对于具有常属性的对象也可以兼容。