第十章运算符重载：让自定义类型像内置类型一样工作#

一句话理解：运算符重载不是必须的技术，但当你希望自己的类型像 int、double 一样自然使用时，它是必不可少的工具。核心原则：不要改变运算符的直觉语义——+ 应该做加法而不是发网络请求。

10.1 概念直觉 —— What & Why#

为什么需要运算符重载？#

没有运算符重载的时代：

1
// 没有运算符重载的数学库 —— 丑陋
2
Vec3 a(1, 2, 3);
3
Vec3 b(4, 5, 6);
4
Vec3 c = a.add(b).sub(d).mul(2.0f);   // 链式调用，难以阅读
5
float d = c.dot(e);
6

7
// 有运算符重载 —— 自然
8
Vec3 a(1, 2, 3);
9
Vec3 b(4, 5, 6);
10
Vec3 c = (a + b - d) * 2.0f;           // 读起来像数学公式
11
float d = c | e;                        // 点积（如果 | 被重载为 dot）

运算符重载的两面性：

优点	风险
代码自然、可读性高	滥用导致语义混乱
泛型编程的基础（STL 靠 `operator<`、`==` 工作）	隐式转换 + 运算符重载 = 难以调试
与模板、移动语义深度配合	写错了编译器错误信息极其冗长

核心规则速览#

1
// 🟢 可以重载的 38 个运算符：
2
// 算术：   +  -  *  /  %  ^  &  |  ~  !  =
3
// 赋值：   += -= *= /= %= ^= &= |= <<= >>=
4
// 比较：   <  >  <= >= == != <=>
5
// 自增减： ++ --
6
// 位运算： << >> (也是流操作)
7
// 逻辑：   && ||
8
// 成员：   ->  ->*  []
9
// 其他：   ()  ,  new  delete  new[]  delete[]
10
// 转换：   operator T()
11

12
// 🔴 不能重载的 4 个：
13
// .   (成员访问)
14
// .*  (成员指针访问)
15
// ::  (作用域解析)
16
// ?:  (三元条件)
17

18
// 🟡 不能凭空发明的运算符：
19
// **  ^^  =>  等等都不行，只能用语言定义的 38 个

10.2 原理图解#

10.2.1 成员 vs 非成员 —— 选择决策#

flowchart TD Start["要重载运算符 @"] Start --> Q1{"@ 必须是成员？ (= [] () -> 类型转换)"} Q1 -->|"是"| Member["✅ 必须是成员函数"] Q1 -->|"否"| Q2{"@ 需要访问 private 成员 且不适合做 public 接口？"} Q2 -->|"是"| Friend["✅ friend 非成员函数"] Q2 -->|"否"| Q3{"@ 的第一个操作数 可能是非本类类型？"} Q3 -->|"是"| NonMember["✅ 非成员函数 （如 << 的左参数是 ostream）"] Q3 -->|"否"| Q4{"@ 的语义要求 两个参数平等对待？"} Q4 -->|"是"| NonMember Q4 -->|"否"| Member style Member fill:#2d6a4f,stroke:#40916c,color:white style NonMember fill:#2d6a4f,stroke:#40916c,color:white style Friend fill:#e85d04,stroke:#f48c06,color:white

10.2.2 a + b 的编译过程#

graph TD Call["a + b"] --> Try1{"a 的类型有 operator+(b) 成员？"} Try1 -->|"✅"| Resolved["调用 a.operator+(b)"] Try1 -->|"❌"| Try2{"存在非成员 operator+(a, b)？"} Try2 -->|"✅"| Resolved2["调用 operator+(a, b)"] Try2 -->|"❌"| Try3{"a 或 b 可隐式转换 到某个定义了 + 的类型？"} Try3 -->|"✅"| Converted["先转换, 再调用"] Try3 -->|"❌"| Error["编译错误"] style Error fill:#d00000,color:white style Resolved fill:#2d6a4f,color:white style Resolved2 fill:#2d6a4f,color:white

如果成员函数和非成员函数同时存在且都匹配 → 二义性错误。所以不要同时定义两个版本。

