O que é mais eficiente i ++ ou ++ i?

Duplicata Exata : Existe uma diferença de desempenho entre i ++ e ++ i em C ++?
Duplicata Exata : Diferença entre i ++ e ++ i em um loop?


O que é mais eficiente i ++ ou ++ i?

Eu usei isso apenas em Java e C / C ++, mas estou realmente perguntando por todos os idiomas em que isso é implementado.

Na faculdade, eu tinha um professor nos mostrando que ++ eu era mais eficiente, mas faz alguns anos e gostaria de receber informações da comunidade de SO.

i ++:

  • criar uma cópia temporária do i
  • incremento i
  • devolver a cópia temporária

++ i:

  • incremento i
  • retorno eu

Com as otimizações ativadas, é bem possível que o assembly resultante seja idêntico, no entanto ++ i é mais eficiente.

edit: tenha em mente que, em C ++, eu posso ser qualquer object que suporte o operador prefixo e postfix ++. Para objects complexos, o custo da cópia temporária é não negligenciável.

Eu procuraria em outro lugar pelo potencial de otimização.

Eis o que o SO pensa do prefixo C ++ versus incrementador postfix

A eficiência não deve ser sua preocupação: é o significado . Os dois não são os mesmos, a menos que sejam independentes: um opera o pré-uso do valor, o outro post.

int i; i = 1; cout << i ++; // Retorna 1

int i; i = 1; cout << ++ i; // retorna 2

Quando o significado não é importante, a maioria dos compiladores traduz ambos ++ i e i ++ (digamos em um loop for) para o mesmo código máquina / VM.

Não importa em um compilador moderno.

int v = i++; 

é o mesmo que

 int v = i; i = i + 1; 

Um compilador moderno descobrirá que v não é usado e o código para calcular v é puro (sem efeitos colaterais). Em seguida, ele removerá v e o código de atribuição e gerará esse

 i = i + 1; 

Isto é importante! Especialmente se você estiver em C ++ …

 ++i // the prefered way, unless.. auto j = i++ // this is what you need 

Você deve sempre usar a notação de prefixo para evitar a cópia necessária de cópia e com C ++ isso importa!

Bem, em C ++, acredito que eles tenham usos diferentes, dependendo de quando você deseja que a variável seja atualizada. A eficiência não deve determinar quando você usa um sobre o outro, mas eu diria que eles teriam a mesma eficiência de qualquer maneira.

++ i é potencialmente mais eficiente para uma implementação não trivial do operador ++, mas mesmo nesse cenário, o compilador pode otimizar o temporário intermediário.

++ eu não preciso de uma variável temporária para armazenar coisas. Pense nelas assim:

++ i

 int preIncrement(int i) { i = i + 1; return i; } 

i ++

 int i = 5; // as an example int postIncrement(_i) { int temp = _i; i = _i + 1; return temp; } 

Vejo? Pós-incremento requer uma variável temporária. Assumindo que o compilador não classifica tudo para você, o que quase certamente acontece.

Naturalmente, mais importante é a lógica do programa; você corre o risco de encontrar a Tragédia Triste do Micro-Optimization Theatre se você se preocupar com isso demais … 🙂

A menos que eu esteja sentindo falta de algo, eles devem ter a mesma eficiência. Ambos devem resultar em uma única instrução add. É apenas uma questão de onde a instrução add ocorre: no início ou no final da sua linha de código.

Não há diferença. Use a construção que faz mais sentido.

Se seu aplicativo for executado lentamente, posso garantir que nunca será devido a diferenças de velocidade na operação de incremento de inteiro. Se for, é um erro grave no compilador. Problemas de velocidade em sua aplicação serão ineficiências algorítmicas, esperando pelo IO e assim por diante.

Não se preocupe com problemas que você não tem. Otimização prematura é a raiz de todo o mal.

