c++如何重载运算符_c++运算符重载规则与实践-C++-PHP中文网

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

裘德小鎮的故事

发布： 2025-09-21 08:24:02

原创

798人浏览过

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

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

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

解决方案

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

operator

登录后复制

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

1. 成员函数重载:

立即学习“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++ 运算符重载有哪些限制？

算家云

高效、便捷的人工智能算力服务平台

查看详情

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

```
.
```
登录后复制
(成员访问运算符)
```
.*
```
登录后复制
,
```
->*
```
登录后复制
(成员指针访问运算符)
```
::
```
登录后复制
(作用域解析运算符)
```
?:
```
登录后复制
(三元条件运算符)
```
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;
    }
};

登录后复制

在这个例子中，赋值运算符首先检查是否是自赋值，如果是，则直接返回