Impact(s) de la création d'un grand nombre de variables locales ?

Bonjour à toutes et à tous,

J'ai récupéré une application dont une des fonctions est appelée chaque 30 ms. Cette fonction nécessite beaucoup de variables locales et son code est assez imposant. Ces variables locales ne sont pas toutes utiles et j'en ai déjà supprimé quelques unes. Les variables sont de types différents comme par exemple basique (int, long, double, ...), structure ou classe.

Les variables que j'ai conservé ne sont pas pas déclarées comme static et je me pose les questions suivantes :
Q1 : Dois je modifier la déclaration de ces variables ou pas ?
Q2 : Quel est l'impact sur la rapidité d'exécution si je laisse ces variable non static ?
Q3 : Quel est l'impact au premier appel de la fonction sur la mémoire utilisée si autant que possible je change la déclaration de ces variables en static ?
Q4 : On peut déclarer une classe static ?

D'avance merci pour vos réponses.

++

Quelques éléments de réponse :

Les compilateurs (avec optimisations) arrivent en général très bien à ne pas tenir compte des variables inutilisées. Certains émettent même un warning quand ils en rencontre une.

Les variables locales sont en général allouée sur la pile. Et allouer sur la pile de la place pour mille variables locales coute souvent le même prix que pour une seule (déplacer un pointeur).

Donc je doute que tu gagne quoi que ce soit, sauf s'il y a des classes avec un gros constructeur (mais peut-on alors parler de variable inutile ?).

Dans la fonction, les variables inutiles ne sont pas inutilisées ... simplement il n'est pas toujours nécessaire de stocker la valeur de retour d'une fonction dans une variable et la ligne suivante utiliser cette variable en paramètre d'une fonction ... ce sont ces variables là que j'ai supprimé quand c'était possible.

Donc, pour en revenir à mes moutons, ce n'est pas nécessaire de déclarer les variables en static pour éviter d'avoir à les recréer toutes les 30 ms ? Sauf peut être pour les variables qui sont des grosses classes ou structures ?

Intérêts du static -> variable que l'on ne calculera qu'une seule fois, ou dont la valeur sera partagée entre tous les appels à la fonction.
Gros inconvénient -> pas réentrant

Si la valeur sera calculée à chaque fois, je ne vois pas ce que cela pourrait apporter de plus.
Après, si tu as plusieurs variables, le compilo devrait s'occuper comme un grand de ne faire qu'un seul push sur la pile ; je pense -- à moins que chacun fasse comme il l'entende.

Si dans tous les cas tes variables sont nécessaires à l'ago, je ne vois pas pourquoi tu t'embêtes.

Si tu as des initialisations qui seront toujours identiques entre deux appels -> refactorises, extraits un objet dont certaines variables seront initialisées une bonne fois pour toutes, et qui contiendra ton algo dans ses fonctions membres.


Mais de toutes façons, quand on doit optimiser, on passe un profiler. On ne part pas à l'aveuglette comme tu me sembles être en train de le faire.


PS: Les variables de retour nommées ont un mauvais impact sur le RVO. Par contre, elles sont débugables. Et pour ça, je suis prêt à payer.

Ok, merci pour toutes ces informations.

J'étais effectivement sur une mauvaise voie en tentant d'essayer d'optimiser le code sans analyse détaillée ... je n'ai fait que très peu de modifications et du coup, avant de recevoir ta réponse Luc, je restauré la version précédente de mon code. En attendant je suis en train de me former à l'utilisation du profiler livré avec VisualC++ Entreprise.

Bref, je vais prendre en considération toutes les réponses, analyser en détail le code en utilisant le profiler et ensuite seulement je déciderai de ce qui doit être fait.

Merci à tout le monde.