运算符重载 - 自定义运算符行为

引言

C++ 是一种支持面向对象编程（OOP）的编程语言，它允许程序员通过运算符重载来自定义类的行为。运算符重载使得我们可以为自定义类型定义与内置类型相似的操作方式，从而使代码更加直观和易读。

本文将详细介绍 C++ 中的运算符重载机制，包括常见的运算符、重载方法以及注意事项，帮助读者理解并掌握这一强大的特性。

1. 什么是运算符重载？

运算符重载是指为已有的运算符赋予新的含义，使其能够操作用户自定义的数据类型（如类或结构体）。通过运算符重载，我们可以让自定义类型像内置类型一样使用标准运算符，从而提高代码的可读性和简洁性。

例如，假设我们有一个复数类 Complex，我们可以通过运算符重载来实现复数之间的加法、减法等操作：

class Complex {
private:
    double real;
    double imag;

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

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

    // 减法运算符重载
    Complex operator-(const Complex& other) const {
        return Complex(real - other.real, imag - other.imag);
    }

    // 打印函数
    void print() const {
        std::cout << "(" << real << ", " << imag << "i)" << std::endl;
    }
};

int main() {
    Complex c1(3, 4);
    Complex c2(1, 2);

    Complex sum = c1 + c2;
    Complex diff = c1 - c2;

    sum.print();  // 输出: (4, 6i)
    diff.print(); // 输出: (2, 2i)

    return 0;
}

在这个例子中，我们为 Complex 类重载了加法运算符 + 和减法运算符 -，使得我们可以像操作内置类型一样对复数进行加减运算。

2. 常见的运算符重载

C++ 支持多种运算符的重载，以下是一些常见的运算符及其重载方法：

2.1 算术运算符

加法 (+)：用于两个对象相加。
减法 (-)：用于两个对象相减。
乘法 (*)：用于两个对象相乘。
除法 (/)：用于两个对象相除。
取模 (%)：用于两个对象取模（通常用于整数类型）。

class Vector {
private:
    double x, y, z;

public:
    Vector(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}

    // 加法运算符重载
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y, z + other.z);
    }

    // 其他算术运算符可以类似地重载...
};

2.2 关系运算符

等于 (==)：用于比较两个对象是否相等。
不等于 (!=)：用于比较两个对象是否不相等。
小于 (<)：用于比较两个对象的大小。
大于 (>)：用于比较两个对象的大小。
小于等于 (<=)：用于比较两个对象的大小。
大于等于 (>=)：用于比较两个对象的大小。

class Point {
private:
    double x, y;

public:
    Point(double x = 0, double y = 0) : x(x), y(y) {}

    // 等于运算符重载
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }

    // 不等于运算符重载
    bool operator!=(const Point& other) const {
        return !(*this == other);
    }

    // 其他关系运算符可以类似地重载...
};

2.3 赋值运算符

赋值 (=)：用于将一个对象的值赋给另一个对象。

class String {
private:
    char* data;

public:
    String(const char* str = "") {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    // 赋值运算符重载
    String& operator=(const String& other) {
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }

    ~String() {
        delete[] data;
    }
};

2.4 输入输出运算符

输入 (>>)：用于从输入流读取数据。
输出 (<<)：用于向输出流写入数据。

class Date {
private:
    int year, month, day;

public:
    Date(int y = 0, int m = 0, int d = 0) : year(y), month(m), day(d) {}

    // 输出运算符重载
    friend std::ostream& operator<<(std::ostream& os, const Date& date) {
        os << date.year << "-" << date.month << "-" << date.day;
        return os;
    }

    // 输入运算符重载
    friend std::istream& operator>>(std::istream& is, Date& date) {
        is >> date.year >> date.month >> date.day;
        return is;
    }
};

int main() {
    Date today;
    std::cin >> today;  // 输入日期
    std::cout << today << std::endl;  // 输出日期
    return 0;
}

2.5 下标运算符

下标 ([])：用于访问数组或容器中的元素。

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

public:
    Array(size_t sz) : size(sz) {
        data = new int[size];
    }

    // 下标运算符重载
    int& operator[](size_t index) {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    const int& operator[](size_t index) const {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    ~Array() {
        delete[] data;
    }
};

int main() {
    Array arr(5);
    arr[0] = 10;
    arr[1] = 20;
    std::cout << arr[0] << " " << arr[1] << std::endl;
    return 0;
}