C++中递增运算符重载的实现示例

// 类内声明
类名& operator++();

// 类外定义
类名& 类名::operator++() {
    // 1. 修改对象内部状态（如数值+1）
    // 2. 返回自身引用（*this）
    return *this;
}

// 类内声明（int是占位符，无实际意义，仅用于区分前置）
类名 operator++(int);

// 类外定义
类名 类名::operator++(int) {
    // 1. 保存当前对象的副本（临时对象）
    类名 temp = *this;
    // 2. 修改原对象状态
    // 3. 返回副本（原状态）
    return temp;
}

#include <iostream>
using namespace std;

class MyInt {
private:
    int val; // 封装的整数值
public:
    // 构造函数
    MyInt(int v = 0) : val(v) {}

    // 1. 重载前置递增（返回引用）
    MyInt& operator++() {
        val++; // 先加1
        return *this; // 返回自身，支持链式操作
    }

    // 2. 重载后置递增（int占位符，返回值）
    MyInt operator++(int) {
        MyInt temp = *this; // 保存当前值
        val++; // 后加1
        return temp; // 返回原状态
    }

    // 辅助：输出重载（方便打印）
    friend ostream& operator<<(ostream& os, const MyInt& mi) {
        os << mi.val;
        return os;
    }
};

int main() {
    MyInt a(5);

    // 前置递增：先加1，再使用
    cout << "++a = " << ++a << endl; // 输出：++a = 6
    cout << "a = " << a << endl;     // 输出：a = 6

    // 后置递增：先使用，再加1
    cout << "a++ = " << a++ << endl; // 输出：a++ = 6
    cout << "a = " << a << endl;     // 输出：a = 7

    // 前置支持链式操作
    MyInt b(10);
    cout << "++(++b) = " << ++(++b) << endl; // 输出：++(++b) = 12

    return 0;
}

#include <iostream>
using namespace std;

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

    // 前置递增：实部、虚部都+1，返回引用
    Complex& operator++() {
        real++;
        imag++;
        return *this;
    }

    // 后置递增：返回原状态，再修改
    Complex operator++(int) {
        Complex temp = *this;
        real++;
        imag++;
        return temp;
    }

    // 输出重载
    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << real << " + " << imag << "i";
        return os;
    }
};

int main() {
    Complex c(1.5, 2.5);

    cout << "++c = " << ++c << endl;  // 输出：++c = 2.5 + 3.5i
    cout << "c++ = " << c++ << endl;  // 输出：c++ = 2.5 + 3.5i
    cout << "c = " << c << endl;      // 输出：c = 3.5 + 4.5i

    return 0;
}

#include <iostream>
using namespace std;

class MyInt {
private:
    int val;
public:
    MyInt(int v = 0) : val(v) {}

    // 声明友元：前置递增
    friend MyInt& operator++(MyInt& mi);
    // 声明友元：后置递增
    friend MyInt operator++(MyInt& mi, int);

    friend ostream& operator<<(ostream& os, const MyInt& mi) {
        os << mi.val;
        return os;
    }
};

// 全局定义前置递增
MyInt& operator++(MyInt& mi) {
    mi.val++;
    return mi;
}

// 全局定义后置递增
MyInt operator++(MyInt& mi, int) {
    MyInt temp = mi;
    mi.val++;
    return temp;
}

int main() {
    MyInt a(5);
    cout << ++a << endl; // 6
    cout << a++ << endl; // 6
    cout << a << endl;   // 7
    return 0;
}

MyInt& operator++() {
    *this += 1; // 复用 += 逻辑
    return *this;
}

// 前置递减
MyInt& operator--() {
    val--;
    return *this;
}

// 后置递减
MyInt operator--(int) {
    MyInt temp = *this;
    val--;
    return temp;
}