首页 文章

我和我之间有什么区别？

提问于
浏览 次
693

在C中，使用 ++i 和 i++ 之间有什么区别，哪些应该用在 for 循环的增量块中？

c for-loop post-increment pre-increment

20 回答

  • 20

    以下是了解差异的示例

    int i=10;
printf("%d %d",i++,++i);

    输出： 10 12/11 11 （取决于 printf 函数的参数的评估顺序，它在编译器和体系结构之间有所不同）

    说明： i++ - > i 已打印，然后递增 . （打印10，但 i 将变为11） ++i - > i 值增量并打印该值 . （打印12， i 的值也是12）

    回复于
  • 873
    • ++i 将递增 i 的值，然后返回递增的值 .
    i = 1;
 j = ++i;
 (i is 2, j is 2)
    • i++ 将递增 i 的值，但返回 i 在递增之前保持的原始值 .
    i = 1;
 j = i++;
 (i is 2, j is 1)

    对于 for 循环，可以正常工作 . ++i 似乎更常见，也许是因为这是K&R中使用的 .

    无论如何，请遵循指南“首选 ++i over i++ ”，您不会出错 .

    关于 ++i 和 i++ 的效率，有几条评论 . 在任何非学生项目编译器中，都没有性能差异 . 您可以通过查看生成的代码来验证这一点，这些代码是相同的 .

    效率问题很有意思......这是我尝试回答的问题：Is there a performance difference between i++ and ++i in C?

    正如On Freund指出的那样，对于C对象来说它是不同的，因为 operator++() 是一个函数，并且编译器无法知道如何优化临时对象的创建以保存中间值 .

    回复于
  • 146

    i++ 被称为 Post Increment 而 ++i 被称为 Pre Increment.

    i++

    i++ 是后增量，因为它在操作结束后将 i 的值增加1 .

    让我们看看以下示例：

    int i = 1, j;
j = i++;

    这里的值为 j = 1 但是 i = 2 . 此处 i 的值将首先分配给 j ，然后 i 将递增 .

    ++i

    ++i 是预增量，因为它在操作之前将 i 的值递增1 . 这意味着 j = i; 将在 i++ 之后执行 .

    让我们看看以下示例：

    int i = 1, j;
j = ++i;

    这里的值为 j = 2 但是 i = 2 . 在 i 的 i 增量之后， i 的值将被分配给 j . 同样地， ++i 将在 j=i; 之前执行 .

    对于你的问题 which should be used in the incrementation block of a for loop? 答案是，你可以使用任何一个..没关系 . 它将执行你的for循环相同的no . 时代

    for(i=0; i<5; i++)
   printf("%d ",i);

    和

    for(i=0; i<5; ++i)
   printf("%d ",i);

    两个循环都会产生相同的输出 . 即 0 1 2 3 4 .

    它只在您使用它的地方很重要 .

    for(i = 0; i<5;)
    printf("%d ",++i);

    在这种情况下，输出将是 1 2 3 4 5 .

    回复于
  • 27

    请不要担心哪一个更快的“效率”（速度，真的） . 这些天我们有编译器来处理这些事情 . 使用任何有意义的使用，在此基础上更清楚地显示您的意图 .

    回复于
  • 19

    ++i 递增该值，然后返回它 .

    i++ 返回值，然后递增它 .

    这是一个微妙的差异 .

    对于for循环，使用 ++i ，因为它稍微快一些 . i++ 将创建一个被丢弃的额外副本 .

    回复于
  • 4

    i： - 在这种情况下，首先分配值，然后发生增量 .

    i： - 在这种情况下，首先完成增量，然后分配值

    下面是图像可视化，这里也是一个很好的实用视频（http://www.youtube.com/watch?v=lrtcfgbUXm4），它演示了相同的内容 .

    enter image description here

    回复于
  • -5

    ++i 可能比 i++ 略快的原因是 i++ 在增加之前可能需要i值的本地副本，而 ++i 从不这样做 . 在某些情况下，如果可能的话，一些编译器会对其进行优化...但并不总是可行，并非所有编译器都这样做 .

    我尽量不要太依赖编译器优化，所以我建议：当我可以使用两者时，我使用 ++i .

    回复于
  • 32

    我和我

    这个小代码可能有助于从与已发布的答案不同的角度可视化差异：

    int i = 10, j = 10;

  printf ("i is %i \n", i);
  printf ("i++ is %i \n", i++);
  printf ("i is %i \n\n", i);

  printf ("j is %i \n", j);
  printf ("++j is %i \n", ++j);
  printf ("j is %i \n", j);

    结果是：

    //Remember that the values are i = 10, and j = 10

