for循环中--比++效率高？为什么呀？

Question

听说for循环中++与--的效率不一样？为什么呀？在哪里体现出来效率高低？

Answer 1

 理论来说 如果循环条件从某数 -- 到 0 结束的话 
比 从 0 ++ 到某数要快些 
从汇编可以看出来
里边是优化的 while 循环 
0 就断了循环
如果是 ++ 的话 就得 判断 是不是相等另外 据说  ++i/--i  比  i++/i-- 效率要高

Answer 2

你说的是for(int i = end - 1; i >= 0; i--)比for(int i = 0; i < end; i++)快吗？
和0比大小比和end比大小要快，但考虑程序可读性，通常没有必要写成--

Answer 3

不是和 0 比大小
而是判断是不是零
判断寄存器里的是不是0 是比比大小要快的
for(int i = end ; i > 0; i--)
到 0 就结束了
这样可以快些的
具体说实话我也是说不太清楚
有兴趣的话可以去查查资料

Answer 4

++i比i++效率高是C++里的问题，因为运行操作符重载，java无此问题。

Answer 5

有这回事？其实这些能提高的效率远不如你把
if写到for外面

Answer 6

哦 谢谢  貌似原来也听说过 Java 里没此问题 
没怎么深入去了解

Answer 7

++i的效率比i++要高，c++中确有这一说

Answer 8

个人感觉
for(int i = end ; i ！= 0; i--)
这样，才可能真的利用到“判断非0”比“判断某个数比另外某个数大（小）”来的快。是用！=做for的循环判断

Answer 9

你的感觉是不错
不过for循环在底层都是被优化成 while 的
所以就有了在某种情况下 -- 比 ++ 要快些的现象 

Answer 10

X86汇编里可以少一个指令，减完后可以直接使用jnz或jz来跳，不然就得先做一次cmp。
不过这个效率的话，2-3个时钟周期而已，现在的CPU每秒有 20-40亿个时钟……可以快一纳秒左右……

Answer 11

--i/++i是左操作数，只执行一次赋值操作，而i--/i++是右操作数，要执行二次操作，所以前者效率高

Answer 12

不要少见多怪，c/c++中全是这样,c++ primer中就是这么说的

Answer 13

果然少见多怪了，c++能重载操作符，c能吗？
一直以为天天唱衰java的人应该是个高手的，呵呵

Answer 14

我们谈的好象是++i和i++的区别吧？翻开你的"C++ Primer"的第140页，原书这样写的：“建议：只有在必要时才使用后置操作符
为什么要在程序中使用前自增操作符？道理很简单：因为前置操作需要做的工作更少，只需加1后返回加1后的结果即可。而后置操作符则必须先保存操作数原来的值，以便返回未加1之前的值作为操作的结果。对于int型对象和指针，编译器可优化掉这项额外工作。但是对于更多的复杂迭代器类型，这种额外工作可能会花费更大的代价。因此，养成使用前置操作这个好习惯，就不必操心性能差异的问题。”原文我一字未改

Answer 15

"c/c++中全是这样"，明明看的是C++的书，非要把c加上。后面还c、汇编，有关系吗？C++好歹写过是十几万行代码了，哎。

Answer 16

没办法，我目前搞c++比较多，纯c和汇编不用已好多年了(因为不做硬件)，特别是纯Ｃ的字符串比c++难用多了，而效率也没c++的字符串高，特讨厌。

Answer 17

开玩笑吧，会c++的不会c语言，c和c++的编译器虽不同，从这个意思上说是两种语言，但c++完全兼容c语言，从这个意思上讲c是c++的一个子集，c++是c的超集，c语言也是大学里计算机入门的第一门语言，++i/i++,c语言和c++里都有的，这扯不上什么操作符重载的问题。

Answer 18

不会是说“没用c写过什么大的程序”，还是看过不少c代码，像Linux内核的或者一些标准库的。
“c是C++的一个子集”，哭了。我c语言很菜，举两个例子吧
main.c#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int i = 0;
char* pc;
printf("%d\n",sizeof('a'));
pc = malloc(1);
free(pc);
i++;
//++i = 5; 无法编译，在c里++i得到的是左值
return 0;
}main.cpp#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int i = 0;
char* pc;
printf("%d\n",sizeof('a'));
//pc = malloc(1); //c++是强类型语言
//free(pc);
i++;
++i = 5; //c++里++i得到的是右值
return 0;
}扯不上操作符重载的问题，我实在无语了。#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int i = 0;
char* pc;
printf("%d\n",sizeof('a'));
//pc = malloc(1); //²»ÄܱàÒë
//free(pc);
i++;
++i = 5;
return 0;
}int i = 0;
i++;
++i;
看vc＋＋6汇遍代码
7:        int i = 0;
0040FB68   mov         dword ptr [ebp-4],0
8:        i++;
0040FB6F   mov         eax,dword ptr [ebp-4]
0040FB72   add         eax,1
0040FB75   mov         dword ptr [ebp-4],eax
9:        ++i;
0040FB78   mov         ecx,dword ptr [ebp-4]
0040FB7B   add         ecx,1
0040FB7E   mov         dword ptr [ebp-4],ecx
在c++里，你重载操作符的时候，i++会创建一个临时对象，这是性能问题的根源，而++i只是对源对象进行操作。
其实不必要陷入语言之争，但真正要争，起码要懂。

Answer 19

操作符重载就是把操作符
　　比如+，-，*，/这些运算符赋于新的意义。允许用户把这些运算符添加到自已的类中以方便类对象之间的运算就像内置类型的运算一样方便，比如对象a+b这样就很明白更容易懂，当然也可以在类中定义一个对象间相加的函数，比如a.add(b)调用函数add()以实现两个对象a和b相加，但是这条语句没有比a+b更容易让人理解。

Answer 20

唉，现在清闲，继续。#include <iostream>
using namespace std;class Integer
{
private:
int i_;
public:
Integer(int i = 0):i_(i)
{
} Integer& operator++() //前++
{
this->i_++;
return *this; //返回自身对象引用
} const Integer operator++(int) //后++
{
Integer old = *this;  //必须产生一个临时对象，作为返回值，因此性能比前++差。
++(*this);
return old;
} void print() const
{
cout << i_ << endl;
}
};int main()
{
Integer i = 5;
i.print();
i++;
i.print();
++i;
i.print();
return 0;
}
平时用的迭代器，一般是某种对象，重载了前++和后++操作符，从性能角度考虑，优先使用前++.

Answer 21

++i/--i 确实比 i++/i-- 的效率要高。
但是java在编译的期间会自动优化，把i++/i--优化为++i/--i。
至于为什么效率要高，因为
i++/i--可以看成这样
[code=Java
]int temp = i;
i=i+1;
return temp;
[/code]
而++i/--i可以看成这样i=i+1;
return i;从上面两段代码可以看出
i++/i--在运行的时候需要创建一个temp来保存i的初始值，所以对相率有影响。