C++运算符重载全面总结

C++运算符重载全面总结

运算符重载是C++中一项强大的特性，它允许程序员为自定义类型定义运算符的行为。以下是关于C++运算符重载的详细总结：

一、基本概念

1. 什么是运算符重载

运算符重载是指为自定义类型（类或结构体）重新定义或重载已有的运算符，使其能够操作该类型的对象。

2. 运算符重载的限制

• 不能创建新的运算符
• 不能改变运算符的优先级和结合性
• 不能改变运算符的操作数个数
• 部分运算符不能被重载（如::, .*, ., ?:等）
• 重载运算符至少有一个操作数是用户定义类型

二、运算符重载的实现方式

1. 成员函数重载

运算符作为类的成员函数重载，隐含this指针作为第一个操作数。

class Complex {
public:
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
private:
    double real, imag;
};

2. 友元函数重载

运算符作为非成员函数重载，通常需要声明为友元以访问私有成员。

class Complex {
    friend Complex operator+(const Complex& a, const Complex& b);
};

Complex operator+(const Complex& a, const Complex& b) {
    return Complex(a.real + b.real, a.imag + b.imag);
}

3. 全局函数重载

对于不访问私有成员的运算符，可以直接定义为全局函数。

Point operator+(const Point& a, const Point& b) {
    return Point(a.x() + b.x(), a.y() + b.y());
}

三、可重载运算符分类

1. 算术运算符

+, -, *, /, %, +=, -=, *=, /=, %=

class Complex {
public:
    Complex& operator+=(const Complex& other) {
        real += other.real;
        imag += other.imag;
        return *this;
    }
};

2. 关系运算符

==, !=, <, >, <=, >=

bool operator==(const Point& a, const Point& b) {
    return a.x() == b.x() && a.y() == b.y();
}

3. 逻辑运算符

!, &&, ||

class Boolean {
public:
    bool operator!() const { return !value; }
};

4. 位运算符

&, |, ^, ~, <<, >>, &=, |=, ^=, <<=, >>=

class BitMask {
public:
    BitMask operator<<(int shift) const {
        return BitMask(mask << shift);
    }
};

5. 赋值运算符

=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=

class String {
public:
    String& operator=(const String& other) {
        // 实现深拷贝
        return *this;
    }
};

6. 递增递减运算符

++, --（前缀和后缀）

class Counter {
public:
    // 前缀++
    Counter& operator++() {
        ++count;
        return *this;
    }
    
    // 后缀++
    Counter operator++(int) {
        Counter temp = *this;
        ++count;
        return temp;
    }
};

7. 下标运算符

[]

class Array {
public:
    int& operator[](size_t index) {
        return data[index];
    }
    
    const int& operator[](size_t index) const {
        return data[index];
    }
};

8. 函数调用运算符

()

class Functor {
public:
    int operator()(int x, int y) {
        return x + y;
    }
};

9. 成员访问运算符

->, ->*

class SmartPtr {
public:
    T* operator->() const {
        return ptr;
    }
};

10. 类型转换运算符

operator type()

class Rational {
public:
    operator double() const {
        return static_cast<double>(numerator) / denominator;
    }
};

11. 内存管理运算符

new, new[], delete, delete[]

class MemoryPool {
public:
    void* operator new(size_t size) {
        return pool.allocate(size);
    }
    
    void operator delete(void* p) {
        pool.deallocate(p);
    }
};

四、特殊运算符重载注意事项

1. 输入输出运算符

<<, >> 通常应作为友元函数重载

class Complex {
    friend ostream& operator<<(ostream& os, const Complex& c);
    friend istream& operator>>(istream& is, Complex& c);
};

ostream& operator<<(ostream& os, const Complex& c) {
    return os << c.real << "+" << c.imag << "i";
}

2. 赋值运算符

• 应返回*this的引用以支持链式赋值
• 需要处理自赋值情况
• 通常需要实现拷贝赋值和移动赋值

class String {
public:
    String& operator=(const String& other) {
        if (this != &other) {
            // 实现深拷贝
        }
        return *this;
    }
    
    String& operator=(String&& other) noexcept {
        // 实现移动语义
        return *this;
    }
};

3. 类型转换运算符

• 可以声明为explicit防止隐式转换
• 应谨慎使用以避免意外的类型转换

class SafeBool {
public:
    explicit operator bool() const { return valid; }
};

五、运算符重载的最佳实践

1. 保持直观性：重载的运算符行为应与内置类型相似
2. 一致性：相关运算符应一起重载（如==和!=，<和>等）
3. 避免过度重载：只为有意义的操作重载运算符
4. 考虑对称性：对于二元运算符，考虑是否需要支持交换操作数的顺序
5. 性能考虑：尽可能使用引用和移动语义提高效率
6. 异常安全：确保运算符重载是异常安全的

六、运算符重载示例

完整示例：复数类

class Complex {
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    
    // 成员函数重载
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    
    Complex& operator+=(const Complex& other) {
        real += other.real;
        imag += other.imag;
        return *this;
    }
    
    // 前缀++
    Complex& operator++() {
        ++real;
        return *this;
    }
    
    // 后缀++
    Complex operator++(int) {
        Complex temp = *this;
        ++real;
        return temp;
    }
    
    // 友元函数重载
    friend Complex operator-(const Complex& a, const Complex& b);
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
    
    // 比较运算符
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }
    
    bool operator!=(const Complex& other) const {
        return !(*this == other);
    }
    
private:
    double real, imag;
};

// 非成员函数实现
Complex operator-(const Complex& a, const Complex& b) {
    return Complex(a.real - b.real, a.imag - b.imag);
}

std::ostream& operator<<(std::ostream& os, const Complex& c) {
    os << c.real << (c.imag >= 0 ? "+" : "") << c.imag << "i";
    return os;
}

七、C++20新增特性

1. 三路比较运算符 <=>

C++20引入了三路比较运算符，可以简化比较运算符的实现：

class Point {
public:
    auto operator<=>(const Point&) const = default;
    // 自动生成 ==, !=, <, <=, >, >=
};

2. 重载co_await

C++20协程支持重载co_await运算符。

总结

运算符重载是C++中实现自定义类型行为一致性的重要手段。合理使用运算符重载可以使代码更直观、更易读。但同时也要注意不要滥用，确保重载的运算符行为符合直觉，并遵循语言惯例。