C++中的运算符重载，简单来说，就是赋予现有运算符新的功能，让它们能够作用于我们自定义的类类型对象。这就像是给一个老工具箱里的锤子、螺丝刀重新定义用途，让它们也能处理一些新材料，核心目的是提高代码的可读性和直观性，让用户自定义类型的使用体验更接近内置类型。
在C++里，重载运算符其实就是定义一个特殊的函数。这个函数的名称是
operator关键字后面跟着要重载的运算符符号。比如说，如果你想让两个
Vector对象能像数字一样直接相加，你就可以重载
+运算符。
重载运算符的函数签名通常是这样的：
返回类型 operator 运算符符号 (参数列表)。具体实现时，这个函数可以是类的成员函数，也可以是全局函数（通常是友元函数）。选择哪种方式，往往取决于运算符的性质和操作数的类型。例如，像
=、
[]、
()、
->这类与对象本身紧密相关的运算符，几乎总是作为成员函数来重载。而像二元算术运算符（
+,
-,
*,
/）或者流插入/提取运算符（
<<,
>>），如果需要支持左操作数不是类类型的情况（比如
int + MyClass），或者需要对称性，那么作为非成员函数（通常是友元函数）会是更灵活的选择。
#include <iostream>
class 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++中，绝大多数运算符都可以被重载，这给我们自定义类型带来了极大的灵活性。我通常会把它们分成几类来记忆，这样更清晰一些：
可以重载的运算符包括：
-
算术运算符：
+
,-
,*
,/
,%
-
关系运算符：
==
,!=
,<
,>
,<=
,>=
-
逻辑运算符：
&&
,||
,!
(但通常不推荐重载&&
和||
，因为它们有短路求值特性，重载后会失去这个特性，可能导致预期外的行为) -
位运算符：
&
,|
,^
,~
,<<
,>>
-
赋值运算符：
=
,+=
,-=
,*=
,/=
,%=
,&=
,|=
,^=
,<<=
,>>=
-
递增/递减运算符：
++
,--
(需要区分前置和后置形式) -
下标运算符：
[]
-
函数调用运算符：
()
(这允许对象像函数一样被调用，非常强大) -
成员访问运算符：
->
(常用于智能指针的实现) -
内存管理运算符：
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
），或者需要与标准库流对象交互（<<
,>>
），那么非成员友元函数通常是更优的选择。 比如，对于+
运算符，我通常会这样实现：
HyperWrite
AI写作助手帮助你创作内容更自信
54
查看详情
// MyClass 的成员函数 MyClass& operator+=(const MyClass& rhs) { // ... 实现加法赋值逻辑 ... return *this; } // 非成员函数（可以是非友元，如果只需要公共接口） MyClass operator+(MyClass lhs, const MyClass& rhs) { lhs += rhs; // 利用 += 实现 return lhs; }这样
operator+
就可以接收两个MyClass
对象，或者一个MyClass
和一个可以隐式转换为MyClass
的对象，并且保证了效率和代码复用。
运算符重载虽然强大，但用不好也容易挖坑。我见过不少因为重载而引入的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++提供的一把双刃剑，它能让代码更富有表现力，但前提是必须谨慎使用，确保其行为符合直觉、高效且正确。
以上就是如何在C++中重载运算符_C++运算符重载规则与实例的详细内容，更多请关注知识资源分享宝库其它相关文章！
相关标签： 工具 ai c++ ios 代码复用 作用域 代码可读性 标准库 隐式转换 运算符 算术运算符 赋值运算符 递减运算符 逻辑运算符 成员函数 构造函数 析构函数 const 关系运算符 位运算符 int 指针 重载运算符 值参数 函数重载 运算符重载 operator copy delete 类型转换 对象 作用域 default 一元运算符 this bug 大家都在看： C++中this指针在类成员函数中是如何工作的 C++内存泄漏检测工具使用技巧 C++工厂模式与抽象工厂区别解析 C++开发环境配置调试工具使用技巧 使用vcpkg为C++项目管理依赖库的具体步骤是什么
发表评论:
◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。