运算符重载

std::string str = "Hello, ";
str.operator+=("world");                       // 同 str += "world";
operator<<(operator<<(std::cout, str) , '\n'); // 同 std::cout << str << '\n';
                                               // (C++17 起) 但定序不同

// 假设对象保有可重用存储，例如一个分配于堆的缓冲区 mArray
T& operator=(const T& other) // 复制赋值
{
    if (this != &other) { // 期待检查自赋值
        if (other.size != size) {         // 存储不可复用
            delete[] mArray;              // 销毁 this 中的存储
            size = 0;
            mArray = nullptr;             // 在下一行抛出的情况下维持不变式
            mArray = new int[other.size]; // 分配 this 中的存储
            size = other.size;
        } 
        std::copy(other.mArray, other.mArray + other.size, mArray);
    }
    return *this;
}

T& operator=(T&& other) noexcept // 移动赋值
{
    if(this != &other) { // 自赋值时无操作（delete[]/size=0 亦 OK）
        delete[] mArray;                               // 删除此存储
        mArray = std::exchange(other.mArray, nullptr); // 令被移动对象遗留于合法状态
        size = std::exchange(other.size, 0);
    }
    return *this;
}

T& T::operator=(T arg) noexcept // 调用复制/移动构造函数以构造 arg
{
    std::swap(size, arg.size); // 在 *this 与 arg 间交换资源
    std::swap(mArray, arg.mArray);
    return *this;
} // 调用 arg 的析构函数以释放先前 *this 所保有的资源

std::ostream& operator<<(std::ostream& os, const T& obj)
{
    // 向流写入 obj
    return os;
}
std::istream& operator>>(std::istream& is, T& obj)
{
    // 从流读取 obj
    if( /* 不能构造 T */ )
        is.setstate(std::ios::failbit);
    return is;
}

// 此类型的对象表示一个变量的线性函数 a*x + b 。
struct Linear {
    double a, b;
 
    double operator()(double x) const {
        return a*x + b;
    }
};
int main() {
    Linear f{2, 1}; // 表示函数 2x + 1 。
    Linear g{-1, 0}; // 表示函数 -x 。
    // f 与 g 为能像函数一样使用的对象。
 
    double f_0 = f(0);
    double f_1 = f(1);
 
    double g_0 = g(0);
}

double a, b; // 坏：全局变量。
double linear(double x) {
    return a*x + b;
}
int main() {
    a = 2; b = 1;
    double f_0 = linear(0);
    double f_1 = linear(1);
 
    // 坏：需要重新赋值参数使得能够计算不同的函数：
    a = -1; b = 0;
    double g_0 = linear(0);
}

double linear(double a, double b, double x) {
    return a*x + b;
}
int main() {
    double f_0 = linear(2, 1, 0);
    // 坏：必须重复输入同一参数：
    double f_1 = linear(2, 1, 1);
 
    double g_0 = linear(-1, 0, 0);
}

struct Sum
{
    int sum;
    Sum() : sum(0) { }
    void operator()(int n) { sum += n; }
};
Sum s = std::for_each(v.begin(), v.end(), Sum());

struct X
{
    X& operator++()
    {
        // actual increment takes place here
        return *this;
    }
    X operator++(int)
    {
        X tmp(*this); // copy
        operator++(); // pre-increment
        return tmp;   // return old value
    }
};

class X
{
 public:
  X& operator+=(const X& rhs) // 复合赋值（不必，但通常是成员函数，以修改私有成员）
  {
    /* 将 rhs 加到 *this 发生于此 */
    return *this; // 按引用返回结果
  }
 
  // 定义于类体内的友元是 inline 的，且在非 ADL 查找中被隐藏
  friend X operator+(X lhs,        // 按值传递 lhs 有助于优化链状的 a+b+c
                     const X& rhs) // 否则，两个形参都是 const 引用
  {
    lhs += rhs; // 复用复合赋值
    return lhs; // 按值返回结果（使用移动构造函数）
  }
};

struct Record
{
    std::string name;
    unsigned int floor;
    double weight;
    friend bool operator<(const Record& l, const Record& r)
    {
        return std::tie(l.name, l.floor, l.weight)
             < std::tie(r.name, r.floor, r.weight); // 保持相同顺序
    }
};

inline bool operator< (const X& lhs, const X& rhs){ /* 做实际比较 */ }
inline bool operator> (const X& lhs, const X& rhs){ return rhs < lhs; }
inline bool operator<=(const X& lhs, const X& rhs){ return !(lhs > rhs); }
inline bool operator>=(const X& lhs, const X& rhs){ return !(lhs < rhs); }

inline bool operator==(const X& lhs, const X& rhs){ /* 做实际比较 */ }
inline bool operator!=(const X& lhs, const X& rhs){ return !(lhs == rhs); }

inline bool operator==(const X& lhs, const X& rhs){ return cmp(lhs,rhs) == 0; }
inline bool operator!=(const X& lhs, const X& rhs){ return cmp(lhs,rhs) != 0; }
inline bool operator< (const X& lhs, const X& rhs){ return cmp(lhs,rhs) <  0; }
inline bool operator> (const X& lhs, const X& rhs){ return cmp(lhs,rhs) >  0; }
inline bool operator<=(const X& lhs, const X& rhs){ return cmp(lhs,rhs) <= 0; }
inline bool operator>=(const X& lhs, const X& rhs){ return cmp(lhs,rhs) >= 0; }

struct T
{
          value_t& operator[](std::size_t idx)       { return mVector[idx]; }
    const value_t& operator[](std::size_t idx) const { return mVector[idx]; }
};