in Par exemple, Aussi j'ai lu que x = x + 1 est x évalué deux fois? Si oui, cela signifie-t-il dans x + = 1 , x n'est évalué qu'une seule fois? Comment les deux expressions sont-elles évaluées en termes de code intermédiaire de compilateur?
x ++ pourrait signifier: prenez l'emplacement de x , chargez le contenu de x dans un registre et incrémenter la valeur de x en mémoire.
x + = 1 est utile lorsque x n'est pas une variable simple, mais une expression impliquant un tableau. Des idées pourquoi c'est le cas?
6 Réponses :
Dans la plupart des compilateurs, ceux-ci seraient identiques
Qu'en est-il des plus anciens compilateurs? qui n'impliquent pas autant que les plus récents..quièmes sont-ils évalués différemment?
Si le compilateur est inefficace, cela peut ignorer le fait que X est référé à deux reprises et le charger, puis effectuez l'opération d'incrémentation sur la valeur chargée.
Et qu'en est-il du commentaire sur les tableaux?
Encore une fois - un bon compilateur sera en mesure de produire le même code, mais une inefficacité pourrait avoir plus de problèmes avec des expressions plus complexes telles que celles impliquant des membres de la matrice.
Donc, il y a déjà des questions qui couvrent ce que vous demandez ici:
incrémentation: x ++ vs x + = 1
ce qui est plus rapide? ++, + = ou x + 1?
La ligne de fin de la ligne est que dans la plupart des mais pas toutes les langues les le compilateur va les rendre identiques de toute façon, il n'y a donc aucune différence d'efficacité. Les questions ci-dessus vont dans un peu de détails sur le sujet.
avec GCC, vous pouvez obtenir le code de l'assembleur avec gcc -s foo.c . Je l'ai essayé avec x + = 1 et x = x + 1 et c'était le même.
Pourquoi x + = 1 plus efficace que x = x + 1?
Ce n'est pas.
pourquoi x ++ est plus efficace que x + = 1?
Ce n'est pas.
la raison de préférer
x + = 1 àx = x + 1 se présente lorsquex est remplacé par un identifiant beaucoup plus long, ou peut-être un champ dans une classe ou une structure. Dans cette situation, la versionx + = 1 est plus lisible et évite encore plus sur les pièges de vous répéter.
car il faut 4 caractères pour écrire plutôt que 5.
Ceci est le seul moyen dans lequel x + = 1 est "plus efficace" que x = x + 1 . Cependant, l'opérateur + = a quelques autres avantages, comme le fait que (x) + = 1 fonctionne dans les macros où x est un expression qui peut avoir des effets secondaires que vous souhaitez éviter d'évaluer plus d'une fois ...
Juste pour vous donner un exemple de «monde réel», considérez ce programme:
.section __TEXT,__text,regular,pure_instructions
.globl _main
.align 4, 0x90
_main:
pushl %ebp # cdecl function stuff
movl %esp, %ebp #
subl $12, %esp # get room for variables
movl $0, -12(%ebp) # i = 0;
; i += 1
movl -12(%ebp), %eax # load i in register a
addl $1, %eax # add 1 to register a
movl %eax, -12(%ebp) # store it back in memory
; i++
movl -12(%ebp), %eax #
addl $1, %eax # just the same
movl %eax, -12(%ebp) #
; i = i + 1
movl -12(%ebp), %eax #
addl $1, %eax # just the same
movl %eax, -12(%ebp) #
movl $0, -8(%ebp)
movl -8(%ebp), %eax
movl %eax, -4(%ebp)
movl -4(%ebp), %eax
addl $12, %esp
popl %ebp
ret
.subsections_via_symbols
-s code> arrêt dans l'assembleur li>
-
-m32 code> à 32 bits, juste pour simplifier les choses un peu li>
ul> générera le programme suivant, à l'exception des commentaires et des lignes vides que j'ai ajoutées. Jetez un coup d'œil spécialement dans les commentaires. P>
int main()
{
int i = 0;
i += 1;
i++;
i = i + 1;
return 0;
}
Je ne sais pas pourquoi cela n'est pas marqué comme la réponse, puisqu'il fournit une preuve et pas seulement un avis.
Cela devrait être marqué comme la réponse. Nous trouvons-nous également une différence dans d'autres compilateurs ou suivons-t-il le même modèle?
@Sanved merci. Difficile à dire, compte tenu de la quantité de compilateurs. Mais tout compilateur avec un développement décent contiendra probablement cette "intelligence". Les compilateurs ne sont pas uniquement des traducteurs directs du niveau élevé à bas, il y a toute une science impliquée et des exemples comme celui-ci figurent parmi les éléments les plus élémentaires et les premiers éléments de cette science. Donc, tout compilateur moderne et majeur devrait l'inclure.
Cela ressemble à beaucoup d'hypothèses non fondées, en particulier le titre. Je ne vois pas une raison pour laquelle on devrait être plus efficace que l'autre et je suis raisonnablement convaincu que ce n'est pas le cas sur la plupart des compilateurs de C.
Un compilateur vaut l'argent que vous avez payé pour cela compilera les deux expressions au même code d'objet. Si vous êtes inquiet pour la performance: Mesure , mesurer différents code, différents drapeaux de compilation, une utilisation différente des ressources, tout différent.
Savez-vous que x + = 1 est plus efficace que x = x + 1? Avez-vous regardé le code objet généré?
Peut-être que cela était applicable aux compilateurs plus âgés..Je suis curieux de savoir pourquoi on pourrait être plus efficace que l'autre dans un plus ancien compilateur ... J'ai lu à ce sujet dans un livre appelé "Secrets profonds C".
Que diriez-vous de trouver des livres qui n'ont pas de 17 ans?
Il y a éventuellement une différence en C ++ (si
x est un UDT), mais il ne devrait y avoir aucune différence dans C.OK..SO Si X est un type défini par l'utilisateur, comment X = + 1 sera-t-il plus efficace?
Demander à propos de UDTS est une question différente. Cette question concerne C.
Non seulement c'est un duplicata; Cette question a une hypothèse fausse dans la ligne d'objet.
@David: Oui, c'était mon point ...