C++操作符重载（Operator Overloading）是C++语言的一项重要特性，它允许程序员为自定义类型（类）重新定义操作符的行为。这使得用户定义的类型可以像基本数据类型（如int，float等）一样进行操作，从而提供了更直观的语法和更高效的代码。

1. 操作符重载的基本概念

在C++中，操作符重载允许我们定义操作符（如+, -, *, ==, []等）对于类的具体行为。这使得我们可以使用自定义对象之间的操作符，如同它们是基本数据类型一样。

1.1 语法

操作符重载的基本语法如下：

ReturnType operatorOp(Parameters) {  
    // 操作符重载逻辑  
}

1.2 规则

1. 不能改变操作符的优先级：重载后操作符的优先级和结合性不变。
2. 不能创建新操作符：只能重载已有的操作符。
3. 某些操作符不能重载：例如：::（作用域解析），.（成员访问），.*（成员指针访问），sizeof等。
4. 重载函数可以是成员函数或非成员函数：

• 成员函数：操作符左侧的对象是调用者（this指针）。
• 非成员函数：通过参数传递对象。

2. 操作符重载的示例

让我们通过示例详细了解如何重载操作符。

2.1 重载二元运算符 +

以下示例展示如何重载加法运算符以帮助实现两个对象之间的加法操作。

#include <iostream>  

class Point {  
private:  
    int x, y;  
public:  
    Point(int xVal, int yVal) : x(xVal), y(yVal) {}  

    // 重载 + 操作符  
    Point operator+(const Point& p) {  
        return Point(x + p.x, y + p.y);  
    }  

    void display() const {  
        std::cout << "Point(" << x << ", " << y << ")" << std::endl;  
    }  
};  

int main() {  
    Point p1(1, 2);  
    Point p2(3, 4);  
    Point p3 = p1 + p2; // 调用重载的 + 操作符  
    p3.display(); // 输出 Point(4, 6)  
    return 0;  
}

2.2 重载一元运算符 -

以下示例展示如何重载一元运算符：

#include <iostream>  

class Point {  
private:  
    int x, y;  
public:  
    Point(int xVal, int yVal) : x(xVal), y(yVal) {}  

    // 重载 - 操作符为一元  
    Point operator-() {  
        return Point(-x, -y);  
    }  

    void display() const {  
        std::cout << "Point(" << x << ", " << y << ")" << std::endl;  
    }  
};  

int main() {  
    Point p(3, 4);  
    Point negP = -p; // 调用重载的 - 操作符  
    negP.display(); // 输出 Point(-3, -4)  
    return 0;  
}

2.3 重载比较运算符 ==

重载比较运算符以比较两个对象。

#include <iostream>  

class Point {  
private:  
    int x, y;  
public:  
    Point(int xVal, int yVal) : x(xVal), y(yVal) {}  

    // 重载 == 操作符  
    bool operator==(const Point& p) {  
        return (x == p.x && y == p.y);  
    }  

    void display() const {  
        std::cout << "Point(" << x << ", " << y << ")" << std::endl;  
    }  
};  

int main() {  
    Point p1(3, 4);  
    Point p2(3, 4);  
    Point p3(4, 5);  

    if (p1 == p2) {  
        std::cout << "p1 is equal to p2" << std::endl; // 输出  
    }  
    if (p1 == p3) {  
        std::cout << "p1 is equal to p3" << std::endl;  
    } else {  
        std::cout << "p1 is not equal to p3" << std::endl; // 输出  
    }  
    return 0;  
}

2.4 重载下标运算符 []

重载下标运算符以访问对象中的元素。以下示例中会使用下标运算符访问动态数组类型。

#include <iostream>  
#include <vector>  

class IntArray {  
private:  
    std::vector<int> arr;  
public:  
    IntArray(int size) : arr(size) {}  

    // 重载 [] 操作符（返回引用，允许修改数组元素）  
    int& operator[](int index) {  
        return arr[index];  
    }  

    const int& operator[](int index) const {  
        return arr[index];  
    }  
};  

int main() {  
    IntArray arr(5);  
    arr[0] = 10;  
    arr[1] = 20;  
    std::cout << arr[0] << ", " << arr[1] << std::endl; // 输出 10, 20  
    return 0;  
}

3. 重载操作符的最佳实践

• 清晰设计：操作符重载应符合用户的直觉，确保重载后使用方式符合原始操作符的语义。
• 避免副作用：避免在操作符重载中创造副作用，尤其是对于算术操作符，应该保持数据的一致性。
• 保持一致性：如果重载了一个操作符，尽量在同一类中重载相关的操作符。
• 保持简单：操作符的实现应尽可能简单，确保代码可读性。