Est-ce que x + = a plus rapide que x = x + a?

Question

Je lisais le "Langage de programmation C ++" de Stroustrup, où il dit que de deux façons d'ajouter quelque chose à une variable

 x = x + a;
 

et

 x += a;
 

Il préfère += car il est probablement mieux mis en œuvre. Je pense qu'il veut dire que ça marche plus vite aussi.
Mais est-ce vraiment? Si cela dépend du compilateur et d'autres choses, comment puis-je vérifier?

Answer 1

Un compilateur qui vaut son sel va générer exactement le même langage machine séquence pour les deux constructions pour n'importe quel type (int, float, etc) tant que l'état est vraiment aussi simple que d' x = x + a; et l'optimisation est activée. (Notamment, du CCG -O0, qui est le mode par défaut, effectue anti-optimisations, comme l'insertion d'complètement inutile, les magasins de la mémoire, afin de s'assurer que les débogueurs pouvez toujours trouver les valeurs d'une variable.)

Si l'instruction est plus compliqué, même si, ils peuvent être différents. Supposons f est une fonction qui retourne un pointeur, puis

*f() += a;

appels f qu'une seule fois, alors que

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

il appelle deux fois. Si f a des effets secondaires, l'un des deux sera fausse (probablement la dernière). Même si f n'ont pas d'effets secondaires, le compilateur ne peut pas être en mesure d'éliminer le deuxième appel, celui-ci peut en effet être plus lent.

Et puisque nous parlons de C++ ici, la situation est complètement différente pour les types de classe qui surcharge operator+ et operator+=. Si x est un type, puis, avant d'optimisation -- x += a se traduit par

x.operator+=(a);

alors qu' x = x + a se traduit par

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

Maintenant, si la classe est bien écrit et le compilateur optimiseur est assez bon, les deux sera le vent de générer le même langage machine, mais ce n'est pas quelque chose de sûr, comme il est de type intégré. C'est probablement ce Stroustrup est en pensant, quand il encourage l'utilisation de l' +=.

Answer 2

Vous pouvez vérifier en regardant les systèmes, qui sera le même.

Pour les types de base, les deux sont tout aussi rapides.

Il s’agit de la sortie générée par une version debug (c.-à-d. aucune optimisation) :

Pour les types définis par l’utilisateur, où vous pouvez surcharger et , cela dépend de leurs implémentations respectives.

Answer 3

Oui ! Il est plus rapide à écrire, plus rapide à lire et rapide à comprendre, pour ce dernier dans l’affaire qui `` peut avoir effets secondaires. C’est donc dans l’ensemble plus rapide pour les humains. Le temps humain dans les frais généraux beaucoup plus que l’heure de l’ordinateur, qui doit donc être ce que vous demandiez sur. Oui ?

Answer 4

La différence entre x = x + a et x += a est la quantité de travail de la machine doit passer par - certains compilateurs peuvent (et le font habituellement) de l'optimiser à l'écart, mais généralement, si l'on ignore l'optimisation pour un certain temps, ce qui se passe est que dans le premier extrait de code, la machine est à la recherche de la valeur pour l' x deux fois, tandis que dans le second, cette recherche doit se produire qu'une seule fois.

Cependant, comme je l'ai mentionné, aujourd'hui, la plupart des compilateurs sont assez intelligents pour analyser l'instruction et de réduire l'résultant de la machine des instructions nécessaires.

PS: Première réponse sur un Débordement de Pile!

Answer 5

Comme vous avez étiqueté ce C++, il n’y a aucun moyen de savoir depuis les deux déclarations que vous avez posté. Vous devez savoir quel « x » est (c’est un peu comme la réponse "42"). Si est une gousse, puis il ne va pas vraiment faire beaucoup de différence. Toutefois, si est une classe, il peut y avoir des surcharges pour les et les méthodes qui pourraient avoir des comportements différents qui mènent à des temps d’exécution très différents.