10.3 底层机制 —— 逐类击破#

10.3.1 算术运算符（+, -, *, /, %）#

黄金法则：用非成员函数，返回值（新对象），内部用 += 等复合赋值实现。

1
class Vec3 {
2
public:
3
    float x, y, z;
4

5
    Vec3(float x_ = 0, float y_ = 0, float z_ = 0)
6
        : x(x_), y(y_), z(z_) {}
7

8
    // 复合赋值 → 成员函数，返回引用
9
    Vec3& operator+=(const Vec3& rhs) noexcept {
10
        x += rhs.x;
11
        y += rhs.y;
12
        z += rhs.z;
13
        return *this;
14
    }
15

16
    Vec3& operator*=(float s) noexcept {
17
        x *= s;
18
        y *= s;
19
        z *= s;
20
        return *this;
21
    }
22
};
23

24
// 算术运算符 → 非成员，通过 += 实现
25
// 这样只需要维护复合赋值一处逻辑
26
inline Vec3 operator+(const Vec3& lhs, const Vec3& rhs) noexcept {
27
    Vec3 result(lhs);
28
    result += rhs;
29
    return result;
30
}
31

32
inline Vec3 operator*(const Vec3& v, float s) noexcept {
33
    Vec3 result(v);
34
    result *= s;
35
    return result;
36
}
37

38
inline Vec3 operator*(float s, const Vec3& v) noexcept {
39
    return v * s;  // 复用上面的版本
40
}

💡 为什么算术运算符返回新对象而不是引用？ 因为 a + b 产生的是一个全新的临时对象，不是 a 也不是 b。返回引用会导致悬垂引用。

10.3.2 比较运算符（==, !=, <, >, <=, >=）#

C++20 前：需要逐个定义 ==、!=、<、>、<=、>=。

1
// 传统写法（C++17 及之前）
2
class Vec3 {
3
public:
4
    float x, y, z;
5

6
    // == 和 != 基于所有成员
7
    friend bool operator==(const Vec3& a, const Vec3& b) noexcept {
8
        return a.x == b.x && a.y == b.y && a.z == b.z;
9
    }
10
    friend bool operator!=(const Vec3& a, const Vec3& b) noexcept {
11
        return !(a == b);  // 用 == 实现 !=
12
    }
13

14
    // < 用于排序（std::map、std::sort 等）
15
    friend bool operator<(const Vec3& a, const Vec3& b) noexcept {
16
        if (a.x != b.x) return a.x < b.x;
17
        if (a.y != b.y) return a.y < b.y;
18
        return a.z < b.z;
19
    }
20
    // 剩下的 >, <=, >= 都可以用 < 组合出来
21
    friend bool operator>(const Vec3& a, const Vec3& b) noexcept  { return b < a; }
22
    friend bool operator<=(const Vec3& a, const Vec3& b) noexcept { return !(b < a); }
23
    friend bool operator>=(const Vec3& a, const Vec3& b) noexcept { return !(a < b); }
24
};

C++20 三路比较（Spaceship Operator <=>）：一个运算符搞定所有比较。

1
// C++20 写法 —— 编译器自动生成全部六个比较运算符
2
class Vec3 {
3
public:
4
    float x, y, z;
5

6
    // = default: 按成员声明顺序逐一比较（类似 std::tie）
7
    auto operator<=>(const Vec3&) const = default;
8

9
    // 如果成员全是基本类型，== 也建议 = default
10
    bool operator==(const Vec3&) const = default;
11
};
12

13
// 以上就是全部！编译器会自动生成：
14
// ==, !=, <, >, <=, >= 全部六个运算符
15

16
// 使用效果
17
Vec3 a{1, 2, 3}, b{1, 2, 4};
18
bool result = a < b;   // true（编译器自动生成，比较 x→y→z）

