前置++和后置++的区别

重载++的过程

假设有一个类Age，描述年龄。该类重载了前置++和后置++两个操作符，以实现对年龄的自增。

class Age   
{   
public:   
  
    Age& operator++() //前置++   
    {   
        ++i;   
        return *this;   
    }   
  
    const Age operator++(int) //后置++   
{   
        Age tmp = *this;   
        ++(*this);  //利用前置++   
        return tmp;   
    }   
  
    Age& operator=(int i) //赋值操作   
    {   
        this->i = i;   
        return *this;   
    }   
  
private:   
    int i;   
}; 

从上述代码，我们可以看出前置++和后置++，有3点不同：

1. 返回类型不同
2. 形参不同
3. 效率不同

返回类型不同

前置++的返回类型是Age&，后置++的返回类型const Age。这意味着，前置++返回的是左值，后置++返回的是右值。

左值和右值，决定了前置++和后置++的用法。

int main()   
{   
    Age a;   
  
    (a++)++;  //编译错误   
    ++(a++);  //编译错误   
    a++ = 1;   //编译错误   
    (++a)++;  //OK   
    ++(++a);  //OK   
    ++a = 1;   //OK   
}  

• ++的类型是const Age，自然不能对它进行前置++、后置++、赋值等操作。
• ++a的类型是Age&，当然可以对它进行前置++、后置++、赋值等操作

a++的返回类型为什么要是const对象呢？

1. 如果不是const对象，a(++)++这样的表达式就可以通过编译。但是，其效果却违反了我们的直觉。a其实只增加了1，因为第二次自增作用在一个临时对象上。
2. 另外，对于内置类型，(i++)++这样的表达式是不能通过编译的。自定义类型的操作符重载，应该与内置类型保持行为一致。

++a的返回类型为什么是引用呢？

1. 这样做的原因应该就是：与内置类型的行为保持一致。前置++返回的总是被自增的对象本身。因此，++(++a)的效果就是a被自增两次。

形参不同

前置++没有形参，而后置++有一个int形参，这是为了绕过语法的限制。

前置++与后置++的操作符重载函数，函数原型必须不同，否则就违反了重载函数必须拥有不同的函数原型的语法规定。

效率不同

前置++的效率更高，理由是：后置++会生成临时对象，会造成一次构造函数和一次析构函数的额外开销。