Qual é a diferença entre o ++ i e o i ++?

Em C, qual é a diferença entre usar ++i e i++ , e qual deve ser usado no bloco de incremento de um loop for ?

  • ++i incrementará o valor de i e retornará o valor incrementado.

      i = 1; j = ++i; (i is 2, j is 2) 
  • i++ incrementará o valor de i , mas retornará o valor original que i mantive antes de ser incrementado.

      i = 1; j = i++; (i is 2, j is 1) 

Para um loop for , ou funciona. ++i parece mais comum, talvez porque é isso que é usado em K & R.

Em qualquer caso, siga a diretriz “prefer ++i i++ ” e você não irá errar.

Há alguns comentários sobre a eficiência do ++i e do i++ . Em qualquer compilador de projeto não-aluno, não haverá diferença de desempenho. Você pode verificar isso observando o código gerado, que será idêntico.

A questão da eficiência é interessante … aqui está minha tentativa de resposta: Existe uma diferença de desempenho entre i ++ e ++ i em C?

Como nas notas de Freund , é diferente para um object C ++, já que o operator++() é uma function e o compilador não pode saber para otimizar a criação de um object temporário para manter o valor intermediário.

i ++ é conhecido como Post Increment, enquanto ++ i é chamado Pre Increment.

i++

i++ é pós incremento porque incrementa o valor de i em 1 após a operação terminar.

Vamos ver o seguinte exemplo:

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

Aqui o valor de j = 1 mas i = 2 . Aqui, o valor de i será atribuído a j primeiro e depois será incrementado.

++i

++i é pré incrementado porque incrementa o valor de i em 1 antes da operação. Isso significa que j = i; irá executar após i++ .

Vamos ver o seguinte exemplo:

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

Aqui o valor de j = 2 mas i = 2 . Aqui o valor de i será atribuído a j após o incremento i de i . Similarmente ++i serei executado antes de j=i; .

Para sua pergunta, que deve ser usada no bloco de incremento de um loop for? a resposta é, você pode usar qualquer um .. não importa. Ele irá executar o seu loop for no mesmo. de vezes.

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

E

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

Ambos os loops produzirão a mesma saída. ou seja, 0 1 2 3 4 .

Só importa onde você está usando.

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

Neste caso, a saída será 1 2 3 4 5 .

Por favor, não se preocupe com a “eficiência” (velocidade, na verdade) de qual deles é mais rápido. Nós temos compiladores nos dias de hoje que cuidam dessas coisas. Use o que fizer sentido usar, com base no que mostra mais claramente a sua intenção.

++i aumenta o valor e retorna-o.

i++ retorna o valor e, em seguida, incrementa-o.

É uma diferença sutil.

Para um loop for, use ++i , pois é um pouco mais rápido. i++ criará uma cópia extra que será descartada.

i ++: – Neste cenário, primeiro o valor é atribuído e, em seguida, o incremento acontece.

++ i: – Neste cenário, primeiro o incremento é feito e, em seguida, o valor é atribuído

