C++ 运算符重载：自定义类型运算扩展

若采用全局函数重载，则需配合友元声明来访问私有数据，调用时等价于 operator+(p1, p2)。

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

前置 ++ 先自增再使用，重载时无参数；后置 ++ 先使用再自增，需要添加一个 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;      // 调用 operator++()
    c.show(); // 输出 6
    return 0;
}

关系与输入输出运算符

关系运算符（如 ==）通常用于比较逻辑。而 << 和 >> 由于左侧操作数是流对象，必须使用全局函数加友元的方式重载，以便支持链式调用。

#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;
    cin >> p;
    cout << p << endl;
    return 0;
}

限制条件与开发规范

并非所有运算符都能随意重载。以下符号禁止重载：.、.*、::、?:、#。同时，赋值运算符 =、函数调用 ()、下标 []、箭头 -> 必须通过成员函数重载。

在重载赋值运算符时，如果类包含指针成员，务必手动实现深拷贝，避免浅拷贝导致的内存泄漏。返回值必须是 *this 的引用，以支持链式赋值（如 a = b = c）。

#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;
    }

    void show() { cout << str << endl; }
};

实战案例：复数运算

设计一个 Complex 类，重载加减乘及输出运算符。这能综合检验对成员函数、友元函数及运算符优先级的理解。

#include <iostream>
using namespace std;

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

    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 + c2 = " << c1 + c2 << endl;
    cout << "c1 * c2 = " << c1 * c2 << endl;
    return 0;
}

运行结果会显示标准的复数运算格式。开发中应遵循语义一致原则，保持重载行为与内置类型相近，避免过度重载增加复杂度。合理使用运算符重载是 C++ 面向对象编程的重要技能。