运算符重载

使用operator关键字引入重载函数

struct Str {
  int val = 3;

  auto operator () (int y = 3) {  // 只有operator () 可以有缺省参数
    return val + x;
  }

  auto operator + (const Str& x) {
    Str res;
    res.val = val + x.val;
    return res;
  }
};

Str Add(const Str& x, const Str& y) {
  Str z;
  z.val = x.val + y.val;
  return z;
}

// auto自动推断返回值需要在C++11后面的版本才可以编译通过
auto operator + (const Str& x, const Str& y) {
  Str res;
  res.val = x.val + y.val;
  return res;
}

int main() {
  Str x;
  Str y;

  auto z = x + y;
  z = Add(x, y);

  z = x(4);  // z.val = 3 + 4
  z = x();  // z.val = 3 + 3
}

重载不能发明新的运算(比如不能创造一个@运算符)，不能改变运算的优先级与结合性，通常不改变运算含义。
函数参数个数与运算操作数个数相同，至少一个为类类型
除operator()外其他运算符不能有缺省参数
可以选择实现为成员函数与非成员函数
- 通常来说，实现为成员函数会以*this作为第一个操作数(注意==与<==>的重载可以不需要*this作为第一个操作数)

根据重载特性，可以将运算符进一步划分
- 可重载且必须实现为成员函数的运算符(=,[],(),->与转型运算符)
- 可重载且可以实现为非成员函数的运算符
- 可重载但不建议重载的运算符(&&,||,逗号运算符)
  - C++17中规定了相应的求值顺序但没有方式实现短路逻辑(短路逻辑即:A&&B,如果A为非，B不用执行)
- 不可重载的运算符(如 ?: 三元运算符)

相对来说比较特殊的运算符重载

对称运算符通常定义为非成员函数以支持首个操作数的类型转换

// 错误示范
struct Str {
  Str(int x) : val(x) {}
  auto operator + (const Str& input) {
    return Str(val + input.val);
  }
  int val;
};

int main() {
  Str x(3);
  Str y = x + 4;  // 通过，4会隐式转换为Str(4)
  Str z = 4 + x;  // 不通过，最好不要将称运算符定义为成员函数
}

// 正确示范
struct Str {
  Str(int x) : val(x) {}

  Str& operator= (const std::string& input) {
    val = static_cast<int>(input.size());
    return *this;
  }

  // 定义为友元的原因是val是私有成员，而operator +是一个类外的运算符重载函数
  friend auto operator + (const Str& input1, const Str& input2) {
    return Str(input1.val + input2.val);
  }

  // 注意这里要返回引用，因为输出流是不支持拷贝的
  friend auto& operator << (std::ostream& ostr, const Str& input) {
    ostr << input.val;
    return ostr;
  }

  int& operator[] (int id) {  // func1
    return val;
  }

  int operator[] (int id) const {  // func2
    return val;
  }

private:
  int val;
};

int main() {
  Str x = 3;
  x = "1234";
  Str y = 4 + x;  // 合法，我们在类外定了operator + (const Str&, const Str&)函数，4会被隐式转换为Str(4)
  std::cout << x << y;  // 合法

  std::cout << x[0];  // 合法
  x[0] = 1;  // 如果func1不是返回的引用，就不合法，因为右值一般不能出现在等号左边

  const Str cx = 3;
  std::cout << cx[0];  // 如果没有定义func2，就不合法，因为func1没用const修饰，可能对类本身进行修改
}

移位运算符一定要定义为非成员函数，因为其首个操作数类型需要是流类型(如上面代码所示)
赋值运算符也可以接受一般参数，比如上面代码中传入了一个string。
operator []通常返回引用，某些情况下不返回引用，比如上面的func2

自增、自减运算符的前缀、后缀重载法

Str& operator++ () {  //如果()里是空的，对应前缀自增x++
  ++val;
  return *this;
}
Str operator++ (int) {  // 如果()里有个int变量，对应后缀自增++x，注意这里的()里面的变量没有任何意义，不会参与任何计算或者赋值
  Str tmp(*this);
  ++val;
  return tmp;
}
// 从上面的代码可以看出，能用前缀自增就用前缀，更加高效

使用解引用运算符(*)与成员访问运算符(->)模拟指针行为

struct Str {
public:
  Str(int* p) : ptr(p) {}

  int& operator * () {
    return *ptr;
  }

  Str* operator -> () {
    return this;
  }

  int val = 5;

private:
  int* ptr;
};

