前缀++与后缀++的重载

4.2 Item M6：自增(increment)、自减(decrement)操作符前缀形式与后缀形式的区别
不论是 increment 或 decrement 的前缀还是后缀都只有一个参数。为了解决这个语言问题，C++
规定后缀形式有一个 int 类型参数，当函数被调用时，编译器传递一个 0 做为 int 参数的值
给该函数

#include <iostream>

class UInt{
public:
    explicit UInt(int i = 0) : m_int(i) { }
    ~UInt() { }
    UInt(const UInt &rhs) : m_int(rhs.get()) { }

public:
    UInt &operator=(const UInt &rhs);

    //前缀形式返回一个引用，是一个左值
    //后缀形式返回一个const类型，是一个右值，亦即是不能被赋值
    UInt &operator++();
    const UInt operator++(int);
    UInt &operator--();
    const UInt operator--(int);
    UInt& operator+=(int);
    int get(void) const { return m_int; }
    void set(int i) { m_int = i; }
private:
    int m_int;
};

UInt operator +(const UInt &lhs, const UInt &rhs)
{
    UInt result;

    result.set(lhs.get() + rhs.get());

    return result;
}

UInt& UInt::operator =(const UInt &rhs)
{
    m_int = rhs.get();

    return *this;
}

//返回一个自身的引用，没有临时对象的代价，性能较高
UInt& UInt::operator ++()
{
    *this += 1;

    return *this;
}

//返回一个临时对象，增加了一个对象构造和析构的代价，性能较低
//由此可见，对于用户自定义类型，应该尽量使用前缀的increment
const UInt UInt::operator ++(int)
{
    UInt oldVal = *this;

    ++(*this);

    return oldVal;
}

UInt& UInt::operator --()
{
    *this += (-1);
    
    return *this;
}

const UInt UInt::operator --(int)
{
    UInt oldVal = *this;

    --(*this);

    return oldVal;
}

UInt& UInt::operator +=(int val)
{
    m_int += val;

    return *this;
}

int main(void)
{
    std::cout << "Hello World!" << std::endl;

    UInt u1(2);
    UInt u2(2);

    //Output 2
    std::cout << "u1++ return " << (u1++).get() << std::endl;
    //Output 3
    std::cout << "++u2 return " << (++u2).get() << std::endl;

    //Output 3
    std::cout << u1.get() << std::endl;
    //Output 3
    std::cout << u2.get() << std::endl;

    return 0;
}