C++ 运算符重载：让自定义类型支持自然运算

全局函数重载

全局函数重载通常用于需要访问私有成员，或者左侧操作数不是当前类对象的情况（如输入输出流）。此时需要声明为友元函数。

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;
    Point(int x = 0, int y = 0) : x(x), y(y) {}
    
    void print() {
        cout << "(" << x << ", " << y << ")" << endl;
    }
    
    // 声明友元函数
    friend Point operator+(const Point& p1, const Point& p2);
};

// 全局函数重载 + 运算符
Point operator+(const Point& p1, const Point& p2) {
    return Point(p1.x + p2.x, p1.y + p2.y);
}

int main() {
    Point p1(1, 2), p2(3, 4);
    Point p3 = p1 + p2; // 等价于 operator+(p1, p2)
    p3.print();
    return 0;
}

常见运算符的重载实战

一元运算符：前置与后置 ++

前置 ++ 先自增后使用，后置 ++ 先使用后自增。区别在于后置版本需要一个 int 占位参数来区分。

#include <iostream>
using namespace std;

class Counter {
private:
    int count;
public:
    Counter(int c = 0) : count(c) {}
    
    // 前置 ++
    Counter& operator++() {
        this->count++;
        return *this; // 返回引用支持链式操作
    }
    
    // 后置 ++
    Counter operator++(int) {
        Counter temp = *this;
        this->count++;
        return temp; // 返回旧值
    }
    
    void show() {
        cout << "计数：" << count << endl;
    }
};

int main() {
    Counter c(5);
    ++c;      // 调用前置版本
    c.show(); // 输出 6
    
    Counter c2 = c++; // 调用后置版本
    c.show();         // 输出 7
    c2.show();        // 输出 6
    return 0;
}

关系运算符：== 与 !=

关系运算符通常用于比较逻辑，建议返回布尔值。

#include <iostream>
#include <string>
using namespace std;

class Student {
private:
    string name;
    int id;
public:
    Student(string name, int id) : name(name), id(id) {}
    
    bool operator==(const Student& s) {
        return this->id == s.id;
    }
    
    string getName() { return name; }
};

int main() {
    Student s1("张三", 2024001);
    Student s3("张三", 2024001);
    
    if (s1 == s3) {
        cout << s1.getName() << " 和 " << s3.getName() << " 是同一学生" << endl;
    }
    return 0;
}

输入输出运算符：<< 和 >>

由于左侧操作数是 ostream 或 istream 对象，必须使用全局函数 + 友元的方式。

#include <iostream>
#include <string>
using namespace std;

class Person {
private:
    string name;
    int age;
public:
    Person(string name = "", int age = 0) : name(name), age(age) {}
    
    friend ostream& operator<<(ostream& os, const Person& p);
    friend istream& operator>>(istream& is, Person& p);
};

ostream& operator<<(ostream& os, const Person& p) {
    os << "姓名：" << p.name << "，年龄：" << p.age;
    return os;
}

istream& operator>>(istream& is, Person& p) {
    is >> p.name >> p.age;
    return is;
}

int main() {
    Person p;
    cout << "请输入姓名和年龄：" << endl;
    cin >> p;
    cout << "你输入的信息：" << p << endl;
    return 0;
}

限制条件与开发规范

并非所有运算符都能重载。以下运算符禁止重载：

• 成员访问运算符：.
• 成员指针访问运算符：.*
• 作用域解析运算符：::
• 条件运算符：?:
• 预处理运算符：#

此外，有些运算符必须通过成员函数重载，例如赋值运算符 =、函数调用运算符 ()、下标运算符 [] 和箭头运算符 ->。

赋值运算符的特殊处理

编译器会自动生成默认的浅拷贝赋值运算符。如果类中包含指针成员，必须手动重载 = 实现深拷贝，否则会导致内存泄漏。

#include <iostream>
#include <cstring>
using namespace std;

class String {
private:
    char* str;
public:
    String(const char* s = "") {
        str = new char[strlen(s) + 1];
        strcpy(str, s);
    }
    
    ~String() {
        delete[] str;
    }
    
    // 重载赋值运算符，实现深拷贝
    String& operator=(const String& s) {
        if (this == &s) return *this; // 防止自赋值
        delete[] str;
        str = new char[strlen(s.str) + 1];
        strcpy(str, s.str);
        return *this; // 返回引用支持链式赋值 a=b=c
    }
    
    void show() {
        cout << str << endl;
    }
};

int main() {
    String s1("Hello C++");
    String s2;
    s2 = s1;
    s2.show();
    return 0;
}

综合案例：复数运算

最后，我们通过一个完整的 Complex 类示例，综合运用加减乘及输出运算符。

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}
    
    Complex operator+(const Complex& c) {
        return Complex(this->real + c.real, this->imag + c.imag);
    }
    
    Complex operator-(const Complex& c) {
        return Complex(this->real - c.real, this->imag - c.imag);
    }
    
    Complex operator*(const Complex& c) {
        double r = this->real * c.real - this->imag * c.imag;
        double i = this->real * c.imag + this->imag * c.real;
        return Complex(r, i);
    }
    
    friend ostream& operator<<(ostream& os, const Complex& c);
};

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

int main() {
    Complex c1(3, 4), c2(1, -2);
    cout << "c1 = " << c1 << endl;
    cout << "c1 + c2 = " << c1 + c2 << endl;
    cout << "c1 * c2 = " << c1 * c2 << endl;
    return 0;
}

总结

运算符重载的核心在于语义一致性。重载后的行为应尽量贴近内置类型的直觉，避免过度设计增加复杂度。记住几个关键点：优先使用成员函数处理一元和复合赋值运算符；输入输出流必须用全局友元；包含指针的成员务必处理深拷贝。掌握了这些，你的 C++ 面向对象编程能力将上一个台阶。