1
// 手动实现 <=>（当你的比较逻辑不是简单逐成员时）
2
struct Score {
3
    int points;
4
    int deaths;  // 死亡数越少越好（反向排序）
5

6
    std::strong_ordering operator<=>(const Score& other) const {
7
        // 先按 points 降序
8
        if (auto cmp = other.points <=> points; cmp != 0)
9
            return cmp;
10
        // 再按 deaths 升序（death 少 = 好 = 更大）
11
        return deaths <=> other.deaths;
12
    }
13
};
14

15
Score a{100, 5}, b{100, 3};
16
// a: 击杀 100 死亡 5, b: 击杀 100 死亡 3
17
// b 更好（死亡更少）→ b > a

💡 <=> 的三种返回类型：

std::strong_ordering：完全可替代（如 int），a == b 意味着 a 和 b 不可区分

std::weak_ordering：相对等价（如大小写不敏感的字符串），a == b 不意味着不可区分

std::partial_ordering：部分有序（如 float/double，因为有 NaN），NaN < 0 和 NaN >= 0 都可能是 false

10.3.3 赋值运算符（=, +=, -=, *=, /=）#

1
// 拷贝赋值 —— 成员函数，返回引用
2
class String {
3
    char* _data;
4
    size_t _size;
5
public:
6
    // 返回 *this 引用，支持链式赋值: a = b = c;
7
    String& operator=(const String& other) {
8
        if (this != &other) {               // 防止自赋值
9
            String temp(other);             // Copy-and-Swap
10
            swap(temp);
11
        }
12
        return *this;
13
    }
14

15
    // 移动赋值
16
    String& operator=(String&& other) noexcept {
17
        if (this != &other) {
18
            delete[] _data;
19
            _data = other._data;
20
            _size = other._size;
21
            other._data = nullptr;
22
            other._size = 0;
23
        }
24
        return *this;
25
    }
26

27
    // 复合赋值 —— 成员函数，返回引用
28
    String& operator+=(const String& other) {
29
        size_t newSize = _size + other._size;
30
        char* newData = new char[newSize + 1];
31
        strcpy(newData, _data);
32
        strcat(newData, other._data);
33
        delete[] _data;
34
        _data = newData;
35
        _size = newSize;
36
        return *this;
37
    }
38

39
    void swap(String& other) noexcept {
40
        std::swap(_data, other._data);
41
        std::swap(_size, other._size);
42
    }
43
};

10.3.4 自增/自减（++i, i++）#

1
class Iterator {
2
    int* _ptr;
3
public:
4
    // 前置 ++（++it）→ 返回自增后的引用
5
    Iterator& operator++() noexcept {
6
        ++_ptr;
7
        return *this;
8
    }
9

10
    // 后置 ++（it++）→ 返回自增前的副本，int 参数是哑元（dummy）
11
    Iterator operator++(int) noexcept {
12
        Iterator old(*this);  // 保存旧值
13
        ++_ptr;               // 调用前置版本
14
        return old;           // 返回旧值
15
    }
16

17
    // 前置 -- 同理
18
    Iterator& operator--() noexcept {
19
        --_ptr;
20
        return *this;
21
    }
22

23
    // 后置 --
24
    Iterator operator--(int) noexcept {
25
        Iterator old(*this);
26
        --_ptr;
27
        return old;
28
    }
29
};

💡 面试中切记：前置返回引用（T&），后置返回值（T）且接受一个哑元 int 参数。后置版本通常调用前置版本实现，避免重复逻辑。

10.3.5 下标运算符（operator[]）#

1
template <typename T>
2
class Array {
3
    T* _data;
4
    size_t _size;
5
public:
6
    // const 版本：const 对象访问
7
    const T& operator[](size_t i) const {
8
        assert(i < _size);
9
        return _data[i];
10
    }
11

12
    // 非 const 版本：可修改
13
    T& operator[](size_t i) {
14
        assert(i < _size);
15
        return _data[i];
16
    }
17

18
    // ❌ 不要返回临时值的引用
19
    // T& operator[](size_t i) const { ... }  // 破坏 const 正确性
20
};

10.3.6 函数调用运算符（operator()）#

