第一节 · 机械臂的自我修养 · 初识重载运算符

C++ 允许我们为自定义类型定义运算符的行为，让自定义类型像内置类型一样使用。这就是运算符重载。

---

为什么需要运算符重载

// 没有重载，复数加法很麻烦
struct Complex
{
    double real, imag;
};

Complex add(Complex a, Complex b)
{
    return {a.real + b.real, a.imag + b.imag};
}

Complex c1 = {1, 2}, c2 = {3, 4};
Complex c3 = add(c1, c2);  // 不直观

// 有了重载，可以写成
// Complex c3 = c1 + c2;  // 更自然

---

基本语法

class Complex
{
public:
    double real, imag;
    
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    
    // 成员函数形式
    Complex operator+(const Complex& other) const
    {
        return Complex(real + other.real, imag + other.imag);
    }
};

int main()
{
    Complex c1(1, 2), c2(3, 4);
    Complex c3 = c1 + c2;  // 调用 c1.operator+(c2)
    
    cout << c3.real << " + " << c3.imag << "i" << endl;
    // 4 + 6i
    
    return 0;
}

---

可重载的运算符

类型	运算符
算术	+ - * / %
比较	== != < > <= >=
赋值	= += -= *= /=
位运算	& `
逻辑	! && `
其他	[] () -> * ++ --

不能重载的运算符：. :: ?: sizeof

---

成员函数 vs 友元函数

class Complex
{
public:
    double real, imag;
    
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    
    // 成员函数：左操作数必须是 Complex
    Complex operator+(const Complex& other) const
    {
        return Complex(real + other.real, imag + other.imag);
    }
    
    // 友元函数：支持 double + Complex
    friend Complex operator+(double d, const Complex& c)
    {
        return Complex(d + c.real, c.imag);
    }
};

int main()
{
    Complex c(1, 2);
    
    Complex c1 = c + 5;   // OK: c.operator+(Complex(5))
    Complex c2 = 5 + c;   // OK: operator+(5, c)
    
    return 0;
}

---

算术运算符

class Vector2D
{
public:
    double x, y;
    
    Vector2D(double x = 0, double y = 0) : x(x), y(y) {}
    
    // 加法
    Vector2D operator+(const Vector2D& v) const
    {
        return Vector2D(x + v.x, y + v.y);
    }
    
    // 减法
    Vector2D operator-(const Vector2D& v) const
    {
        return Vector2D(x - v.x, y - v.y);
    }
    
    // 标量乘法
    Vector2D operator*(double s) const
    {
        return Vector2D(x * s, y * s);
    }
    
    // 取负
    Vector2D operator-() const
    {
        return Vector2D(-x, -y);
    }
};

// 支持 scalar * vector
Vector2D operator*(double s, const Vector2D& v)
{
    return v * s;
}

---

复合赋值运算符

class Vector2D
{
public:
    double x, y;
    
    // 复合赋值返回引用
    Vector2D& operator+=(const Vector2D& v)
    {
        x += v.x;
        y += v.y;
        return *this;
    }
    
    Vector2D& operator*=(double s)
    {
        x *= s;
        y *= s;
        return *this;
    }
};

int main()
{
    Vector2D v1(1, 2), v2(3, 4);
    v1 += v2;  // v1 变为 (4, 6)
    v1 *= 2;   // v1 变为 (8, 12)
    
    return 0;
}

---

比较运算符

class Date
{
public:
    int year, month, day;
    
    bool operator==(const Date& other) const
    {
        return year == other.year &&
               month == other.month &&
               day == other.day;
    }
    
    bool operator!=(const Date& other) const
    {
        return !(*this == other);
    }
    
    bool operator<(const Date& other) const
    {
        if (year != other.year) return year < other.year;
        if (month != other.month) return month < other.month;
        return day < other.day;
    }
    
    // C++20 的三路比较运算符
    // auto operator<=>(const Date& other) const = default;
};

---

输入输出运算符

class Point
{
public:
    int x, y;
    
    // 必须是友元或非成员函数
    friend ostream& operator<<(ostream& os, const Point& p)
    {
        os << "(" << p.x << ", " << p.y << ")";
        return os;
    }
    
    friend istream& operator>>(istream& is, Point& p)
    {
        is >> p.x >> p.y;
        return is;
    }
};

int main()
{
    Point p = {3, 4};
    cout << p << endl;  // (3, 4)
    
    cout << "Enter x y: ";
    cin >> p;
    cout << p << endl;
    
    return 0;
}

---

运算符重载的原则

1. 保持直观性：重载的行为应符合预期

2. 保持一致性：实现 + 也应实现 +=

3. 返回合理类型：算术返回新对象，赋值返回引用

4. 不要滥用：不要给运算符赋予不相关的含义

---

习题

• 为 Complex 类实现完整的算术运算符。

• 实现一个 Fraction 分数类，支持四则运算。

• 解释为什么 << 和 >> 要返回流引用。