1. class Age     
2. {     
3. public:     
4.     
5.     Age& operator++() //前置++     
6.     {     
7.         ++i;     
8.         return *this;     
9.     }     
10.     
11.     const Age operator++(int) //后置++     
12.    {     
13.         Age tmp = *this;     
14.         ++(*this);  //利用前置++     
15.         return tmp;     
16.     }     
17.     
18.     Age& operator=(int i) //赋值操作     
19.     {     
20.         this->i = i;     
21.         return *this;     
22.     }     
23.     
24. private:     
25.     int i;     
26. }; 

       ++i的实现原理是现将i自增1，然后返回i的引用；j++的实现原理是：先定义一个j的副本，然后在将j自增1，最后返回之前定义个那个副本的值。

      通常，c++的内置类型都要求前缀式操作符返回被增量或被减量对象的引用；而要求后缀式操作符返回被增量和被减量对象做增或减操作之前的副本(这里边就存在内存拷贝)。

1. int main()     
2. {     
3.     Age a;     
4.     
5.     (a++)++;  //编译错误     
6.     ++(a++);  //编译错误     
7.     a++ = 1;   //编译错误     
8.     (++a)++;  //OK     
9.     ++(++a);  //OK     
10.     ++a = 1;   //OK     
11. } 

a++的类型是const XX ，自然不能对它进行前置++、后置++、赋值等操作。

++a的类型是XX &，当然可以对它进行前置++、后置++、赋值等操作

2：如何进行重载呢？如何区别？
      一般要求后缀式操作符接受一个额外的int型形参(不会使用它，仅做区分用)，来区别两者的不同
例如：

class A 

{

    private:


          int a;

    public:

           A& operator++() 

    {

      ++a;
                                    //直接进行++并且返回其引用

                  return *this;         //前置++
           //...


    }

           A  operator++(int) 

    {   

                   A a = *this;                    //先做一个副本

                   ++*this; 
                       //对其本身进行++的操作

                   return a;                      //后置++
          //...

    }


}

3:优先使用前置++

    

   很明显tmp是一个临时对象。会造成一次析构函数和一次构造函数的产生的额外开销。虽然编译器可以进行优化，但是我们最好不要依赖于编译的优化，自己去简化。