1
// 仿函数（Functor）—— 带状态的可调用对象
2
// C++ 标准库大量使用：std::less<>, std::hash<>, 自定义排序器
3

4
// 示例一：自定义排序器
5
struct ByDistance {
6
    Vec3 origin;
7
    bool operator()(const Vec3& a, const Vec3& b) const {
8
        return (a - origin).length() < (b - origin).length();
9
    }
10
};
11

12
std::vector<Vec3> points = { ... };
13
std::sort(points.begin(), points.end(), ByDistance{Vec3{0, 0, 0}});
14

15
// 示例二：累计器
16
struct Accumulator {
17
    int sum = 0;
18
    void operator()(int x) { sum += x; }
19
};
20

21
Accumulator acc;
22
acc = std::for_each(v.begin(), v.end(), acc);
23
std::cout << acc.sum << std::endl;  // 所有元素的和
24

25
// 示例三：多次调用状态机（协程基础）
26
struct Range {
27
    int start, end;
28
    int operator()() {
29
        if (start < end) return start++;
30
        throw std::out_of_range("exhausted");
31
    }
32
};
33
Range gen{0, 5};
34
while (true) {
35
    try { std::cout << gen() << " "; }
36
    catch (...) { break; }
37
}
38
// 输出: 0 1 2 3 4

10.3.7 解引用运算符（operator*, operator->）#

智能指针的核心。第二章已经展示过手写 UniquePtr，这里专注于规律总结。

1
template <typename T>
2
class Ptr {
3
    T* _p;
4
public:
5
    // operator* → 返回引用
6
    T& operator*() const { return *_p; }
7

8
    // operator-> → 返回指针（编译器会自动递归调用 -> 直到遇到裸指针）
9
    T* operator->() const { return _p; }
10
};
11

12
// operator-> 的特殊行为：
13
Ptr<Ptr<int>> pp;  // pp-> 调用一次 Ptr::operator->，返回 Ptr<int>*
14
                   // 编译器发现返回的还是一个对象（Ptr<int>）
15
                   // → 自动再调用 Ptr<int>::operator->，返回 int*
16
                   // → 最终访问到 int 的成员
17

18
// 这就是智能指针的 operator-> 能链式穿透的原因。

10.3.8 类型转换运算符（operator T）#

1
// 隐式转换运算符 —— 危险！容易引发意料之外的转换
2
struct Wrapper {
3
    int _value;
4
    operator int() const { return _value; }  // 隐式转 int
5
};
6

7
Wrapper w{42};
8
int x = w;          // 隐式转换
9
std::cout << w;     // 也工作了！（转为 int 再输出）
10
auto y = w + 1;     // y = 43，这可能是你想要的，也可能不是
11

12
// ✅ C++11 显式转换运算符 —— 安全
13
struct SafeWrapper {
14
    int _value;
15
    explicit operator int() const { return _value; }
16
};
17

18
SafeWrapper sw{42};
19
// int x = sw;      // ❌ 编译错误！不能隐式转换
20
int y = static_cast<int>(sw);  // ✅ 必须显式
21
// 但：if、while、for、!、&&、|| 等需要 bool 的上下文中，
22
// explicit operator bool 仍然可以隐式工作（contextual conversion）

1
// ❌ 经典陷阱：提供太多隐式转换
2
struct BadString {
3
    operator const char*() const;  // 转 C 字符串
4
    operator int() const;          // 转整数？
5
    // BadString s;
6
    // s + 1;  // 这不明确！是转为 const char* 做指针算术，还是转为 int 做整数加法？
7
};
8

9
// ✅ 最佳实践：优先用命名函数而非转换运算符
10
struct GoodString {
11
    const char* c_str() const;     // 明确、不会意外触发
12
    int toInt() const;
13
};

10.3.9 流运算符（operator<<, operator>>）#

1
// 必须是非成员函数（左参数是 std::ostream，不是你的类）
2
class Point {
3
    float x, y;
4
public:
5
    // 输出到流
6
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {
7
        return os << "Point(" << p.x << ", " << p.y << ")";
8
    }
9

10
    // 从流读取
11
    friend std::istream& operator>>(std::istream& is, Point& p) {
12
        return is >> p.x >> p.y;
13
    }
14
};

