Est-il bon ou mauvais de réutiliser les variables?

Je me demande si c‘est bon ou mauvais (ou peu importe) si je réutilise autant que possible les noms de variables? par exemple

int main(void){ //... int x=0; //.. x = atoi(char_var); //.. for (x=0; x<12; x++){ //... } //.. x = socket(...) if(x<0){ //... } for(x=0;x<100;x++{ //... } return 0; } 

Une autre variable pourrait être utilisée à la place de x ci-dessus (ce qui pourrait être meilleur pour la lisibilité), mais je me demande si cela me procurerait un avantage en termes de taille binary, de performances ou autre chose?

En général, il est très peu courant de réutiliser des noms de variables à des fins différentes – si quelqu’un d’autre a besoin de maintenir votre code ultérieurement, il devra trouver ces “changements de contexte” dans votre code, où x signifie soudainement autre chose que ce que cela signifiait auparavant. cette ligne de code.

Vous économiserez peut-être de la mémoire, mais elle est tellement minime comparée aux problèmes qu’elle pose, c’est déconseillée. (Lisez aussi l’édition ci-dessous.)

En règle générale, il est également recommandé de ne pas utiliser de noms de variable à un caractère pour des compteurs autres que des compteurs de boucles. On pourrait argumenter que x pourrait aussi être une coordonnée X mais j’utiliserais un préfixe ou un nom plus long dans ce cas. Les noms de variable d’une lettre sont trop courts pour donner des indications significatives sur le but d’une variable.

Edit : comme plusieurs commentaires (et quelques-unes des autres réponses) l’ont souligné, les économies de mémoire potentielles (le cas échéant) dépendent de la qualité du compilateur. Les compilateurs d’optimisation bien rédigés peuvent se rendre compte que deux variables n’ont pas de durée de vie qui se chevauchent, de sorte qu’ils n’allouent de toute façon qu’un seul emplacement de variable. Le résultat final serait un gain d’exécution et un code source encore moins gérable. Cela ne fait que renforcer l’argument: ne réutilisez pas les variables.

Comme avec presque tout dans la programmation, cela dépend de la situation.

Si vous réutilisez la même variable à des fins différentes, cela rend votre code moins lisible et vous ne devriez pas le faire. Si l’objective est le même (par exemple, les compteurs de boucles), vous pouvez le réutiliser sans problème car cela ne rend pas votre code moins lisible.

La réutilisation d’une variable évite de réserver de l’espace dans la stack, ce qui se traduit par un programme plus rapide (vous ne perdez pas de temps à réserver de l’espace dans la stack et à pousser la valeur) et à moins de mémoire (vous ne le stockez pas dans la stack). Mais ces avantages sont absolument négligeables dans l’ensemble du contexte du programme, ainsi que par rapport à l’architecture, au langage et au compilateur. Je m’inquiéterais donc davantage de la lisibilité que de ces petits avantages.

Mal. Pour les types simples tels que int s, passés par valeur, le compilateur sera en mesure de déterminer s’ils ne sont plus nécessaires et de réutiliser l’espace.

Par exemple, j’ai compilé le code C ++ suivant dans Visual Studio 2010 en utilisant le mode de libération 32 bits:

 for (int i = 0; i < 4; ++i) { printf("%d\n", i); } for (int j = 0; j < 4; ++j) { printf("%d\n", j); } 

et a obtenu la sortie suivante de l'assembleur:

 ; 5 : for (int i = 0; i < 4; ++i) mov edi, DWORD PTR __imp__printf xor esi, esi npad 6 $LL6@main: ; 6 : { ; 7 : printf("%d\n", i); push esi push OFFSET ??_C@_03PMGGPEJJ@?$CFd?6?$AA@ call edi inc esi add esp, 8 cmp esi, 4 jl SHORT $LL6@main ; 8 : } ; 9 : ; 10 : for (int j = 0; j < 4; ++j) xor esi, esi $LL3@main: ; 11 : { ; 12 : printf("%d\n", j); push esi push OFFSET ??_C@_03PMGGPEJJ@?$CFd?6?$AA@ call edi inc esi add esp, 8 cmp esi, 4 jl SHORT $LL3@main ; 13 : } 

Vous pouvez voir que le compilateur utilise le registre esi pour i et j .

  int x=0; //.. x = atoi(char_var); //.. int x = 0; 

Vous ne pouvez pas redéclarer x dans la même scope. Si vous ne le redéclarez pas mais si vous l’utilisez à des fins différentes, vous êtes libre de le faire. Mais c’est une mauvaise pratique et doit être évité car cela diminue la lisibilité du code. Aussi, vous devriez trouver des noms significatifs pour vos variables pour les mêmes raisons.

Vous pouvez le réutiliser mais je ne pense pas que cela apportera un avantage significatif à votre programme et rendra votre code moins lisible.

Exprimez-le de la manière suivante: comment l’apprécieriez-vous si j’écrivais une telle stack de code complexe non documenté et complexe et que vous deviez ensuite le maintenir / l’améliorer?

S’il vous plaît ne faites pas une telle chose, jamais 🙂

En règle générale, quelle que soit la langue utilisée, si vous réutilisez des noms de variable et décidez ensuite de refactoriser une partie de votre code dans une autre méthode, vous devrez donc append ou modifier des déclarations.

 int i; for(i = 0; i < 10; ++i) { printf("%d\t%d\n", i , i * i); } for(i = 0; i < 10; ++i) { printf("%d\t%d\n", i , i * i * i); } 

Supposons que vous preniez la seconde boucle et la déplaciez vers une méthode print_cubes . Vous ne pourrez pas simplement couper et coller la boucle for, car i n’aurai aucune déclaration à cet endroit. Un bon IDE pourrait peut-être insérer la déclaration, mais il pourrait s'inquiéter des effets secondaires sur i dans le code que vous avez tapé.

En général, les compilateurs peuvent consolider les variables utilisées à l'aide d'algorithmes de coloration de graphes. Considérons cette variante:

 for(int i = 0; i < 10; ++i) { // BLOCK 1 printf("%d\t%d\n", i , i * i); } // END BLOCK 1 for(int j = 0; j < 10; ++j) { // BLOCK 2 printf("%d\t%d\n", j , j * j * j); } // END BLOCK 2 

Le compilateur répertorie les variables utilisées: i , j . Il répertorie les blocs utilisés: BLOC 1, BLOC 2. La fonction parent est également un bloc, mais i et j sont visibles que dans les BLOC 1 et BLOCK 2. Elle crée donc un graphique des variables et ne les connecte que si ils sont visibles dans le même bloc. Il essaie ensuite de calculer le nombre minimum de couleurs nécessaire pour colorer chaque sumt sans donner la même couleur à deux sumts adjacents, similaire au théorème de Haken-Appel Four Color. Ici; une seule couleur est nécessaire.

Il est préférable de réutiliser les variables en termes de mémoire. Attention toutefois, vous n’avez pas besoin de la valeur d’une variable avant de la réutiliser. Sinon, vous ne devriez pas toujours utiliser la variable. Il est important de garder un code propre et lisible. Je vous conseille donc de choisir différentes variables avec des noms en fonction du contexte afin que votre code ne devienne pas déroutant.

Vous devriez également examiner l’allocation dynamic de mémoire en C, ce qui est très utile pour gérer la mémoire et les variables.

https://en.wikipedia.org/wiki/C_dynamic_memory_allocation

Seul inconvénient est la lisibilité de votre code.

En réutilisant les variables, vous économisez de la mémoire.

La vitesse n’est pas affectée (sauf si vous devez utiliser plus d’instructions pour pouvoir réutiliser une variable).