++i é mais rápido porque o i++ precisa armazenar i , depois incrementá-lo e retornar o valor armazenado de i . ++i simplesmente incrementa i seguida, retorna-lo.

 // ++i i += 1; return i; // i++ temp = i; i += 1; return temp; 

Um autônomo “i ++;” ou “++ i;” deve gerar código igualmente eficiente. A diferença vem se você estiver usando em uma expressão, onde o “efeito colateral” entra em jogo.

Dito isto, houve um tempo, quando “todo o mundo é um Vax”, e compiladores sugaram, que ++ i foi dito ser mais eficiente que i ++, mesmo em um “for (i = 0; i

Essa pergunta sobre stackoverflow tem uma ótima resposta: Existe uma diferença de desempenho entre i ++ e ++ i em C?

Eu gostaria de acrescentar que você deve usar o que melhor atenda às suas necessidades. Exceto no momento mais crítico de aplicações, não é importante. Do ponto de vista acadêmico, também é melhor escrever código que expresse o que você precisa e otimize por último.

Não há resposta certa ou errada

Como isso depende

1) como foi implementado pelo complier

2) em qual CPU o sistema é executado

3) Se eu for byte ou double word

Em geral, é mais eficiente usar ++ i que i ++. A razão simples para isso é que ++ i é totalmente o mesmo que

i + = 1;

que para x86 é uma instrução única (e provavelmente a maioria das outras arquiteturas amplamente usadas). i ++ é no entanto igual a

tmp = i; i + = 1;

Isso é porque o valor antigo de ‘i’ é o que o i ++ avalia para. E claramente isso requer mais trabalho do que simplesmente i + = 1;

Mas, como dito acima, isso praticamente não tem impacto com um compilador suficientemente inteligente, pois otimizará as operações não utilizadas. Para muitas linguagens interpretadas (exemplo: PHP), é provável que haja um ganho mínimo de velocidade para o ++ i; Mas esse aumento é insignificante.

Geralmente, em c ++, o postfix exigirá a construção adicional do object incrementado, enquanto o prefixo é aplicado diretamente ao object. (Ou então eu li)

Como não posso atestar como o compilador lida com isso, devido ao meu conhecimento limitado sobre o assunto, ele poderia ser tratado por você, tornando-se um ponto discutível.

++ eu recebo 1 instrução de processador a menos do que i ++ no assembly x86 sem otimização

Geralmente é mais fácil digitar i ++, portanto, é mais eficiente em termos de tempo de produtividade.

Sério, no entanto, se eu for um tipo de dados nativo (como int, double, etc) – não há diferença.

E é implementação depende se é um tipo definido pelo usuário, como

 class Type { Type& operator ++(){} const Type& operator ++(int i){} }; T i; 

Depende do contexto, por exemplo:

 x = i++ 

Neste caso, ‘x’ será igual a ‘i’, e somente depois disso ‘i’ será aumentado em um.

 x = ++i 

Nesse caso, ‘i’ será aumentado em um e, em seguida, o novo valor de ‘x’ será atribuído a ‘x’.

No caso de um loop ‘for’, há pouca diferença aparente além do desempenho (++ i é mais rápido).

É difícil responder isso precisamente, pois depende da implementação do compilador / intérprete.

Mas, em geral, você pode dizer que estende aproximadamente o i ++ para as seguintes instruções:

 COPY i to tmp INCREMENT tmp SAVE tmp as i 

Enquanto ++ eu estenderei aproximadamente:

 LOAD i INCREMENT i 

Você não pode simplesmente dizer que ++ i é mais rápido que o i ++, já que as implementações de linguagem são muito inteligentes e podem otimizar essas instruções quando você sabe que não acessará o valor temporário do i ++. Isso geralmente acontece em dizer um loop for. Então, em muitos casos, é o mesmo.

Se você está tentando este tipo de micro-otimizações, eu aconselho você a fazer o perfil / medir antes de escolher um sobre o outro.