10.3.10 new / delete 运算符重载#

第一章详细讲过，这里只提面试关键点：

1
// 全局 operator new / delete
2
void* operator new(size_t size) {
3
    void* p = std::malloc(size);
4
    if (!p) throw std::bad_alloc();
5
    return p;
6
}
7

8
void operator delete(void* p) noexcept {
9
    std::free(p);
10
}
11

12
// 类内重载 —— 为特定类型定制分配策略
13
class Pooled {
14
public:
15
    static void* operator new(size_t size) {
16
        return PoolAllocator::allocate(size);
17
    }
18
    static void operator delete(void* p) noexcept {
19
        PoolAllocator::deallocate(p);
20
    }
21
};

10.4 经典陷阱与面试题#

10.4.1 这段代码有什么问题？#

陷阱一：返回局部引用

1
Vec3& operator+(const Vec3& a, const Vec3& b) {
2
    Vec3 result(a.x + b.x, a.y + b.y, a.z + b.z);
3
    return result;  // ❌ 返回局部对象的引用 —— 悬垂！
4
}

陷阱二：赋值运算符忘了自赋值保护

1
String& String::operator=(const String& other) {
2
    delete[] _data;                     // 如果 other 就是 *this？
3
    _size = other._size;
4
    _data = new char[_size + 1];
5
    strcpy(_data, other._data);         // other._data 已被 delete！
6
    return *this;
7
}

陷阱三：运算符优先级不直观

1
// 如果你重载了 operator%
2
Vec3 v = a + b % c;  // 你以为: (a + b) % c
3
                     // 实际:   a + (b % c) （% 优先级高于 +）
4
// 无法改变内置优先级！这是语言硬编码的。

陷阱四：operator&& 和 operator|| 的重载破坏短路

1
// ❌ 重载 && 和 || 会失去短路求值特性！
2
struct MyBool {
3
    bool _v;
4
    MyBool operator&&(const MyBool& other) const {
5
        return MyBool{_v && other._v};
6
    }
7
};
8

9
MyBool a{false}, b{throw std::runtime_error("should not run")};
10
// 内置 &&：a && b → false（b 不会被求值）
11
// 重载 &&：a && b → 两个参数都会被求值 → 抛异常！
12
// 所以：基本上不要重载 && 和 ||

陷阱五：比较运算符不对称

1
// ❌ 只定义了成员 operator<
2
struct Data {
3
    int id;
4
    bool operator<(const Data& other) const { return id < other.id; }
5
};
6

7
Data d{1};
8
d < 2;   // ✅ 如果 Data(int) 不是 explicit
9
2 < d;   // ❌ 编译错误！int 没有 operator<(int, Data)
10

11
// ✅ 用非成员函数解决对称性
12
bool operator<(const Data& a, const Data& b) { return a.id < b.id; }

10.5 游戏实战场景#

10.5.1 游戏数学库#

1
// 游戏中最常见的运算符重载场景
2
struct Vector2 {
3
    float x = 0, y = 0;
4

5
    Vector2() = default;
6
    Vector2(float x_, float y_) : x(x_), y(y_) {}
7

8
    // 复合赋值
9
    Vector2& operator+=(Vector2 v) noexcept { x += v.x; y += v.y; return *this; }
10
    Vector2& operator-=(Vector2 v) noexcept { x -= v.x; y -= v.y; return *this; }
11
    Vector2& operator*=(float s)   noexcept { x *= s;   y *= s;   return *this; }
12
    Vector2& operator/=(float s)   noexcept { x /= s;   y /= s;   return *this; }
13

14
    // 比较（C++20）
15
    auto operator<=>(const Vector2&) const = default;
16
};
17

