C++ 运算符重载：自定义类型的运算操作

1. 什么是C++运算符重载

理解运算符重载是C++中的一个强大特性，允许为自定义类型（类或结构体）重新定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象像基本数据类型一样使用熟悉的运算符进行操作。

检查运算符重载的本质是通过特殊函数实现的，这些函数以operator关键字开头，后跟要重载的运算符符号。例如，要重载加法运算符+，我们需要定义一个名为operator+的函数。

注意并非所有运算符都可以重载。不可重载的运算符包括：.、::、.*、?:和sizeof等。

2. 为什么需要运算符重载

增强代码的可读性和直观性：当自定义类型需要进行运算操作时，运算符重载可以让代码表达更自然，而不是调用特殊的命名函数。

简化复杂操作：对于数学类、矩阵类或字符串类等，运算符重载可以大大简化代码，使复杂操作变得直观明了。

提高代码一致性：遵循内置类型的使用习惯，使自定义类型的接口与语言原生类型保持一致。

3. 基本运算符重载规则

遵循以下基本规则来重载运算符：

1. 确定要重载的运算符：大多数运算符都可以重载，但有一些限制。
2. 定义运算符函数：语法为返回类型 operator 运算符(参数列表)。
3. 区分成员函数和非成员函数：某些运算符必须重载为成员函数（如=、()、[]、->等），其他可以是成员函数或非成员函数。

记住运算符重载不会改变运算符的优先级和结合性。

4. 常见运算符重载示例

4.1 算术运算符重载

实现一个简单的复数类，并重载加法运算符：

class Complex {
private:
    double real;
    double imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 重载加法运算符作为成员函数
    Complex operator+(const Complex& other) {
        return Complex(real + other.real, imag + other.imag);
    }

    // 重载加法运算符作为非成员函数
    friend Complex operator-(const Complex& c1, const Complex& c2);
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
};

// 非成员函数实现减法运算符
Complex operator-(const Complex& c1, const Complex& c2) {
    return Complex(c1.real - c2.real, c1.imag - c2.imag);
}

// 重载<<运算符以便输出
std::ostream& operator<<(std::ostream& os, const Complex& c) {
    os << c.real << " + " << c.imag << "i";
    return os;
}

使用上述重载的运算符：

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);

    Complex c3 = c1 + c2;  // 使用重载的+运算符
    Complex c4 = c1 - c2;  // 使用重载的-运算符

    std::cout << "c3 = " << c3 << std::endl;  // 输出: c3 = 4 + 6i
    std::cout << "c4 = " << c4 << std::endl;  // 输出: c4 = 2 + 2i

    return 0;
}

4.2 比较运算符重载

实现一个Person类并重载比较运算符：

class Person {
private:
    std::string name;
    int age;

public:
    Person(std::string n, int a) : name(n), age(a) {}

    // 重载相等运算符
    bool operator==(const Person& other) const {
        return name == other.name && age == other.age;
    }

    // 重载小于运算符
    bool operator<(const Person& other) const {
        return age < other.age;
    }
};

使用上述重载的运算符：

int main() {
    Person p1("Alice", 30);
    Person p2("Bob", 25);
    Person p3("Alice", 30);

    if (p1 == p3) {
        std::cout << "p1和p3是同一个人" << std::endl;
    }

    if (p2 < p1) {
        std::cout << "p2比p1年轻" << std::endl;
    }

    return 0;
}

4.3 赋值运算符重载

注意赋值运算符(=)通常需要重载为成员函数。对于需要深拷贝的自定义类，必须重载赋值运算符。

class DynamicArray {
private:
    int* data;
    size_t size;

public:
    DynamicArray(size_t s = 0) : size(s) {
        data = new int[size];
    }

    // 析构函数
    ~DynamicArray() {
        delete[] data;
    }

