Les déclarations de variables devraient-elles toujours être évitées en C++?

Question

Parfois, je déclare des variables "à usage unique" dans mon code pour plus de clarté. Est-ce que cela affecte considérablement les performances ou est-ce que le compilateur peut l'optimiser?

Par exemple, je aurais tendance à faire:

int minVal = long_arithmetic_expresion(); 
int maxVal = even_longer_expression(); 

for (int i = minVal; i < maxVal; i++) 
    { 
     // Do stuff not related to minVal or maxVal 
    } 

double part1 = 4*sqrt(something)* ... // Very long thing 
double part2 = 5*sqrt(something else)* ... // Very long thing 

double interestingValue = part1/part2; // This is the only interesting variable for later 

Plutôt que:

for (int i = long_arithmetic_expresion(); i < even_longer_expression(); i++) 
    { 
     // Do stuff not related to minVal or maxVal 
    } 

double interestingValue = (4*sqrt(whatever)* ...)/(5*sqrt(something else)* ...); 

Cette boucle serait contenue dans une fonction qui sera appelée à plusieurs reprises, de sorte que même les performances des petites le gain serait pertinent dans mon cas.

Note:

Comme il a été rapidement fait remarquer, il y a une chance que even_longer_expression() pourrait être évaluée à chaque étape de la boucle, ce qui est évidemment pas bon. Pour plus de clarté, ma question concerne le fait de déclarer des variables à usage unique. J'ai ajouté un peu plus de code après la boucle. Je me réfère à des cas comme les variables part1 et part2.

Answer 1

Est-ce que cela affecte considérablement les performances ou est-ce que le compilateur peut l'optimiser?

dépend totalement:

Si long_arithmetic_expresion() et even_longer_expression() sont marqués comme constexpr et non susceptible de changer au cours de l'exécution, le compilateur peut optimiser des appels récurrents à ces fonctions.

Sinon, il pourrait être préférable d'utiliser les variables initialisées une fois.

Answer 2

Sauf si vous désactivez les optimisations, les codes suivants seraient presque sûrement montrer absolument les mêmes performances sur un compilateur moderne (étant donné que les expressions sont évidemment indépendants):

// save to temporary minVal variable 
int minVal = long_arithmetic_expresion(); 
int maxVal = even_longer_expression(); 
for (int i = minVal; i < maxVal; i++) { 
    ... 
} 

// avoid creating temporary minVal variable 
int maxVal = even_longer_expression(); 
for (int i = long_arithmetic_expresion(); i < maxVal; i++) { 
    ... 
} 

Mais la première version est souvent plus lisible =) La raison est la suivante: copy propagation pour les variables de types fondamentaux est trivial à faire pour un compilateur. Donc, dans la première version du compilateur supprimerait i = minVal affectation.