18
// 算术（非成员）
19
inline Vector2 operator+(Vector2 a, Vector2 b) noexcept { return a += b; }
20
inline Vector2 operator-(Vector2 a, Vector2 b) noexcept { return a -= b; }
21
inline Vector2 operator*(Vector2 v, float s)  noexcept { return v *= s; }
22
inline Vector2 operator*(float s, Vector2 v)  noexcept { return v *= s; }
23
inline Vector2 operator/(Vector2 v, float s)  noexcept { return v /= s; }
24

25
// 一元负号
26
inline Vector2 operator-(Vector2 v) noexcept { return {-v.x, -v.y}; }
27

28
// 点积（用 | 或命名函数；很多人认为用运算符表示点积是滥用）
29
inline float dot(Vector2 a, Vector2 b) noexcept { return a.x * b.x + a.y * b.y; }
30

31
// 在游戏代码中的使用体验
32
Vector2 position(100, 200);
33
Vector2 velocity(5, -2);
34
float dt = 0.016f;
35

36
position += velocity * dt;    // 读起来就是物理公式
37
Vector2 nextPos = position + velocity * dt;  // 更清晰

10.5.2 自定义迭代器 —— 遍历场景树#

1
// 为自定义数据结构实现迭代器，让 range-for 能工作
2
class SceneNode {
3
    std::vector<SceneNode*> _children;
4
public:
5
    class Iterator {
6
        SceneNode** _ptr;
7
    public:
8
        explicit Iterator(SceneNode** p) : _ptr(p) {}
9

10
        SceneNode& operator*()  const { return **_ptr; }
11
        SceneNode* operator->() const { return *_ptr; }
12

13
        Iterator& operator++()    noexcept { ++_ptr; return *this; }
14
        Iterator  operator++(int) noexcept { return Iterator(_ptr++); }
15

16
        bool operator==(const Iterator& other) const noexcept { return _ptr == other._ptr; }
17
        bool operator!=(const Iterator& other) const noexcept { return _ptr != other._ptr; }
18
    };
19

20
    Iterator begin() { return Iterator(_children.data()); }
21
    Iterator end()   { return Iterator(_children.data() + _children.size()); }
22
};
23

24
// 使用：原生 range-for
25
SceneNode node;
26
for (auto& child : node) {
27
    child.update();
28
}

10.5.3 Handle 系统的运算符支持#

1
// 联动第五章的 Handle 系统，加入运算符让 Handle 用起来像指针
2
template <typename T>
3
class Handle {
4
    uint32_t _index;
5
    uint32_t _generation;
6
public:
7
    // operator-> 和 operator* —— 像指针一样访问
8
    T* operator->() {
9
        return ObjectPool<T>::get(_index, _generation);
10
    }
11
    T& operator*() {
12
        return *operator->();
13
    }
14

15
    // operator bool —— 判断 Handle 是否有效
16
    explicit operator bool() const {
17
        return ObjectPool<T>::isValid(_index, _generation);
18
    }
19

20
    // operator== —— 比较两个 Handle 是否指向同一对象
21
    bool operator==(const Handle& other) const noexcept {
22
        return _index == other._index && _generation == other._generation;
23
    }
24
    bool operator!=(const Handle& other) const noexcept {
25
        return !(*this == other);
26
    }
27
};
28

29
// 使用体验
30
Handle<Entity> entity = world.spawn();
31
if (entity) {
32
    entity->setPosition(1, 2, 3);  // 像指针
33
    (*entity).setPosition(1, 2, 3); // 等价写法
34
}

10.6 30 秒速答#

Q：哪些运算符必须重载为成员函数？

=（赋值）、[]（下标）、()（函数调用）、->（成员访问）、类型转换运算符（operator T()）。这五个必须是成员函数，不能作为非成员函数重载。

Q：什么情况用成员函数，什么情况用非成员？

如果运算符要求左操作数是本类类型且需要修改对象（如 +=、++），用成员函数。如果要求对称性（如 +、==，左操作数可能不是本类类型），用非成员函数。<< 和 >> 因为左操作数是 std::ostream/std::istream，只能用非成员（或 friend）。

Q：C++20 的 <=> 有什么用？

