为什么说++i的效率比i++高？

骑猪看日落 2023-08-17 16:24 127阅读 0赞

来源：公众号【编程珠玑】

作者：守望先生

网站：[https://www.yanbinghu.com/2019/09/09/58833.html][https_www.yanbinghu.com_2019_09_09_58833.html]

## 前言 ##

不知道你是否听说过++i比i++快的说法，真的如此吗？

## \++i与i++的区别 ##

这两个表达式从我们初学编程语言的时候就会接触到。**前者是自增后取值，后者是取值后自增**。  
我们看一个简单的例子。

#include <iostream>
    using namespace std;
    int main()
    {
        int a = 0;
        int b = 0;
        int c = a++;//int tmp = a;c=a;a = a + 1
        int d = ++b;//b = b + 1;d = b;
        cout<<"c="<<c<<";d="<<d<<endl;
        return 0;
    }

运行结果：

c=0;d=1

对于这个结果我们并不感到意外。

另外我们还注意到另外一个有意思的现象：

//来源：公众号【编程珠玑】地址：https://www.yanbinghu.com
    #include <iostream>
    using namespace std;
    int main()
    {
        int a = 0;
        int b = 0;
        int *c = &(a++);
        int *d = &(++b);
        return 0;
    }

编译后报错：

main.cpp:7:19: error: lvalue required as unary ‘&’ operand
         int *c = &(a++);

说&作用于左值，也就是说a++的结果并非左值。但++b的结果是左值。

可简单理解左值和右值：

*  左值，有名对象，可赋值
 *  右值，临时对象，不可被赋值

## 运算符重载 ##

在《[运算符重载][Link 1]》一文中已经说到了运算符的重载，通过前面的例子也发现了，对于内置类型，前置自增返回对象的引用，而后置自增返回对象的原值（但非左值）。  
基于上述原则，一个前置版本和后置版本的常见实现如下：

//来源：公众号【编程珠玑】地址：https://www.yanbinghu.com
    class Test
    {
    public:
        Test& operator++();//前置自增
        const Test operator++(int);//后置自增
    private:
        int curPos; //当前位置
    };
    /*前置自增实现范式*/
    Test& Test::operator++()
    {
        ++curPos;      //自增
        return *this;  //取值
    }
    /*后置自增实现范式，为了与前置区分开，多了一个int参数，但从来没用过*/
    const Test Test::operator++(int)
    {
        Test tmp = *this;  //取值
        ++curPos;             //自增
        return tmp;
    }

仔细观察后，我们发现前置自增，先自增，后返回原对象的对象；没有产生任何临时对象；而后置自增，先保存原对象，然后自增，最后返回该原临时对象，那么它就需要创建和销毁，这样一来，效率孰高孰低就很清楚了。

在不进行赋值的情况下，内置类型前置和后置自增的汇编都是一样的呢！

void test()
    {
      int i = 0;
      i++;
      //++i;
    }

汇编:

push    rbp
    mov     rbp, rsp
    mov     DWORD PTR [rbp-4], 0
    add     DWORD PTR [rbp-4], 1
    nop
    pop     rbp
    ret

不过，**赋值的情况下，并且不开启编译器优化**，它们的汇编代码还是有差别的，有兴趣的可以试试。

## 总结 ##

对于内置类型，前置和后置自增或者自减在编译器优化的情况下，两者并无多大差别，而对于自定义类型，如无特别需要，人们似乎更加偏爱前置自增或自减，因为后置自增常常会产生临时对象。

但是，又能提高多少效率呢？

推荐阅读：

[什么是运算符的重载？][Link 1]

[一句话帮你理解typedef的用法][typedef]

[为什么建议你用nullptr而不是NULL？][nullptr_NULL]

[C++中是如何调用C接口的？][C_C]

关注公众号【编程珠玑】，获取更多Linux/C/C++/Python/Go/算法/工具等原创技术文章。后台免费获取经典电子书和视频资源

![format_png][]

[https_www.yanbinghu.com_2019_09_09_58833.html]: https://www.yanbinghu.com/2019/09/09/58833.html
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI2OTA3NTk3Ng==&mid=2649284949&idx=1&sn=6df7b044c6b2fab5983ec0b160de4756&chksm=f2f99232c58e1b24be3a16ee799289e4d024208193e547eb05aebaab6d1ff3763958e72a6caf&scene=21#wechat_redirect
[typedef]: http://mp.weixin.qq.com/s?__biz=MzI2OTA3NTk3Ng==&mid=2649284943&idx=1&sn=4a43a41b59dd0944180f38870b1c7c1a&chksm=f2f99228c58e1b3e0457db989841a760d421a7fc947630646d720f47483cfbf14a7e5f9c23ca&scene=21#wechat_redirect
[nullptr_NULL]: http://mp.weixin.qq.com/s?__biz=MzI2OTA3NTk3Ng==&mid=2649284913&idx=1&sn=9dd45f361cf7c0bcb8239e3df96f7823&chksm=f2f99256c58e1b408c6386448d08fdf22d62d024c653d48901e4b06414599d177b1939f7f6f0&scene=21#wechat_redirect
[C_C]: http://mp.weixin.qq.com/s?__biz=MzI2OTA3NTk3Ng==&mid=2649284921&idx=1&sn=0c82a8350c51a6ad8b7c5d4572c70557&chksm=f2f9925ec58e1b48d74f554875d6be5fc917c1f4a1278aace8564e162e1273ec98c04bde5e51&scene=21#wechat_redirect
[format_png]: /images/20230810/ffbbbf532f3846948e3bc065498c0c6c.png