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

今天在阅读《google c++ 编程风格》的文档的时候,5.10. 前置自增和自减:有一句话引起了我的注意:

对于迭代器和其他模板对象使用前缀形式 (++i) 的自增, 自减运算符.,理由是 前置自增 (++i) 通常要比后置自增 (i++) 效率更高。于是我查了查前置++和后置++的区别

注意:《more effective c++》条款8也专门叙述了问题。后来我发现,下面的文章基本就是它的翻版,哈哈

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

  1. int a = 0;  
  2. ++ a;   //前置++  
  3. a++;    //后置++  

《C专家编程》中有如下描述(P276,人民邮电出版社):

++a表示取a的地址,增加它的内容,然后把值放在寄存器中;

a++表示取a的地址,把它的值装入寄存器,然后增加内存中的a的值;


另外,网上找了篇文章,通过从运算符重载的角度来探讨他们的不同,如下:

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

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

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

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

返回值类型的区别

前置++的返回类型是Age&,后置++的返回类型const Age。这意味着,前置++返回的是左值,后置++返回的是右值。(关于左值和右值的讨论很多,见本文下面)

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

  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. }    

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

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

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

有两个原因:

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

a++的返回类型如果改成非const对象,肯定能通过编译,但是我们最好不要这样做。

 

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

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

 

形参的区别

前置++没有形参,而后置++有一个int形参,但是该形参也没有被用到。很奇怪,难道有什么特殊的用意?

其实也没有特殊的用意,只是为了绕过语法的限制

 

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

虽然前置++与后置++的返回类型不同,但是返回类型不属于函数原型。为了绕过语法限制,只好给后置++增加了一个int形参。

 

原因就是这么简单,真的没其他特殊用意。其实,给前置++增加形参也可以;增加一个double形参而不是int形参,也可以。只是,当时就这么决定了。

 

代码实现的区别

前置++的实现比较简单,自增之后,将*this返回即可。需要注意的是,一定要返回*this。

后置++的实现稍微麻烦一些。因为要返回自增之前的对象,所以先将对象拷贝一份,再进行自增,最后返回那个拷贝。

 

在Age的代码中,后置++利用了前置++来实现自增。这样做是为了避免“自增的代码”重复。

在本例中,自增的代码很简单,就是一行++i,没有必要这样做。但是在其它自增逻辑复杂的例子中,这么做还是很有必要的。

 

效率的区别

如果不需要返回自增之前的值,那么前置++和后置++的计算效果都一样。但是,我们仍然应该优先使用前置++,尤其是对于用户自定义类型的自增操作。

前置++的效率更高,理由是:后置++会生成临时对象。

 

从Age的后置++的代码实现也可以看出这一点。

  1. const Age operator++(int//后置++     
  2. {     
  3.     Age tmp = *this;     
  4.     ++(*this);  //利用前置++     
  5.     return tmp;     
  6. }    

很明显,tmp是一个临时对象,会造成一次构造函数和一次析构函数的额外开销。虽然,编译器在某些情况下可以优化掉这些开销。但是,我们最好不要依赖编译器的行为。


所以,在非内置类型的时候,尽量使用前置++,因为效率高(后置自增,效率低)
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

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

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