C++ 运算符重载 - 夜羽的小作坊

你有没有想过，1 + 2 和 vec1 + vec2 在 C++ 里到底有什么区别？

答案是：几乎没有区别。+ 在 C++ 里本质上就是一个函数。对于 int，编译器知道怎么处理；对于你自己定义的类型，你可以亲手告诉编译器该怎么做——这就是运算符重载。

运算符的本质：它就是函数#

这是最重要的一句话，记住它，后面所有内容都会豁然开朗：

运算符只是语法糖。a + b 就是 operator+(a, b)。

编译器看到 a + b，会去找一个叫 operator+ 的函数。如果 a 是 int，编译器内置了这个实现；如果 a 是你自己的类，你需要自己定义它。

你在 Python 里见过 __add__、__eq__ 这些魔法方法吗？C++ 的运算符重载和它们是完全相同的思想——只是语法不同。

1
// 这两行完全等价
2
vec1 + vec2;
3
operator+(vec1, vec2);  // 或者 vec1.operator+(vec2)

贯通全文的例子：Vector2#

我们用一个二维向量类来演示所有常用的运算符重载。先搭好骨架：

1
#include <iostream>
2

3
struct Vector2 {
4
    float x, y;
5

6
    Vector2(float x, float y) : x(x), y(y) {}
7
};

就这么简单。接下来我们一个一个把运算符装上去。

成员函数 vs 非成员函数#

重载运算符有两种写法，选哪个取决于左操作数是谁。

成员函数：左操作数是 `this`#

1
struct Vector2 {
2
    float x, y;
3
    Vector2(float x, float y) : x(x), y(y) {}
4

5
    // 成员函数写法：this 就是左操作数
6
    Vector2 operator+(const Vector2& other) const {
7
        return Vector2(x + other.x, y + other.y);
8
    }
9
};

vec1 + vec2 会被翻译成 vec1.operator+(vec2)。vec1 是 this，vec2 是参数。

非成员函数：两个操作数都是参数#

1
// 在类外面定义
2
Vector2 operator+(const Vector2& a, const Vector2& b) {
3
    return Vector2(a.x + b.x, a.y + b.y);
4
}

什么时候必须用非成员函数？ 当左操作数不是你的类的时候。

最典型的例子是 std::cout << v——左边是 std::ostream，那是标准库的类，你改不了它。所以你只能写成非成员函数：

1
std::ostream& operator<<(std::ostream& os, const Vector2& v) {
2
    os << "(" << v.x << ", " << v.y << ")";
3
    return os;
4
}

如果这个函数需要访问类的私有成员，就把它声明为友元（friend）：

1
struct Vector2 {
2
private:
3
    float x, y;
4
public:
5
    // ...
6
    friend std::ostream& operator<<(std::ostream& os, const Vector2& v);
7
};

常用运算符重载详解#

算术运算符：`+`、`-`、`*`#

向量加法、减法、标量乘法——最直观的用法：

1
Vector2 operator+(const Vector2& other) const {
2
    return { x + other.x, y + other.y };
3
}
4

5
Vector2 operator-(const Vector2& other) const {
6
    return { x - other.x, y - other.y };
7
}
8

9
// 标量乘法：vec * 2.0f
10
Vector2 operator*(float scalar) const {
11
    return { x * scalar, y * scalar };
12
}

注意这里 operator* 只支持 vec * 2.0f，不支持 2.0f * vec（因为左操作数 float 不是我们的类）。如果需要两边都支持，还要加一个非成员版本：

1
// 支持 2.0f * vec
2
Vector2 operator*(float scalar, const Vector2& v) {
3
    return v * scalar;  // 复用已有的成员函数
4
}

比较运算符：`==`、`!=`#

1
bool operator==(const Vector2& other) const {
2
    return x == other.x && y == other.y;
3
}
4

5
bool operator!=(const Vector2& other) const {
6
    return !(*this == other);  // 复用 ==，保持逻辑一致
7
}

operator!= 直接用 !(*this == other) 实现——不要复制粘贴相同逻辑，复用它。

输出流：`operator<<`#

必须是非成员函数，而且必须返回 ostream&。

为什么要返回引用？因为链式调用：

1
cout << a << b << c;
2
// 等价于
3
((cout << a) << b) << c;

每次 << 必须返回同一个 cout（的引用），下一次 << 才有地方调用。如果返回 void 或者返回值，链式调用就断了。

1
std::ostream& operator<<(std::ostream& os, const Vector2& v) {
2
    os << "(" << v.x << ", " << v.y << ")";
3
    return os;  // 必须返回 os 的引用
4
}

下标运算符：`operator[]`#

如果你想用 v[0] 访问 x，v[1] 访问 y：

1
float& operator[](int index) {
2
    return index == 0 ? x : y;
3
}
4

5
// const 版本：用于 const 对象
6
const float& operator[](int index) const {
7
    return index == 0 ? x : y;
8
}

返回引用是关键——这样 v[0] = 3.0f 也能正常工作（可以赋值）。

函数调用运算符：`operator()`#

重载 () 让对象可以像函数一样被调用，这样的对象叫仿函数（functor）：

1
struct Adder {
2
    float value;
3
    Adder(float v) : value(v) {}
4

5
    float operator()(float x) const {
6
        return x + value;
7
    }
8
};
9

10
Adder add5(5.0f);
11
std::cout << add5(3.0f);  // 输出 8

std::sort 的自定义比较器、std::function 背后都是这个机制。

完整的 Vector2 类#

把所有内容整合到一起，这是一个完整可运行的版本：

1
#include <iostream>
2

