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++; // 调用后置版本，c2 为 6，c 变为 7
    c2.show();
    c.show();
    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 << "c2 = " << c2 << endl;
    cout << "c1 + c2 = " << c1 + c2 << endl;
    cout << "c1 - c2 = " << c1 - c2 << endl;
    cout << "c1 * c2 = " << c1 * c2 << endl;
    return 0;
}

运行结果如下：

c1 = 3 + 4i
c2 = 1 - 2i
c1 + c2 = 4 + 2i
c1 - c2 = 2 + 6i
c1 * c2 = 11 - 2i

开发规范建议

1. 语义一致：重载后的行为应与内置类型语义相近，避免误导使用者。
2. 优先成员函数：一元运算符及复合赋值运算符（+= 等）优先用成员函数。
3. IO 用全局友元：<< 和 >> 必须用全局函数配合友元。
4. 深拷贝处理：含指针成员的类必须手动重载 =。
5. 适度重载：只重载实际需要的运算符，避免过度设计增加复杂度。

合理使用运算符重载能显著提升代码的可读性与扩展性，是 C++ 面向对象编程中不可或缺的技能。