    // 拷贝构造函数
    DynamicArray(const DynamicArray& other) : size(other.size) {
        data = new int[size];
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    // 赋值运算符重载
    DynamicArray& operator=(const DynamicArray& other) {
        if (this != &other) {  // 防止自赋值
            delete[] data;     // 释放原有资源
            size = other.size;
            data = new int[size];
            for (size_t i = 0; i < size; ++i) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }
};

4.4 下标运算符重载

实现一个安全的数组类，重载下标运算符：

class SafeArray {
private:
    int* data;
    size_t size;

public:
    SafeArray(size_t s) : size(s) {
        data = new int[size];
    }

    ~SafeArray() {
        delete[] data;
    }

    // 重载const版本的下标运算符
    const int& operator[](size_t index) const {
        // 检查索引是否越界
        if (index >= size) {
            throw std::out_of_range("索引超出范围");
        }
        return data[index];
    }

    // 重载非const版本的下标运算符
    int& operator[](size_t index) {
        // 检查索引是否越界
        if (index >= size) {
            throw std::out_of_range("索引超出范围");
        }
        return data[index];
    }
};

5. 运算符重载的高级用法

5.1 一元运算符重载

实现一个Counter类，重载自增运算符：

class Counter {
private:
    int count;

public:
    Counter(int c = 0) : count(c) {}

    // 前置++运算符
    Counter& operator++() {
        ++count;
        return *this;
    }

    // 后置++运算符
    Counter operator++(int) {
        Counter temp = *this;
        ++count;
        return temp;
    }

    int getCount() const {
        return count;
    }
};

区分前置和后置运算符：后置运算符有一个额外的int参数（这个参数没有实际用途，仅用于区分前置和后置版本）。

5.2 类型转换运算符重载

实现一个可以转换为int的类：

class Convertible {
private:
    int value;

public:
    Convertible(int v = 0) : value(v) {}

    // 重载类型转换运算符
    operator int() const {
        return value;
    }
};

int main() {
    Convertible c(42);
    int x = c;  // 隐式调用operator int()
    std::cout << x << std::endl;  // 输出: 42

    return 0;
}

注意类型转换运算符没有返回类型，语法为operator 目标类型() const。

5.3 函数调用运算符重载

实现一个可调用对象（函数对象）：

class Multiplier {
private:
    int factor;

public:
    Multiplier(int f) : factor(f) {}

    // 重载函数调用运算符
    int operator()(int x) const {
        return x * factor;
    }
};

int main() {
    Multiplier times2(2);  // 创建一个乘以2的函数对象
    Multiplier times3(3);  // 创建一个乘以3的函数对象

    std::cout << times2(5) << std::endl;  // 输出: 10
    std::cout << times3(5) << std::endl;  // 输出: 15

    return 0;
}

5.4 运算符重载的链式调用

实现可以链式调用的运算符：

class StringBuilder {
private:
    std::string str;

public:
    StringBuilder(const std::string& s = "") : str(s) {}

    // 返回引用以支持链式调用
    StringBuilder& operator+=(const std::string& other) {
        str += other;
        return *this;
    }

    std::string toString() const {
        return str;
    }
};

int main() {
    StringBuilder sb;
    sb += "Hello";
    sb += " ";
    sb += "World";

    std::cout << sb.toString() << std::endl;  // 输出: Hello World

    return 0;
}

6. 注意事项和最佳实践

1. 保持运算符的自然语义：重载运算符时，确保其行为与运算符在基本类型上的使用方式一致，避免造成混淆。

2. 提供对称的运算符：如果重载了+，通常也应该重载+=；如果重载了==，通常也应该重载!=。

3. 考虑运算符的效率：特别是对于复杂对象，注意运算符的实现效率，避免不必要的拷贝。

4. 小心运算符的副作用：某些运算符（如++和--）有前置和后置版本，确保实现正确。

5. 遵循const正确性：对于不会修改对象状态的运算符，应该标记为const。

6. 优先使用非成员函数：对于二元运算符，当左侧操作数不是类的类型时，通常需要将其重载为非成员函数。

7. 注意自增/自减运算符的实现：前置版本返回引用，后置版本返回原值的拷贝。

8. 考虑异常安全：在重载运算符时，特别是涉及到资源管理的运算符，要确保异常安全性。

9. 避免过度使用运算符重载：只有当运算符确实能增强代码可读性时才使用，不要为了重载而重载。

10. 测试边界情况：特别测试运算符重载在极端条件下的行为，如自赋值、空指针等。