3
struct Vector2 {
4
    float x, y;
5

6
    Vector2(float x = 0, float y = 0) : x(x), y(y) {}
7

8
    // 算术运算
9
    Vector2 operator+(const Vector2& other) const {
10
        return { x + other.x, y + other.y };
11
    }
12

13
    Vector2 operator-(const Vector2& other) const {
14
        return { x - other.x, y - other.y };
15
    }
16

17
    Vector2 operator*(float scalar) const {
18
        return { x * scalar, y * scalar };
19
    }
20

21
    // 复合赋值
22
    Vector2& operator+=(const Vector2& other) {
23
        x += other.x;
24
        y += other.y;
25
        return *this;
26
    }
27

28
    // 比较
29
    bool operator==(const Vector2& other) const {
30
        return x == other.x && y == other.y;
31
    }
32

33
    bool operator!=(const Vector2& other) const {
34
        return !(*this == other);
35
    }
36

37
    // 下标访问
38
    float& operator[](int index) {
39
        return index == 0 ? x : y;
40
    }
41

42
    const float& operator[](int index) const {
43
        return index == 0 ? x : y;
44
    }
45

46
    // 输出流（非成员友元）
47
    friend std::ostream& operator<<(std::ostream& os, const Vector2& v);
48
};
49

50
// 非成员：输出流
51
std::ostream& operator<<(std::ostream& os, const Vector2& v) {
52
    return os << "(" << v.x << ", " << v.y << ")";
53
}
54

55
// 非成员：标量在左边的乘法
56
Vector2 operator*(float scalar, const Vector2& v) {
57
    return v * scalar;
58
}
59

60
int main() {
61
    Vector2 a(1.0f, 2.0f);
62
    Vector2 b(3.0f, 4.0f);
63

64
    std::cout << "a = " << a << "\n";         // (1, 2)
65
    std::cout << "b = " << b << "\n";         // (3, 4)
66
    std::cout << "a + b = " << a + b << "\n"; // (4, 6)
67
    std::cout << "a - b = " << a - b << "\n"; // (-2, -2)
68
    std::cout << "a * 2 = " << a * 2 << "\n"; // (2, 4)
69
    std::cout << "3 * b = " << 3 * b << "\n"; // (9, 12)
70

71
    std::cout << "a == b: " << (a == b) << "\n"; // 0
72
    std::cout << "a != b: " << (a != b) << "\n"; // 1
73

74
    std::cout << "a[0] = " << a[0] << "\n"; // 1
75
    std::cout << "a[1] = " << a[1] << "\n"; // 2
76

77
    // 链式输出
78
    std::cout << "chained: " << a << " and " << b << "\n";
79

80
    return 0;
81
}

输出结果：

1
a = (1, 2)
2
b = (3, 4)
3
a + b = (4, 6)
4
a - b = (-2, -2)
5
a * 2 = (2, 4)
6
3 * b = (9, 12)
7
a == b: 0
8
a != b: 1
9
a[0] = 1
10
a[1] = 2
11
chained: (1, 2) and (3, 4)

C++20 飞船运算符 `<=>`#

在 C++20 之前，如果你想支持所有六个比较运算符（<、>、<=、>=、==、!=），你得写六个函数——很烦。

C++20 引入了三路比较运算符（三路比较，又叫飞船运算符，因为 <=> 长得像飞船）：

1
#include <compare>
2

3
struct Vector2 {
4
    float x, y;
5

6
    // 一个 <=> 搞定所有比较
7
    auto operator<=>(const Vector2& other) const = default;
8
    bool operator==(const Vector2& other) const = default;
9
};

= default 让编译器自动生成按成员逐一比较的实现。有了 <=> 之后，<、>、<=、>= 都会自动派生出来，== 和 != 也会。

如果你需要自定义比较逻辑（比如按向量长度比较），也可以手写：

1
auto operator<=>(const Vector2& other) const {
2
    float len1 = x * x + y * y;
3
    float len2 = other.x * other.x + other.y * other.y;
4
    return len1 <=> len2;
5
}

返回类型 auto 会推导为 std::partial_ordering（浮点数）或 std::strong_ordering（整数）。

什么时候不应该重载#

运算符重载是把双刃剑。用得好，代码像诗；用得烂，代码像谜。

不要重载这些运算符：

operator,（逗号运算符）：几乎没有人知道它的语义，重载后会让人困惑
operator&& 和 operator||：内置版本有短路求值（左边为假就不算右边），重载后短路行为消失，会出 bug
语义不直观的场合：如果你需要注释来解释 a + b 是什么意思，就不要重载 +

好的运算符重载应该满足最小惊讶原则：看到 a + b，用户应该能猜到它在做什么，而且猜对了。

小结#

运算符	建议写法	关键点
`+`、`-`、`*`	成员函数	返回新对象，标记 `const`
`+=`、`-=`	成员函数	返回 `*this` 的引用
`==`、`!=`	成员函数	`!=` 复用 `==`
`<<`	非成员友元	返回 `ostream&`，支持链式
`[]`	成员函数	返回引用，提供 `const` 版本
`()`	成员函数	仿函数，配合 STL 算法使用
`<=>`	成员函数	C++20，一次定义所有比较

运算符重载的核心思想很简单：它只是函数，只是名字比较特殊。搞清楚左操作数是谁、是否需要返回引用、是否需要链式调用，其他的都是细节。

下一篇我们聊模板（Templates）——让一个函数或类同时支持 int、float、Vector2 各种类型，真正实现”写一次，到处用”。

运算符的本质：它就是函数#

贯通全文的例子：Vector2#

成员函数 vs 非成员函数#

成员函数：左操作数是 this#

非成员函数：两个操作数都是参数#

常用运算符重载详解#

算术运算符：+、-、*#

比较运算符：==、!=#

输出流：operator<<#

下标运算符：operator[]#

函数调用运算符：operator()#