Se você não sabe a diferença das duas, é simples:
int x, y;
x = 3;
y = x++; //y vai valer 3 e x vai valer 4
x = 3;
y = x++; //y vai valer 3 e x vai valer 4
int x, y;
x = 3;
y = ++x; //x e y vão valer 4
x = 3;
y = ++x; //x e y vão valer 4
ou seja, ++x primeiro incrementa e depois retorna.
x++ guarda o valor antigo, incrementa x e retorna o valor antigo de x.
Pensando em código:
++x:
Incrementa x;
returna x;
returna x;
x++:
temp = x;
incrementa x;
retorna temp;
incrementa x;
retorna temp;
Como podem ver, no pós-incremento (x++), é criada uma variável de backup, que consome memória e processamento, desnecessária se você não for utilizar o seu valor.
Portanto, a próxima vez que você for fazer:
for ( int x = 0; x < blablabla; x++ )
opte por:
for ( int x = 0; x < blablabla; ++x )
P.s.: Alguns compiladores até otimizam isso se você estiver utilizando tipos básicos (char, int, float...), mas se estiver lidando com objetos, isso não acontecerá.
Um exemplo é se você estiver utilizando iteradores da STL.
No caso do loop for, pré-incremento e pós-incremento têm a mesma semântica, do ponto de vista do compilador. O loop for é uma simplificação de:
ResponderExcluirx = 0;
while (x < blablabla)
{
/* Fal algo aqui */
x++;
}
E ++x ou x++, neste contexto gera exatamente o mesmo código...
Sim, como eu comento no "P.s.", os compiladores atuais são capazes de otimizar o código para tipos básicos.
ResponderExcluirMas experimente fazer isso em um objeto:
std::vector< int > vetor;
/*Adicione objetos no vetor*/
std::vector< int >::iterator iter = vetor.begin();
while( iter != vetor.end() )
{
iter++;
}
Compare o resultado obtido por este código com um ++iter.
No caso dos tipos básicos, se pegar um compilador tosco (como o CCS), o desempenho de int++ será pior do que do ++int.
No exemplo do pós-incremento existe um erro no retorno:
ResponderExcluirx++:
temp = x;
incrementa x;
retorna temp; // Deve retornar "temp" e não "x"
É verdade, já corrigi.
ResponderExcluirObrigado!