É x + = a mais rápido do que x = x + a?

Eu estava lendo "The C ++ Programming Language" de Stroustrup, onde ele diz que de duas maneiras de adicionar algo a uma variável

x = x + a;

e

x += a;

Ele prefere +=porque provavelmente é melhor implementado. Acho que ele quer dizer que funciona mais rápido também.
Mas é mesmo? Se depender do compilador e outras coisas, como faço para verificar?

Qualquer valor de compilador o seu sal vai gerar exatamente a mesma seqüência de linguagem de máquina para ambas as construções para qualquer tipo built-in ( int, float, etc), desde que a declaração é realmente tão simples como x = x + a; e otimização está habilitado . (Notavelmente, o GCC -O0, que é o modo padrão, realiza anti-otimizações , como inserir armazenamentos completamente desnecessários na memória, a fim de garantir que os depuradores sempre possam encontrar valores de variáveis.)

Se a declaração for mais complicada, porém, eles podem ser diferentes. Suponha que fseja uma função que retorna um ponteiro, então

*f() += a;

liga fapenas uma vez, enquanto

*f() = *f() + a;

chama duas vezes. Se ftiver efeitos colaterais, um dos dois estará errado (provavelmente o último). Mesmo se fnão tiver efeitos colaterais, o compilador pode não ser capaz de eliminar a segunda chamada, portanto, a última pode ser mais lenta.

E como estamos falando sobre C ++ aqui, a situação é totalmente diferente para tipos de classes que sobrecarregam operator+e operator+=. Se xfor esse tipo, então - antes da otimização - se x += atraduz em

x.operator+=(a);

Considerando que se x = x + atraduz em

auto TEMP(x.operator+(a));
x.operator=(TEMP);

Agora, se a classe for escrita corretamente e o otimizador do compilador for bom o suficiente, ambos acabarão gerando a mesma linguagem de máquina, mas não é uma coisa certa como é para tipos internos. Provavelmente é nisso que Stroustrup está pensando quando incentiva o uso de +=.

Você pode verificar olhando para a desmontagem, que será a mesma.

Para tipos básicos , ambos são igualmente rápidos.

Esta é a saída gerada por uma compilação de depuração (ou seja, sem otimizações):

    a += x;
010813BC  mov         eax,dword ptr [a]  
010813BF  add         eax,dword ptr [x]  
010813C2  mov         dword ptr [a],eax  
    a = a + x;
010813C5  mov         eax,dword ptr [a]  
010813C8  add         eax,dword ptr [x]  
010813CB  mov         dword ptr [a],eax  

Para tipos definidos pelo usuário , onde você pode sobrecarregar operator +e operator +=, depende de suas respectivas implementações.

Sim! É mais rápido escrever, ler e descobrir, para o último caso xpossa ter efeitos colaterais. Portanto, é no geral mais rápido para os humanos. O tempo humano em geral custa muito mais do que o tempo do computador, então deve ser sobre isso que você está perguntando. Direito?

Realmente depende do tipo de xea e da implementação de +. Para

   T x, a;
   ....
   x = x + a;

o compilador deve criar um T temporário para conter o valor de x + a enquanto o avalia, que pode então atribuir a x. (Não pode usar x ou a como área de trabalho durante esta operação).

Para x + = a, não precisa de um temporário.

Para tipos triviais, não há diferença.

A diferença entre x = x + ae x += aé a quantidade de trabalho que a máquina tem que passar - alguns compiladores podem (e geralmente fazem) otimizá-la, mas geralmente, se ignorarmos a otimização por um tempo, o que acontece é que no trecho de código anterior, o a máquina deve pesquisar o valor xduas vezes, enquanto na última, essa pesquisa precisa ocorrer apenas uma vez.

No entanto, como mencionei, hoje a maioria dos compiladores são inteligentes o suficiente para analisar a instrução e reduzir as instruções de máquina resultantes necessárias.

PS: Primeira resposta no Stack Overflow!

Como você rotulou este C ++, não há como saber a partir das duas declarações que você postou. Você precisa saber o que é 'x' (é um pouco como a resposta '42'). Se xfor um POD, não fará muita diferença. No entanto, se xfor uma classe, pode haver sobrecargas para os métodos operator +e operator +=que podem ter comportamentos diferentes que levam a tempos de execução muito diferentes.

Se você disser +=que está tornando a vida muito mais fácil para o compilador. Para que o compilador reconheça que x = x+aé o mesmo que x += a, o compilador deve

• analise o lado esquerdo ( x) para ter certeza de que não há efeitos colaterais e sempre se refere ao mesmo valor l. Por exemplo, pode ser z[i], e tem que garantir que ambos ze inão mudem.

• analise o lado direito ( x+a) e certifique-se de que é um somatório, e que o lado esquerdo ocorre uma vez e apenas uma vez no lado direito, embora possa ser transformado, como em z[i] = a + *(z+2*0+i).

Se o que você quer dizer é adicionar aa x, o redator do compilador agradece quando você apenas diz o que quer dizer. Dessa forma, você não está exercitando a parte do compilador que seu escritor espera que ele / ela tem todos os bugs fora de, e que não realmente tornar a vida mais fácil para você, a menos que você honestamente não pode obter a cabeça para fora do modo Fortran.

Para um exemplo concreto, imagine um tipo de número complexo simples:

struct complex {
    double x, y;
    complex(double _x, double _y) : x(_x), y(_y) { }
    complex& operator +=(const complex& b) {
        x += b.x;
        y += b.y;
        return *this;
    }
    complex operator +(const complex& b) {
        complex result(x+b.x, y+b.y);
        return result;
    }
    /* trivial assignment operator */
}

Para o caso a = a + b, ele tem que fazer uma variável temporária extra e então copiá-la.

Você está fazendo a pergunta errada.

É improvável que isso impulsione o desempenho de um aplicativo ou recurso. Mesmo se fosse, a maneira de descobrir é analisar o código e saber como ele o afeta com certeza. Em vez de se preocupar nesse nível com o que é mais rápido, é muito mais importante pensar em termos de clareza, correção e legibilidade.

Isso é especialmente verdadeiro quando você considera que, mesmo que seja um fator de desempenho significativo, os compiladores evoluem com o tempo. Alguém pode descobrir uma nova otimização e a resposta certa hoje pode se tornar errada amanhã. É um caso clássico de otimização prematura.

Isso não quer dizer que o desempenho não tenha importância alguma ... Apenas que é a abordagem errada para atingir seus objetivos de desempenho. A abordagem certa é usar ferramentas de criação de perfil para aprender onde seu código está realmente gastando seu tempo e, portanto, onde concentrar seus esforços.

Acho que isso deve depender da máquina e de sua arquitetura. Se sua arquitetura permitir endereçamento indireto de memória, o redator do compilador PODE usar este código (para otimização):

mov $[y],$ACC

iadd $ACC, $[i] ; i += y. WHICH MIGHT ALSO STORE IT INTO "i"

Visto que, i = i + ypode ser traduzido para (sem otimização):

mov $[i],$ACC

mov $[y],$B 

iadd $ACC,$B

mov $B,[i]

Não, as duas maneiras são tratadas da mesma forma.