i is 10 
i++ is 10     //Assigns (print out), then increments
i is 11 

j is 10 
++j is 11    //Increments, then assigns (print out)
j is 11

    注意前后情况 .

    for循环

    至于在for循环的增量块中应该使用哪一个，我认为我们做出决定的最佳方法是使用一个很好的例子：

    int i, j;

For (i = 0; i <= 3; i++)
    printf (" > iteration #%i", i);

printf ("\n");

for (j = 0; j <= 3; ++j)
    printf (" > iteration #%i", j);

    结果是：

    > iteration #0 > iteration #1 > iteration #2 > iteration #3
> iteration #0 > iteration #1 > iteration #2 > iteration #3

    我不了解你，但我认为它的用法没有任何差别，至少在for循环中 .

    回复于
  • 4

    使用任何一种的有效结果是相同的 . 换句话说，循环在两个实例中都会做同样的事情 .

    在效率方面，选择i而不是i可能会受到惩罚 . 就语言规范而言，使用后增量运算符应该创建运算符所作用的值的额外副本 . 这可能是额外操作的来源 .

    但是，您应该考虑前面逻辑的两个主要问题 .

    • 现代编译器很棒 . 所有优秀的编译器都足够聪明，可以意识到它在for循环中看到了整数增量，并且它将两种方法优化为相同的高效代码 . 如果使用后增量超过预增量实际上会导致程序运行时间变慢，那么您使用的是可怕的编译器 .

    • 就操作时间复杂性而言，这两种方法（即使实际执行副本）也是等效的 . 在循环内执行的指令数应该显着地增加增量操作中的操作数 . 因此，在任何有效大小的循环中，增量方法的代价将被循环体的执行大大掩盖 . 换句话说，您最好不要担心在循环中优化代码而不是增量 .

    在我看来，整个问题简单归结为一种风格偏好 . 如果你认为预增量是更具可读性，然后使用它 . 就个人而言，我更喜欢后加入，但这可能是因为在我对优化有所了解之前，这就是我所教授的内容 .

    这是过早优化的典型例子，这样的问题有可能让我们分散设计中的严重问题 . 然而，这仍然是一个很好的问题，因为在“最佳实践”中没有统一的使用或共识 .

    回复于
  • 3

    他们都增加了数字 . 我相当于i = i 1 .

    我和我非常相似但不完全一样 . 两者都递增数字，但我在计算当前表达式之前递增数字，而i在计算表达式之后递增数字 .

    示例：

    int i = 1;
int x = i++; //x is 1, i is 2
int y = ++i; //y is 3, i is 3
    回复于
  • -3

    我是预增量，另一个是后增量

    i：获取元素然后递增它 .
    i：递增i然后返回元素

    例：

    int i = 0;
printf("i: %d\n", i);
printf("i++: %d\n", i++);
printf("++i: %d\n", ++i);

    输出：

    i: 0
i++: 0
++i: 2
    回复于
  • 11

    ++i (Prefix operation): Increments and then assigns the value
    （例如）：int i = 5，int b = i
    在这种情况下，首先将6分配给b，然后增加到7，依此类推 .

    i++ (Postfix operation): Assigns and then increments the value
    （例如）：int i = 5，int b = i
    在这种情况下，首先将5分配给b，然后增加到6，依此类推 .

    for循环：我主要使用i，因为通常我们在递增for循环之前使用i的起始值 . 但是根据你的程序逻辑，它可能会有所不同 .

    回复于
  • 3

    我假设你现在理解语义上的差异（虽然老实说我想知道为什么人们会问'运算符X对于堆栈溢出的问题'而不是阅读，你知道，书或网络教程等等 .

    但无论如何，就使用哪一个而言，忽略性能问题，即使在C语言中也不太重要 . 这是您在决定使用哪个时应该使用的原则：

    说出你在代码中的意思 .

    如果您不需要语句中的value-before-increment，请不要使用该运算符的形式 . 这是一个小问题，但除非你正在使用一个版本指南，禁止一个版本支持另一个版本（也就是一个骨头风格指南），你应该使用最准确表达你想要做的事情的形式 .

    QED，使用预增量版本：

    for (int i = 0; i != X; ++i) ...
    回复于
  • 2

    下面这个简单的C代码可以理解这种差异：

    int i, j, k, l;
