La déclaration d'une variable dans une boucle entraîne-t-elle des frais supplémentaires ? (C++)

Question

Je me demande simplement s'il y aurait une perte de vitesse ou d'efficacité si vous faisiez quelque chose comme ça :

int i = 0;
while(i < 100)
{
    int var = 4;
    i++;
}

qui déclare int var cent fois. Il me semble qu'il y en aurait, mais je n'en suis pas sûr. Ne serait-il pas plus pratique/rapide de faire ceci à la place :

int i = 0;
int var;
while(i < 100)
{
    var = 4;
    i++;
}

ou sont-ils identiques, en termes de vitesse et d'efficacité ?

Answer 1

L'espace de pile pour les variables locales est généralement alloué dans la portée de la fonction. Donc aucun ajustement du pointeur de pile n'a lieu à l'intérieur de la boucle, il suffit d'assigner 4 à var . Ces deux extraits ont donc la même surcharge.

Answer 2

Pour les types primitifs et les types POD, cela ne fait aucune différence. Le compilateur allouera l'espace de pile pour la variable au début de la fonction et le désallouera au retour de la fonction dans les deux cas.

Pour les types de classes non-POD qui ont des constructeurs non triviaux, cela VA faire une différence -- dans ce cas, placer la variable en dehors de la boucle n'appellera le constructeur et le destructeur qu'une seule fois et l'opérateur d'affectation à chaque itération, alors que la placer à l'intérieur de la boucle appellera le constructeur et le destructeur à chaque itération de la boucle. En fonction de ce que font le constructeur, le destructeur et l'opérateur d'affectation de la classe, cela peut être souhaitable ou non.

Answer 3

Les deux sont identiques, et voici comment vous pouvez le savoir, en regardant ce que fait le compilateur (même sans que l'optimisation soit réglée à un niveau élevé) :

Regardez ce que le compilateur (gcc 4.0) fait à vos exemples simples :

1.c :

main(){ int var; while(int i < 100) { var = 4; } }

gcc -S 1.c

1.s :

_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    movl    $0, -16(%ebp)
    jmp L2
L3:
    movl    $4, -12(%ebp)
L2:
    cmpl    $99, -16(%ebp)
    jle L3
    leave
    ret

2.c

main() { while(int i < 100) { int var = 4; } }

gcc -S 2.c

2.s :

_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        movl    $0, -16(%ebp)
        jmp     L2
L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3
        leave
        ret

A partir de là, vous pouvez voir deux choses : premièrement, le code est le même dans les deux.

Deuxièmement, le stockage de var est alloué en dehors de la boucle :

         subl    $24, %esp

Et finalement, la seule chose dans la boucle est l'affectation et la vérification de la condition :

L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3

Ce qui est à peu près aussi efficace que vous pouvez l'être sans supprimer entièrement la boucle.

Answer 4

De nos jours, il est préférable de la déclarer à l'intérieur de la boucle, sauf s'il s'agit d'une constante, car le compilateur pourra mieux optimiser le code (en réduisant la portée des variables).

Answer 5

La plupart des compilateurs modernes optimisent cela pour vous. Ceci étant dit, j'utiliserais votre premier exemple car je le trouve plus lisible.