В чем разница между ++ i и i ++?

Question

В C, в чем разница между использованием ++i и i++, и что должно использоваться в блоке приращения цикла for?

Answer 1

i ++ и ++ i

Этот небольшой код может помочь визуализировать разницу под другим углом, чем уже опубликованные ответы:

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, я думаю, что лучшее, что мы можем сделать для принятия решения, - это использовать хороший пример:

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.

Answer 2

Полагаю, вы понимаете разницу в семантике (хотя, честно говоря, мне интересно, почему люди задают вопросы «что означает оператор X» о переполнении стека, а не о чтении, Вы знаете, книга или веб-учебник или что-то.

Но в любом случае, в отношении того, какой из них использовать, игнорируйте вопросы производительности, которые вряд ли важно даже в C ++. Это принцип, который вы должны использовать при принятии решения какой использовать:

Скажите, что вы имеете в виду в коде.

Если вам не нужно значение before-increment в вашем выражении, не используйте эту форму оператора. Это небольшая проблема, но если вы не работаете с руководством по стилю, которое запрещает версия в пользу другой в целом (так называемое руководство по стилю с головой), вы должны использовать форма, которая наиболее точно выражает то, что вы пытаетесь сделать.

КЭД, используйте версию с преинкрементом:

for (int i = 0; i != X; ++i) ...

Answer 3

Разницу можно понять по следующему простому коду 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;

Answer 4

Основная разница

• i ++ Post ( после увеличения ) и

• ++ i Pre ( До приращения )

  • отправлять, если i =1 цикл увеличивается как 1,2,3,4,n
  • pre, если i =1 цикл увеличивается как 2,3,4,5,n

Answer 5

Следующий фрагмент кода C иллюстрирует разницу между операциями увеличения и уменьшения до и после строки:

int i; int j;

// Операторы приращения

i = 1;

j = ++ i; // я теперь 2, j тоже 2

j = i ++; // я сейчас 3, j 2

Answer 6

Предварительная обработка означает приращение по той же строке. Постинкремент означает приращение после выполнения строки.

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

Когда речь идет об операторах ИЛИ и AND, становится интереснее.

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
}

В массиве

        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
        }

В C ++ сообщение / предварительное увеличение переменной указателя

#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)
}

Answer 7

Коротко: ++ i и i ++ работают одинаково, если вы не пишете их в функции. Если вы используете что-то вроде функции (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

Answer 8

Единственная разница - это порядок операций между приращением переменной и значением, которое возвращает оператор.

Этот код и его вывод объясняют разницу:

#include<stdio.h>

int main(int argc, char* argv[])
{
  unsigned int i=0, a;
  a = i++;
  printf("i before: %d; value returned by i++: %d, i after: %d\n", i, a, i);
  i=0;
  a = ++i;
  printf("i before: %d; value returned by ++i: %d, i after: %d\n", i, a, i);
}

Вывод:

i before: 1; value returned by i++: 0, i after: 1
i before: 1; value returned by ++i: 1, i after: 1

Таким образом, в основном ++i возвращает значение после его увеличения, в то время как ++i возвращает значение до его увеличения. В конце в обоих случаях значение i будет увеличено.

Другой пример:

#include<stdio.h>

int main ()
  int i=0;
  int a = i++*2;
  printf("i=0, i++*2=%d\n", a);
  i=0;
  a = ++i * 2;
  printf("i=0, ++i*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  return 0;
}

Выход:

i=0, i++*2=0
i=0, ++i*2=2
i=0, (++i)*2=2
i=0, (++i)*2=2

---

Много раз нет никакой разницы

Различия очевидны, когда возвращаемое значение присваивается другой переменной или когда приращение выполняется в сцеплении с другими операциями, где применяется приоритет операций (i++*2 отличается от ++i*2, но (i++)*2 и (++i)*2 возвращает одно и то же значение) во многих случаях они взаимозаменяемы. Классическим примером является синтаксис цикла for:

for(int i=0; i<10; i++)

имеет тот же эффект, что и

for(int i=0; i<10; ++i)

Правило запоминания

Чтобы не путать два оператора, я принял это правило:

Свяжите позицию оператора ++ относительно переменной i с порядком операции ++ относительно присвоения

Сказал другими словами:

• ++ до i означает, что увеличение должно быть выполнено до назначения ;
• ++ после i означает, что приращение должно выполняться после назначение:

Answer 9

Вы можете думать о внутреннем преобразовании этого как несколько операторов ;

// case 1 :

i++;

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

// case 2

++i;

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

Answer 10

Вот пример, чтобы понять разницу

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

output: 10 12/11 11 (в зависимости от порядка вычисления аргументов функции printf, которая варьируется в зависимости от компиляторов и архитектур)

Пояснение: i++ -> i печатается, а затем увеличивается. (Печатает 10, но i станет 11) ++i -> i значение увеличивается и печатает значение. (Печатает 12, а значение i также 12)