i = 1; //initialize int i with 1
j = i+1; //add 1 with i and set that as the value of j. i is still 1
k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1
l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l.
cout << i << ' ' << j << ' ' << k << ' '<< l << endl;
return 0;
    回复于
  • 2

    主要区别是i Post（增量后）和i Pre（增量前）后如果i = 1，则循环增量如1,2,3,4，n pre如果i = 1则循环增量如2,3,4 5，正

    回复于
  • 2

    简而言之：如果你不是在函数中编写它们，我和我的工作方式相同 . 如果你使用类似函数（i）或函数（i）的东西，你可以看到差异 .

    函数（i）表示首先将i递增1，然后将此i放入具有新值的函数中 .

    函数（i）表示在增量之后将第一个i放入函数中i乘以1 .

    int i=4;
printf("%d\n",pow(++i,2));//it prints 25 and i is 5 now
i=4;
printf("%d",pow(i++,2));//it prints 16 i is 5 now
    回复于
  • 3

    Pre-crement means increment on the same line. Post-increment means increment after the line executes.

    int j=0;
System.out.println(j); //0
System.out.println(j++); //0. post-increment. It means after this line executes j increments.

int k=0;
System.out.println(k); //0
System.out.println(++k); //1. pre increment. It means it increments first and then the line executes

    When it comes with OR, AND operators, it becomes more interesting.

    int m=0;
if((m == 0 || m++ == 0) && (m++ == 1)) { //false
/* in OR condition if first line is already true then compiler doesn't check the rest. It is technique of compiler optimization */
System.out.println("post-increment "+m);
}

int n=0;
if((n == 0 || n++ == 0) && (++n == 1)) { //true
System.out.println("pre-increment "+n); //1
}

    In Array

    System.out.println("In Array");
        int[] a = { 55, 11, 15, 20, 25 } ;
        int ii, jj, kk = 1, mm;
        ii = ++a[1]; // ii = 12. a[1] = a[1] + 1
        System.out.println(a[1]); //12

        jj = a[1]++; //12
        System.out.println(a[1]); //a[1] = 13

        mm = a[1];//13
        System.out.printf ( "\n%d %d %d\n", ii, jj, mm ) ; //12, 12, 13

        for (int val: a) {
            System.out.print(" " +val); //55, 13, 15, 20, 25
        }

    In C++ post/pre-increment of pointer variable

    #include <iostream>
using namespace std;

int main() {

    int x=10;
    int* p = &x;

    std::cout<<"address = "<<p<<"\n"; //prints address of x
    std::cout<<"address = "<<p<<"\n"; //prints (address of x) + sizeof(int)
    std::cout<<"address = "<<&x<<"\n"; //prints address of x

    std::cout<<"address = "<<++&x<<"\n"; //error. reference can't re-assign because it is fixed (immutable)
}
    回复于
  • 2

    以下C代码片段说明了前后增量和减量运算符之间的区别：

    int i; int j;

    //增加运算符

    i = 1;

    j = i; //我现在是2，j也是2

    j = i; //我现在是3，j是2

    回复于
  • 8

    您可以将其内部转换为 multiple statements ;

    // case 1 :

i++;

/* you can think as,
 * i;
 * i= i+1;
 */

// case 2

++i;

/* you can think as,
 * i = i+i;
 * i;
 */
    回复于
  • -1

    a = i表示包含当前i值a = i表示包含递增的i值

    回复于

相关问题