Abaixo está a visualização da imagem e também aqui está um belo vídeo prático ( http://www.youtube.com/watch?v=lrtcfgbUXm4 ) que demonstra o mesmo.

insira a descrição da imagem aqui

A razão pela qual ++i posso ser um pouco mais rápido que o i++ é que o i++ pode requerer uma cópia local do valor de i antes de ser incrementada, enquanto ++i nunca o faço. Em alguns casos, alguns compiladores irão otimizá-lo, se possível … mas nem sempre é possível, e nem todos os compiladores fazem isso.

Eu tento não confiar muito em otimizações de compiladores, então eu seguiria o conselho de Ryan Fox: quando eu posso usar os dois, eu uso ++i .

O resultado efetivo de usar um dos dois é idêntico. Em outras palavras, o loop fará exatamente o mesmo em ambos os casos.

Em termos de eficiência, pode haver uma penalidade envolvida na escolha do i ++ sobre ++ i. Em termos de especificação de idioma, o uso do operador pós-incremento deve criar uma cópia extra do valor no qual o operador está agindo. Isso poderia ser uma fonte de operações extras.

No entanto, você deve considerar dois problemas principais com a lógica anterior.

  1. Compiladores modernos são ótimos. Todos os bons compiladores são inteligentes o suficiente para perceber que está vendo um incremento de inteiro em um loop for, e ele otimizará os dois methods para o mesmo código eficiente. Se o uso de pós-incremento sobre o pré-incremento realmente faz com que seu programa tenha um tempo de execução mais lento, então você está usando um compilador terrível .

  2. Em termos de complexidade de tempo operacional, os dois methods (mesmo que uma cópia esteja realmente sendo executada) são equivalentes. O número de instruções sendo executadas dentro do loop deve dominar o número de operações na operação de incremento significativamente. Portanto, em qualquer loop de tamanho significativo, a penalidade do método de incremento será massivamente ofuscada pela execução do corpo do loop. Em outras palavras, é melhor se preocupar em otimizar o código no loop em vez do incremento.

Na minha opinião, a questão toda simplesmente se resume a uma preferência de estilo. Se você acha que o pré-incremento é mais legível, use-o. Pessoalmente, eu prefiro o pós-incremento, mas isso é provavelmente porque foi o que eu aprendi antes de saber alguma coisa sobre otimização.

Esse é um exemplo típico de otimização prematura, e problemas como esse têm o potencial de nos distrair de problemas sérios no design. Ainda é uma boa pergunta, no entanto, porque não há uniformidade no uso ou consenso nas “melhores práticas”.

Ambos aumentam o número. ++ i é equivalente a i = i + 1.

i ++ e ++ i são muito parecidos, mas não exatamente iguais. Ambos incrementam o número, mas ++ i incrementa o número antes da expressão atual ser avaliada, enquanto i ++ incrementa o número após a expressão ser avaliada.

Exemplo:

 int i = 1; int x = i++; //x is 1, i is 2 int y = ++i; //y is 3, i is 3 

++ i é pré-incremento o outro é pós-incremento

i ++: obtém o elemento e, em seguida, incrementa-o.
++ i: incrementa i e retorna o elemento

Exemplo:

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

Saída:

 i: 0 i++: 0 ++i: 2 

++ i (operação de prefixo): Incrementa e, em seguida, atribui o valor
(por exemplo): int i = 5, int b = ++ i
Neste caso, 6 é atribuído a b primeiro e, em seguida, incrementa para 7 e assim por diante.

i ++ (operação Postfix): Atribui e, em seguida, incrementa o valor
(por exemplo): int i = 5, int b = i ++
Neste caso, 5 é atribuído a b primeiro e, em seguida, aumenta para 6 e assim por diante.

Incase de loop for: i + + é usado principalmente porque, normalmente, usamos o valor inicial de i antes de incrementar em loop.Mas dependendo da sua lógica de programa pode variar.

Presumo que você entenda a diferença na semântica agora (embora, sinceramente, eu me pergunte por que as pessoas perguntam ‘o que o operador X quer dizer’ perguntas sobre estouro de pilha em vez de ler, você sabe, um livro ou tutorial na web ou algo assim?

Mas de qualquer maneira, até onde usar, ignore questões de desempenho, que são pouco importantes mesmo em C ++. Este é o princípio que você deve usar ao decidir qual usar:

Diga o que você quer dizer em código.

Se você não precisa do valor antes do incremento na sua declaração, não use essa forma do operador. É uma questão menor, mas a menos que você esteja trabalhando com um guia de estilo que proíba uma versão em favor da outra (também conhecido como guia de estilo com cabeça de bobo), você deve usar o formulário que mais exatamente expressa o que você está tentando fazer.

QED, use a versão pré-incremento:

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

A diferença pode ser entendida por este simples código C ++ abaixo:

 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; 

A principal diferença é

  • i ++ Post ( After Increment ) e
  • ++ i Pre ( antes do incremento )

    • postar se i =1 o loop incrementa como 1,2,3,4,n
    • pre if i =1 o loop é incrementado como 2,3,4,5,n

Brevemente: ++ i e i ++ funcionam mesmo se você não estiver escrevendo em uma function. Se você usar algo como function (i ++) ou function (++ i), poderá ver a diferença.

function (++ i) diz que o primeiro incremento i por 1, depois disso, coloca este i na function com novo valor.

function (i + +) diz colocar primeiro eu na function depois que o incremento i por 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 

Pre-crement significa incrementar na mesma linha. Pós-incremento significa incremento após a execução da linha.

 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 

Quando se trata de operadores OR, AND, torna-se mais interessante.

 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 } 

Em matriz

  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 } 

Em C ++ post / pré-incremento da variável do ponteiro

 #include  using namespace std; int main() { int x=10; int* p = &x; std::cout< <"address = "< 

O seguinte fragment de código C ilustra a diferença entre os operadores de pré e pós incremento e decremento:

int i; int j;

// Operadores de incremento

i = 1;

j = ++ i; // agora é 2, j também é 2

j = i ++; // eu tenho agora 3, j é 2

i ++ e ++ i

Este pequeno código pode ajudar a visualizar a diferença de um ângulo diferente do que as respostas já postadas:

 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); 

O resultado é:

 //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 

Preste atenção às situações antes e depois.

for loop

Quanto a qual deles deve ser usado em um bloco de incremento de um loop for, acho que o melhor que podemos fazer para tomar uma decisão é usar um bom exemplo:

 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); 

O resultado é:

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

Eu não sei sobre você, mas não vejo nenhuma diferença em seu uso, pelo menos em um loop for.

Você pode pensar na conversão interna disso como uma declaração múltipla ;

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

a = i ++ significa que contém um valor i atual a = ++ i significa que contém um valor i incrementado

Aqui está o exemplo para entender a diferença

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

output: 10 12/11 11 (dependendo da ordem de avaliação dos argumentos para a function printf , que varia entre compiladores e arquiteturas)

Explicação: i++ -> i é impresso e, em seguida, incrementado. (Imprime 10, mas será 11) ++i -> i valoriza incrementos e imprime o valor. (Imprime 12, e o valor de i também 12)