C++运算符重载方法与规则详解

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

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

解决方案

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

1. 成员函数重载:

当运算符左侧的操作数是该类的对象时，通常使用成员函数重载。例如，重载 + 运算符，让两个自定义的 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;
    }
};

在这个例子中，赋值运算符首先检查是否是自赋值，如果是，则直接返回 *this。然后，它释放旧的 data 指向的内存，分配新的内存，并将 other 对象的 data 复制到新的内存中。这可以防止内存泄漏和悬挂指针。 复制构造函数和析构函数也需要正确地管理动态分配的内存。