运算符重载允许为自定义类型赋予现有运算符新功能，提升代码可读性。它通过定义以operator为前缀的特殊函数实现，可作为成员或友元函数重载。多数运算符可重载，如算术、关系、位运算、赋值、递增递减、下标、函数调用等；但., .*, ::, ?:, sizeof, typeid不可重载。选择成员函数还是友元函数取决于操作数对称性与访问需求：赋值、下标、函数调用等必须为成员函数；流操作及需类型转换的二元运算符宜用友元函数。最佳实践包括保持语义一致、const正确性、用复合赋值实现二元运算符、处理自赋值与资源管理（如copy-and-swap）、避免过度重载。陷阱有行为反直觉、性能损耗、不一致实现等。合理使用可增强表达力，滥用则导致混乱。
C++中的运算符重载，简单来说，就是赋予现有运算符新的功能，让它们能够作用于我们自定义的类类型对象。这就像是给一个老工具箱里的锤子、螺丝刀重新定义用途，让它们也能处理一些新材料，核心目的是提高代码的可读性和直观性，让用户自定义类型的使用体验更接近内置类型。
在C++里，重载运算符其实就是定义一个特殊的函数。这个函数的名称是
operator关键字后面跟着要重载的运算符符号。比如说，如果你想让两个
Vector对象能像数字一样直接相加，你就可以重载
+运算符。
重载运算符的函数签名通常是这样的：
返回类型 operator 运算符符号 (参数列表)。具体实现时，这个函数可以是类的成员函数，也可以是全局函数（通常是友元函数）。选择哪种方式，往往取决于运算符的性质和操作数的类型。例如，像
=、
[]、
()、
->这类与对象本身紧密相关的运算符，几乎总是作为成员函数来重载。而像二元算术运算符（
+,
-,
*,
/）或者流插入/提取运算符（
<<,
>>），如果需要支持左操作数不是类类型的情况（比如
int + MyClass），或者需要对称性，那么作为非成员函数（通常是友元函数）会是更灵活的选择。
#includeclass MyVector { public: int x, y; MyVector(int x = 0, int y = 0) : x(x), y(y) {} // 成员函数重载 + 运算符 MyVector operator+(const MyVector& other) const { return MyVector(x + other.x, y + other.y); } // 成员函数重载 - 运算符 MyVector operator-(const MyVector& other) const { return MyVector(x - other.x, y - other.y); } // 成员函数重载 += 运算符 MyVector& operator+=(const MyVector& other) { x += other.x; y += other.y; return *this; } // 前置递增运算符 MyVector& operator++() { ++x; ++y; return *this; } // 后置递增运算符 (int 参数是占位符，用于区分前置) MyVector operator++(int) { MyVector temp = *this; ++(*this); // 调用前置递增 return temp; } // 友元函数重载 << 运算符，用于输出 friend std::ostream& operator<<(std::ostream& os, const MyVector& vec) { os << "(" << vec.x << ", " << vec.y << ")"; return os; } // 友元函数重载 == 运算符 friend bool operator==(const MyVector& v1, const MyVector& v2) { return v1.x == v2.x && v1.y == v2.y; } // 友元函数重载 != 运算符 friend bool operator!=(const MyVector& v1, const MyVector& v2) { return !(v1 == v2); // 通常基于 == 实现 } }; int main() { MyVector v1(1, 2); MyVector v2(3, 4); MyVector v3 = v1 + v2; // 使用重载的 + std::cout << "v1 + v2 = " << v3 << std::endl; // 使用重载的 << MyVector v4 = v1 - v2; // 使用重载的 - std::cout << "v1 - v2 = " << v4 << std::endl; v1 += v2; // 使用重载的 += std::cout << "v1 after += v2 = " << v1 << std::endl; MyVector v5 = ++v1; // 前置递增 std::cout << "v5 (pre-increment v1) = " << v5 << ", v1 = " << v1 << std::endl; MyVector v6 = v1++; // 后置递增 std::cout << "v6 (post-increment v1) = " << v6 << ", v1 = " << v1 << std::endl; MyVector v7(5, 7); std::cout << "v1 == v7 is " << (v1 == v7 ? "true" : "false") << std::endl; std::cout << "v1 != v7 is " << (v1 != v7 ? "true" : "false") << std::endl; return 0; }
C++中哪些运算符可以被重载？
在C++中，绝大多数运算符都可以被重载，这给我们自定义类型带来了极大的灵活性。我通常会把它们分成几类来记忆，这样更清晰一些：
立即学习“C++免费学习笔记（深入）”；
可以重载的运算符包括：
-
算术运算符：
+
,-
,*
,/
,%
-
关系运算符：
==
,!=
,<
,>
,<=
,>=
-
逻辑运算符：
&&
,||
,!
(但通常不推荐重载&&
和||
，因为它们有短路求值特性，重载后会失去这个特性，可能导致预期外的行为) -
位运算符：
&
,|
,^
,~
,<<
,>>
-
赋值运算符：
=
,+=
,-=
,*=
,/=
,%=
,&=
,|=
,^=
,<<=
,>>=
-
递增/递减运算符：
++
,--
(需要区分前置和后置形式) -
下标运算符：
[]
-
函数调用运算符：
()
(这允许对象像函数一样被调用，非常强大) -
成员访问运算符：
->
(常用于智能指针的实现) -
内存管理运算符：
new
,delete
,new[]
,delete[]
-
类型转换运算符：
operator type()
(例如operator int()
，允许隐式或显式转换为其他类型)
然而，有一些运算符是C++明确规定不能被重载的，主要有：
-
成员选择运算符：
.
(点运算符) -
成员指针选择运算符：
.*
-
作用域解析运算符：
::
-
条件运算符：
?:
sizeof
运算符typeid
运算符
我个人觉得，这些不可重载的运算符都有其特殊性。例如，
.运算符直接关系到成员访问的语法结构，如果能重载，C++的语法解析会变得异常复杂且模糊；
sizeof和
typeid是编译时或运行时获取类型信息的关键，它们的操作数不是常规意义上的对象，而是类型或表达式，重载它们没有实际意义。理解这些限制，其实也是对C++设计哲学的一种认识。
运算符重载时，选择成员函数还是友元函数？
这是一个在设计自定义类型时经常需要权衡的问题。我通常会根据运算符的语义和操作数的特性来决定。
成员函数重载的特点：
-
左操作数必须是类类型的对象。 当运算符的左操作数始终是你的类类型对象时，成员函数是自然的选择。例如，
myObject.operator+(anotherObject)
。 -
隐式
this
指针。 成员函数可以隐式访问当前对象的私有和保护成员，无需额外的权限。 -
适合一元运算符。 比如
!
(逻辑非)、++
(递增)、--
(递减) 等，它们只作用于一个对象，作为成员函数非常合理。 -
赋值运算符
=
必须是成员函数。 这是语言强制的规定，因为它涉及到对象状态的改变。 -
下标运算符
[]
、函数调用运算符()
、成员访问运算符->
也必须是成员函数。 它们与对象的行为和访问方式紧密相关。
友元函数（非成员函数）重载的特点：
-
提供对称性。 对于二元运算符，如果希望左操作数可以是其他类型（比如
int + MyClass
而不仅仅是MyClass + int
），或者希望运算符的行为对所有操作数类型都“一视同仁”，那么友元函数是更好的选择。例如，std::cout << myObject
，这里的左操作数是std::ostream
类型，显然不能是MyClass
的成员函数。 - 需要友元声明才能访问私有成员。 如果非成员函数需要访问类的私有或保护成员，就必须在类中声明为友元。
-
通常用于流插入/提取运算符
<<
和>>
。 这是因为它们通常需要操作std::ostream
或std::istream
对象作为左操作数。 - *实现算术运算符
+
,-
, `,
/的一种常见且推荐的方式。** 许多人会先在类中实现
+=,
-=,
=等复合赋值运算符作为成员函数，然后将
+,
-,
` 等二元算术运算符作为非成员函数，通过调用复合赋值运算符来实现，这样可以避免代码重复，并利用了复合赋值运算符通常效率更高的特点。
我的选择策略是这样的：
如果运算符必须是成员函数（例如
=
,[]
,()
等），那就别无选择。如果运算符是一元运算符（例如
!
++
--
），并且操作数是你的类类型，优先考虑成员函数。-
如果运算符是二元运算符，且需要支持操作数类型不对称的情况（例如
int + MyClass
），或者需要与标准库流对象交互（<<
,>>
），那么非成员友元函数通常是更优的选择。 比如，对于+
运算符，我通常会这样实现：// MyClass 的成员函数 MyClass& operator+=(const MyClass& rhs) { // ... 实现加法赋值逻辑 ... return *this; } // 非成员函数（可以是非友元，如果只需要公共接口） MyClass operator+(MyClass lhs, const MyClass& rhs) { lhs += rhs; // 利用 += 实现 return lhs; }这样
operator+
就可以接收两个MyClass
对象，或者一个MyClass
和一个可以隐式转换为MyClass
的对象，并且保证了效率和代码复用。
C++运算符重载有哪些常见陷阱和最佳实践？
运算符重载虽然强大，但用不好也容易挖坑。我见过不少因为重载而引入的bug，所以有一些经验总结出的陷阱和最佳实践，我觉得挺有用的。
常见陷阱：
-
违反直觉的行为： 这是最危险的陷阱。重载运算符的目的是让代码更自然，如果
+
运算符不再是加法，或者==
运算符不符合等价关系（例如，a == b
为真，但b == a
为假），那代码就成了难以维护的“地雷阵”。用户会基于对内置类型的理解来使用你的运算符，一旦行为不符，就会导致混乱和错误。 -
效率问题： 尤其是在返回对象时，如果不注意，可能会产生不必要的临时对象拷贝，影响性能。例如，一个
operator+
如果返回一个MyClass
对象，而MyClass
又很大，每次运算都进行深拷贝，开销会很大。 -
自赋值问题： 在重载
operator=
时，忘记处理obj = obj
这种自赋值情况会导致资源泄露或数据损坏。 -
不一致性： 如果重载了
==
但没有重载!=
，或者重载了+
但没有重载+=
，或者它们之间的行为不一致，都会让用户感到困惑。 - 过度重载： 有些人喜欢重载所有能想到的运算符，但如果某个运算符的语义与你的类不符，或者很少用到，那就没必要重载，反而增加了类的复杂性。
最佳实践：
保持语义一致性： 这是最重要的原则。重载的运算符行为应该尽可能地与内置类型的相应运算符保持一致。例如，
+
应该是可交换的，==
应该是自反、对称和传递的。-
考虑
const
正确性： 如果一个运算符函数不会修改对象的状态，就应该声明为const
成员函数。这不仅能提高代码的安全性，还能让const
对象也能使用这些运算符。// 示例：const 正确性 MyVector operator+(const MyVector& other) const { // const 确保不会修改 *this return MyVector(x + other.x, y + other.y); } -
利用复合赋值运算符实现二元算术运算符： 对于
+
,-
,*
,/
等二元运算符，我强烈建议先实现其对应的复合赋值运算符 (+=
,-=
,*=
,/=
) 作为成员函数，然后将二元运算符作为非成员函数，通过调用复合赋值运算符来实现。// 成员函数 MyVector& operator+=(const MyVector& other) { /* ... */ return *this; } // 非成员函数 (可以是非友元，如果只需要公共接口) MyVector operator+(MyVector lhs, const MyVector& rhs) { lhs += rhs; // 调用成员函数 += return lhs; }这种模式的好处是：减少代码重复、保证行为一致性，并且利用了传值参数
lhs
的拷贝构造函数，避免了在operator+
内部手动创建临时对象。 -
正确实现
operator=
： 赋值运算符是核心，必须处理好自赋值、资源管理（深拷贝）和异常安全。一个常见的模式是“拷贝并交换”（copy-and-swap）惯用法，它能很好地保证异常安全。// 假设 MyClass 管理一个动态分配的资源 class MyClass { int* data; size_t size; public: // 构造函数 MyClass(size_t s = 0) : size(s), data(s > 0 ? new int[s] : nullptr) {} // 析构函数 ~MyClass() { delete[] data; } // 拷贝构造函数 MyClass(const MyClass& other) : size(other.size), data(other.size > 0 ? new int[other.size] : nullptr) { if (data) { std::copy(other.data, other.data + other.size, data); } } // 移动构造函数 (C++11) MyClass(MyClass&& other) noexcept : data(other.data), size(other.size) { other.data = nullptr; other.size = 0; } // 拷贝赋值运算符 (使用 copy-and-swap 惯用法) MyClass& operator=(MyClass other) { // 注意这里是传值参数，会调用拷贝构造函数 swap(*this, other); // 交换 *this 和 other 的内部状态 return *this; } // 友元 swap 函数 (用于 copy-and-swap) friend void swap(MyClass& first, MyClass& second) noexcept { using std::swap; swap(first.data, second.data); swap(first.size, second.size); } // ... 其他成员 ... }; 为
<<
和>>
重载流运算符： 这是实现自定义类型输入输出的标准方式，通常作为友元函数实现，因为左操作数是std::ostream
或std::istream
。-
考虑默认行为： C++11 引入了
default
和delete
关键字，可以显式地让编译器生成或禁止某些特殊成员函数（包括赋值运算符）。对于一些简单、没有资源管理的类，直接使用编译器生成的默认行为可能是最好的。class SimplePoint { public: int x, y; SimplePoint(int x=0, int y=0) : x(x), y(y) {} // 编译器会生成默认的拷贝构造、拷贝赋值、移动构造、移动赋值和析构函数 // 如果它们行为正确，就无需手动实现 };这被称为“零法则”（Rule of Zero），即如果你的类不需要自定义析构函数、拷贝构造函数或拷贝赋值运算符，那么它可能也不需要自定义移动构造函数或移动赋值运算符，直接依赖编译器生成的默认行为即可。
总的来说，重载运算符是C++提供的一把双刃剑，它能让代码更富有表现力，但前提是必须谨慎使用，确保其行为符合直觉、高效且正确。