int main() {
  int x = 100;
  Str ptr(&x);
  std::cout << *ptr << std::endl;
  std::cout << ptr->val << std::endl;
  // C++编译的时候遇到->就会去查看有没有operator->重载，如果有重载的话，就把它当作一个类成员函数去调用
  // 所以ptr->val会被翻译为：ptr.operator->()->val，其中ptr.operator->()的返回值就是一个Str*类型的指针
}

注意，".“运算符不能重载

“->“会递归调用”->“操作

struct Str2 {
  Str2* operator -> () {
    return this;
  }

  int val2 = 123;
};

struct Str {
  Str2 operator -> () {
    return Str2{};
  }

  int val = 5;
};

int main() {
  Str ptr = Str();
  std::cout << ptr->val2 << std::endl;
  // 由于Str的operator->()函数返回的是Str2，不是一个指针类型，所以编译期还会继续调用Str2的operator->()函数，直到返回一个指针为止
  // ptr.operator->().operator()->val2
}

使用函数调用运算符构造可调用对象(lambda表达式就是通过这个手段实现的)

struct Str {
  Str(int p) : val(p) {}

  bool operator () (int input) {
    return val++ < input;
  }

private:
  int val;
};

int main() {
  Str obj(100);
  std::cout << obj(99) << std::endl;  // 0
  std::cout << obj(102) << std::endl;  // 1
  std::cout << obj(102) << std::endl;  // 0, 因为val++
}

类型转换运算符

函数声明为operator type() const

struct Str {
  Str(int p) : val(p) {}

  operator int() const {
    return val;
  }

  friend auto operator + (Str a, Str b) {
    return Str(a.val + b.val);
  }

private:
  int val;
};

int main() {
  Str obj(100);
  static_cast<Str>(100);  // 通过
  static_cast<int>(obj);  // 通过
  int v = obj;  // 通过
  std::cout << v << std::endl;

  obj + 3;  // 不通过，编译器既可以选择把obj转为int再相加，也可以把3转换为Str类型再相加（上面实现了Str的+友元重载）
  // 解决方案就是在Str的构造函数或者型转换运算符重载函数前面加上explicit关键字
  // 如果在构造函数前加explicit，3就不能隐式转换为Str类型了
  // 注意，不能两个函数前同时加上explicit，如果都加了也编译不过，因为没有任何隐式转换发生的话，Str和int无法执行+。

  // 如果在两个函数前同时加上explicit，代码就要这么改
  obj + static_cast<Str>(3);
  static_cast<int>(obj) + 3;
}

与单参数构造函数一样，都引入了一种类型转换方式
注意避免引入歧义性与意料之外的行为
- 通过explicit引入显示类型转换(参考上面的代码)

explicit bool的特殊性：用于条件表达式时会进行隐式类型转换

struct Str {
  explicit Str(int p) : val(p) {}

  explicit operator bool() const {
    return val == 0;
  }

private:
  int val;
};

int main() {
  Str obj(100);    
  std::cout << obj << std::endl;  // 不通过，因为上面有explicit修饰，不能隐式转换了

  if (obj) {  // 通过，即使定义了explicit，但这里仍然会进行隐式类型转换
    std::cout << 1 << std::endl;
  } else {
    std::cout << 0 << std::endl;
  }

  auto var = obj ? 1 : 0;  // 通过
  std::cout << var << std::endl;
}

C++20中对==与<==>的重载

在C++20之前，如果我们想重载大小比较，我们需要实现6个重载，==, !=, >=, <=, >, <。
在C++20之后，只需要重载==, <==>这两个就可以完成对上面6个功能的定义
通过==定义!=

隐式交换操作数

#include <compare>
struct Str {
  Str(int p) : val(p) {}

  friend bool operator == (Str obj, int obj2) {
    return obj.val == obj2;
  }

  auto operator <==> (int x) {
    return val <==> x;
  }

private:
  int val;
};

int main() {
  Str obj(100);
  std::cout << (obj == 100) << std::endl;
  std::cout << (obj != 100) << std::endl;  // C++20之后通过
  std::cout << (100 == obj) << std::endl;  // C++20之后通过，C++20会先尝试找(int, Str)，如果找不到会继续找(Str, int)

  std::cout << (100 >= obj) << std::endl;
  std::cout << (obj >= 100) << std::endl;
}

通过<==>定义多种比较逻辑(参考上main的代码)
- 注意<==>可以返回的类型，strong_ordering, weak_ordering, partial_ordering

looyifan / Operator

运算符重载