定义 operator<=>（三路比较 / Spaceship），编译器会自动生成 ==、!=、<、>、<=、>= 全部六个比较运算符。还可以 = default 让编译器帮你逐成员比较，省掉大量样板代码。

Q：为什么不要重载 && 和 ||？

内置 && 和 || 有短路求值特性（左侧为 false 时不求值右侧）。重载后变成普通函数调用，两个参数都会被求值，破坏了使用者对短路的所有预期，极易引发 bug。

Q：operator++() 和 operator++(int) 的区别？

前者是前置自增（++x），返回引用；后者是后置自增（x++），返回旧值的副本，int 参数是哑元仅用于区分签名。后置版本通常调用前置版本实现。

Q：什么是 ADL（Argument-Dependent Lookup）？

当调用一个函数时，编译器除了在当前作用域查找，还会在函数参数类型所在的命名空间中查找。这就是为什么 std::cout << "hello" 能找到 std::operator<<(ostream&, const char*)，以及为什么你定义的 operator+ 放在和 Vec3 同一个命名空间中就能被找到，而不需要 using。

📖 上一章：第九章异常处理与异常安全 —— 栈展开、异常安全三大保证、noexcept 与移动语义的联动、游戏资源加载的错误恢复。

📖 下一章：敬请期待 —— C# 系列即将上线。

音乐

音乐

第十章运算符重载：让自定义类型像内置类型一样工作#

10.1 概念直觉 —— What & Why#

为什么需要运算符重载？#

核心规则速览#

10.2 原理图解#

10.2.1 成员 vs 非成员 —— 选择决策#

10.2.2 a + b 的编译过程#

10.3 底层机制 —— 逐类击破#

10.3.1 算术运算符（+, -, *, /, %）#

10.3.2 比较运算符（==, !=, <, >, <=, >=）#

10.3.3 赋值运算符（=, +=, -=, *=, /=）#

10.3.4 自增/自减（++i, i++）#

10.3.5 下标运算符（operator[]）#

10.3.6 函数调用运算符（operator()）#

10.3.7 解引用运算符（operator*, operator->）#

10.3.8 类型转换运算符（operator T）#

10.3.9 流运算符（operator<<, operator>>）#

10.3.10 new / delete 运算符重载#

10.4 经典陷阱与面试题#

10.4.1 这段代码有什么问题？#

10.5 游戏实战场景#

10.5.1 游戏数学库#

10.5.2 自定义迭代器 —— 遍历场景树#

10.5.3 Handle 系统的运算符支持#

10.6 30 秒速答#

文章分享

评论区

音乐

目录

音乐

音乐

第十章 运算符重载：让自定义类型像内置类型一样工作

第十章 运算符重载：让自定义类型像内置类型一样工作#

10.1 概念直觉 —— What & Why#

为什么需要运算符重载？#

核心规则速览#

10.2 原理图解#

10.2.1 成员 vs 非成员 —— 选择决策#

10.2.2 a + b 的编译过程#

10.3 底层机制 —— 逐类击破#

10.3.1 算术运算符（+, -, *, /, %）#

10.3.2 比较运算符（==, !=, <, >, <=, >=）#

10.3.3 赋值运算符（=, +=, -=, *=, /=）#

10.3.4 自增/自减（++i, i++）#

10.3.5 下标运算符（operator[]）#

10.3.6 函数调用运算符（operator()）#

10.3.7 解引用运算符（operator*, operator->）#

10.3.8 类型转换运算符（operator T）#

10.3.9 流运算符（operator<<, operator>>）#

10.3.10 new / delete 运算符重载#

10.4 经典陷阱与面试题#

10.4.1 这段代码有什么问题？#

10.5 游戏实战场景#

10.5.1 游戏数学库#

10.5.2 自定义迭代器 —— 遍历场景树#

10.5.3 Handle 系统的运算符支持#

10.6 30 秒速答#

文章分享

评论区

音乐

目录

第十章运算符重载：让自定义类型像内置类型一样工作

第十章运算符重载：让自定义类型像内置类型一样工作#