c++如何重载运算符_c++运算符重载规则与实践

32次阅读

C++运算符重载通过成员或非成员函数实现，如Vector类重载+和<<运算符，前者用于对象相加，后者借助友元函数输出对象；不可重载的运算符包括.、::、?:等，且不能改变优先级与操作数数量；自增/减需区分前缀（返回引用）与后缀（带int哑元，返回副本）；赋值运算符需防自赋值并正确管理内存，遵循三/五法则避免泄漏。

C++ 运算符重载允许你为自定义类型赋予运算符新的含义，使其能够像内置类型一样使用。这增强了代码的可读性和表达力。

解决方案

C++ 中重载运算符是通过定义特殊的成员函数或非成员函数来实现的。这些函数的名字是

operator

关键字后跟要重载的运算符。

1. 成员函数重载:

立即学习“.quark.cn/s/6e7abc4abb9f" style="text-decoration: underline !important; color: blue; font-weight: bolder;" rel="nofollow" target="_blank">C++免费学习笔记（深入）”；

当运算符左侧的操作数是该类的对象时，通常使用成员函数重载。例如，重载

运算符，让两个自定义的

Vector

对象相加：

class Vector { public:     double x, y;      Vector(double x = 0, double y = 0) : x(x), y(y) {}      Vector operator+(const Vector& other) const {         return Vector(x + other.x, y + other.y);     } };  int main() {     Vector v1(1, 2);     Vector v2(3, 4);     Vector v3 = v1 + v2; // 使用重载的 + 运算符     return 0; }

在这个例子中，

operator+

是

Vector

类的一个成员函数。它接受另一个

Vector

对象作为参数，并返回一个新的

Vector

对象，其 x 和 y 分别是两个原始

Vector

对象的 x 和 y 的和。

const

修饰符表示该函数不会修改调用它的对象。

2. 非成员函数重载:

当运算符左侧的操作数不是该类的对象，或者需要对称性时，使用非成员函数重载。例如，重载

<<

运算符，以便可以将

Vector

对象输出到

std::cout

：

#include <iostream>  class Vector { public:     double x, y;      Vector(double x = 0, double y = 0) : x(x), y(y) {}      friend std::ostream& operator<<(std::ostream& os, const Vector& v); // 声明友元函数 };  std::ostream& operator<<(std::ostream& os, const Vector& v) {     os << "(" << v.x << ", " << v.y << ")";     return os; }  int main() {     Vector v(1, 2);     std::cout << v; // 使用重载的 << 运算符     return 0; }

这里，

operator<<

是一个非成员函数，它接受一个

std::ostream

对象和一个

Vector

对象作为参数。它将

Vector

对象的 x 和 y 输出到

std::ostream

对象，并返回

std::ostream

对象。由于该函数需要访问

Vector

对象的私有成员，所以声明为

Vector

类的友元函数。

C++ 运算符重载有哪些限制？

.yycxw.com/ai/%E7%81%AB%E5%B1%B1%E7%BF%BB%E8%AF%91"> c++如何重载运算符_c++运算符重载规则与实践

.yycxw.com/ai/%E7%81%AB%E5%B1%B1%E7%BF%BB%E8%AF%91">火山翻译

火山翻译，字节跳动旗下的机器翻译品牌，支持超过100种语种的免费在线翻译，并支持多种领域翻译

198

.yycxw.com/ai/%E7%81%AB%E5%B1%B1%E7%BF%BB%E8%AF%91"> 查看详情 c++如何重载运算符_c++运算符重载规则与实践

并非所有的运算符都可以重载。以下运算符不能被重载：

```
.
```
(成员访问运算符)
```
.*
```
,
```
->*
```
(成员指针访问运算符)
```
::
```
(作用域解析运算符)
```
?:
```
(三元条件运算符)
```
sizeof
```
(sizeof 运算符)
```
typeid
```
(typeid 运算符)

static_cast

,

dynamic_cast

,

const_cast

,

reinterpret_cast

(类型转换运算符)

此外，运算符的优先级和结合性不能被改变。重载运算符也不能改变运算符的操作数数量。例如，你不能将一个一元运算符重载为二元运算符。

重载运算符时应该遵循哪些最佳实践？

保持一致性： 重载运算符应该使其行为与内置类型的行为类似。例如，如果你重载了
```
+
```
运算符，它应该执行加法操作，而不是其他任何操作。
避免歧义： 重载运算符不应该导致代码难以理解。如果一个运算符有多种可能的含义，那么最好不要重载它。
考虑性能： 重载运算符可能会影响性能。如果一个运算符被频繁使用，那么应该确保它的实现是高效的。使用
```
const
```
引用传递参数可以避免不必要的复制。
使用友元函数： 对于某些运算符，例如
```
<<
```
和
```
>>
```
，使用友元函数可以更方便地访问类的私有成员。
避免过度重载： 不是每个运算符都需要重载。只有在重载运算符可以显著提高代码的可读性和表达力时，才应该考虑重载它。

如何重载自增和自减运算符（++ 和 –）？

C++ 中自增和自减运算符有前缀和后缀两种形式。为了区分这两种形式，后缀形式的重载函数需要一个

int

类型的哑元参数。

class Counter { private:     int value; public:     Counter(int v = 0) : value(v) {}      // 前缀自增     Counter& operator++() {         ++value;         return *this;     }      // 后缀自增     Counter operator++(int) {         Counter temp = *this; // 保存原始值         ++value;         return temp; // 返回原始值     }      int getValue() const { return value; } };  int main() {     Counter c(5);     std::cout << "Prefix: " << (++c).getValue() << std::endl; // 输出 6     std::cout << "Postfix: " << (c++).getValue() << std::endl; // 输出 6，但 c 的值现在是 7     std::cout << "Current: " << c.getValue() << std::endl;   // 输出 7     return 0; }

前缀形式的

operator++()

首先递增

value

，然后返回递增后的对象的引用。后缀形式的

operator++(int)

首先保存对象的原始值，然后递增

value

，最后返回原始值的副本。这个

int

参数只是一个占位符，用于区分前缀和后缀形式。

重载赋值运算符 (=) 时需要注意什么？

重载赋值运算符需要特别小心，以避免浅拷贝和内存泄漏。必须确保正确地复制对象的所有成员，包括指针指向的动态分配的内存。通常，需要遵循“复制构造函数、赋值运算符和析构函数”的三/五法则。

class String { private:     char* data;     size_t length;  public:     String(const char* str = nullptr) : data(nullptr), length(0) {         if (str) {             length = strlen(str);             data = new char[length + 1];             strcpy(data, str);         }     }      // 复制构造函数     String(const String& other) : data(nullptr), length(0) {         length = other.length;         data = new char[length + 1];         strcpy(data, other.data);     }      // 赋值运算符     String& operator=(const String& other) {         if (this == &other) {             return *this; // 防止自赋值         }          // 释放旧内存         delete[] data;          // 分配新内存并复制数据         length = other.length;         data = new char[length + 1];         strcpy(data, other.data);          return *this;     }      // 析构函数     ~String() {         delete[] data;     } };