# ===== CodeLab: cpp-overload =====
# 以下代码片段按文章出现顺序拼接, 共 7 段

# ----- 片段 1 (cpp) -----
#include <iostream>

class Complex {
public:
    Complex(double r = 0, double i = 0) : re_(r), im_(i) {}

    // 成员函数形式:this 是左操作数,rhs 是右操作数
    Complex operator+(const Complex& rhs) const {
        return Complex(re_ + rhs.re_, im_ + rhs.im_);
    }

    void print() const {
        std::cout << re_ << " + " << im_ << "i\n";
    }

private:
    double re_, im_;
};

int main() {
    Complex a(1, 2), b(3, 4);
    Complex c = a + b;          // 等价于 a.operator+(b)
    c.print();                  // 输出:4 + 6i
    return 0;
}

# ----- 片段 2 (cpp) -----
#include <iostream>

class Complex {
    // 友元可以访问私有成员
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
    friend bool operator==(const Complex& a, const Complex& b);

public:
    Complex(double r = 0, double i = 0) : re_(r), im_(i) {}

    Complex operator+(const Complex& rhs) const {
        return Complex(re_ + rhs.re_, im_ + rhs.im_);
    }

private:
    double re_, im_;
};

std::ostream& operator<<(std::ostream& os, const Complex& c) {
    os << c.re_ << (c.im_ >= 0 ? "+" : "") << c.im_ << "i";
    return os;   // 返回 os 本身,支持 cout << a << b 连续输出
}

bool operator==(const Complex& a, const Complex& b) {
    return a.re_ == b.re_ && a.im_ == b.im_;
}

int main() {
    Complex a(1, 2), b(3, 4);
    std::cout << a + b << "\n";                     // 输出:4+6i
    std::cout << (a == Complex(1, 2)) << "\n";      // 输出:1
    return 0;
}

# ----- 片段 3 (cpp) -----
#include <iostream>
#include <vector>

class IntVec {
public:
    explicit IntVec(std::size_t n = 0) : data_(n, 0) {}

    int& operator[](std::size_t i) { return data_[i]; }
    const int& operator[](std::size_t i) const { return data_[i]; }

    IntVec& operator+=(int v) {
        for (auto& x : data_) x += v;
        return *this;
    }

    std::size_t size() const { return data_.size(); }

private:
    std::vector<int> data_;
};

int main() {
    IntVec v(3);
    v[0] = 10; v[1] = 20; v[2] = 30;   // 通过重载的 [] 写入
    v += 5;                             // 每个元素加 5
    for (std::size_t i = 0; i < v.size(); ++i)
        std::cout << v[i] << " ";       // 输出:15 20 35
    std::cout << "\n";
    return 0;
}

# ----- 片段 4 (cpp) -----
#include <iostream>

class Counter {
public:
    explicit Counter(int v = 0) : value_(v) {}

    // 前缀 ++:先自增,返回自增后的对象(引用)
    Counter& operator++() {
        ++value_;
        return *this;
    }
    // 后缀 ++:返回自增前的副本,形参 int 只是区分标记
    Counter operator++(int) {
        Counter old = *this;
        ++value_;
        return old;
    }
    int get() const { return value_; }

private:
    int value_;
};

int main() {
    Counter c(10);
    std::cout << (++c).get() << " ";   // 前缀:先加后取,11
    std::cout << (c++).get() << " ";   // 后缀:先取后加,还是 11
    std::cout << c.get() << "\n";      // 此时已是 12
    return 0;
}

# ----- 片段 5 (cpp) -----
#include <iostream>

class Accumulator {
public:
    explicit Accumulator(int start = 0) : sum_(start) {}
    int operator()(int x) {
        sum_ += x;
        return sum_;
    }
    int total() const { return sum_; }

private:
    int sum_;
};

int main() {
    Accumulator acc(100);
    std::cout << acc(1) << " ";    // 输出:101
    std::cout << acc(5) << " ";    // 输出:106
    std::cout << acc(20) << "\n";  // 输出:126
    return 0;
}

# ----- 片段 6 (cpp) -----
#include <iostream>

class Complex {
    friend std::ostream& operator<<(std::ostream&, const Complex&);

public:
    Complex(double r = 0, double i = 0) : re_(r), im_(i) {}

    Complex operator+(const Complex& rhs) const {
        return Complex(re_ + rhs.re_, im_ + rhs.im_);
    }
    Complex& operator+=(const Complex& rhs) {
        re_ += rhs.re_; im_ += rhs.im_;
        return *this;
    }
    bool operator==(const Complex& rhs) const {
        return re_ == rhs.re_ && im_ == rhs.im_;
    }
    bool operator!=(const Complex& rhs) const { return !(*this == rhs); }

private:
    double re_, im_;
};

std::ostream& operator<<(std::ostream& os, const Complex& c) {
    return os << c.re_ << " + " << c.im_ << "i";
}

int main() {
    Complex a(1, 2), b(3, 4);
    a += b;
    std::cout << a << "\n";                    // 4 + 6i
    std::cout << (a == Complex(4, 6)) << "\n"; // 1
    std::cout << (a != b) << "\n";             // 1
    return 0;
}

# ----- 片段 7 (cpp) -----
#include <iostream>

struct Flag {
    bool on;
    Flag operator&&(const Flag& rhs) const { return Flag{on && rhs.on}; }
};

Flag make_flag(bool v, const char* name) {
    std::cout << "求值 " << name << "\n";
    return Flag{v};
}

int main() {
    Flag a = make_flag(false, "a") && make_flag(true, "b");
    // 输出两行:说明 b 也被求值了,短路失效
    return 0;
}