运算符重载

正常实现

class Time {
public:
  Time(int h, int m, int s) : h(h), m(m), s(s){}
  Time operator+(const Time& rhs) const {
    int h = this->h + rhs.h;
    int m = this->m + rhs.m;
    int s = this->s + rhs.s;
    if (s > 60) {
      m += s / 60;
      s %= 60;
    }
    if (m > 60) {
      h += m / 60;
      m %= 60;
    }
    return Time(h, m, s);
  }
  Time &operator+=(const Time& rhs) {
    *this = *this + rhs;
    return *this;
  }
  int h, m, s;
};

+= 重载函数使用了一次构造函数，如果使用下面方法去实现可以省去一次构造，直接在 this 的成员上进行构造。

  Time &operator+=(const Time& rhs) {
    h += rhs.h;
    m += rhs.m;
    s += rhs.s;
    if (s > 60) {
      m += s / 60;
      s %= 60;
    }
    if (m > 60) {
      h += m / 60;
      m %= 60;
    }
    return *this;
  }
  Time operator+(const Time& rhs) const {
    Time t(*this);
    t += rhs;
    return t;
  }

+重载不应该修改 this ，由于+法重载无论如何都会进行一次构造，所以我们通常手动实现+=重载（在this上构造，+=需要改变this），再由+=实现+重载（需要新的对象）。

  Time operator+(const Time& lhs, const Time& rhs) {} // 也可以抽出来当作自由函数

自增操作符重载

  Time operator++(int) {
    Time t(*this);
    ++(*this);
    return t;
  }
  Time& operator++() {
    ++s;
    if (s > 60) {
      ++m;
      s %= 60;
    }
    if (m > 60) {
      ++h;
      m %= 60;
    }
    return *this;
  }

分别对应 a++，++a，int 主要是为了区分两种自增，由于 a++ 返回的是增加之前的，所以需要额外构造出一个对象。

注意为什么 a++ 的返回类型是 Time 是因为 t 是局部变量，无法取引用 Reference to stack memory associated with local variable ‘t’ returned 。由于 *this 是在上层作用域存储的，所以可以返回 Time& 类型。

  friend std::ostream &operator<<(std::ostream& os, const Time& t) {
    os << t.h << ":" << t.m << ":" << t.s;
    return os;
  }

二元操作符

经常会有Overloaded 'operator<<' must be a binary operator (has 3 parameters) 报错，如果你重载了二元操作符，如果在类内部使用了下面写法，则提示上面报错。是因为类内部隐藏传递了 this 参数，所以有三个参数。将下面的重载写在类外部即可。

  std::ostream &operator<<(std::ostream& os, const Time& t) {
    os << t.h << ":" << t.m << ":" << t.s;
    return os;
  }