Variables inutilisées en C/C : pourquoi et comment ?

Lors de la révision du code C/C, nous trouvons assez souvent des variables qui ne sont jamais utilisées. De telles variables inutilisées se produisent pour diverses raisons. Dans cet article, nous examinons certaines des causes les plus courantes pour lesquelles des variables inutilisées apparaissent dans le code C/C. Nous examinons comment demander au compilateur d'avertir des variables inutilisées et comment supprimer les avertissements pour des variables inutilisées spécifiques.

Pourquoi les variables ne sont pas utilisées

Il existe de nombreuses raisons pour lesquelles des variables inutilisées peuvent rester dans une base de code. Ceux-ci incluent :

1. Bogues et erreurs : la raison la plus évidente pour une variable inutilisée est un code défectueux. Soit la variable n'est vraiment pas du tout nécessaire et peut être supprimée, soit la variable est nécessaire mais nous avons oublié de l'utiliser à certains moments critiques.

2. Refactoring : Au fur et à mesure que le logiciel est écrit et réécrit, des sections entières de code peuvent être supprimées. Les variables qui étaient autrefois vitales pour le code, telles que les résultats des calculs auxiliaires, peuvent alors être laissées de côté, inutilisées.

3. Pérennité : les variables inutilisées peuvent apparaître non seulement comme un héritage du code passé, mais également comme un héritage du code futur. Vous pouvez déclarer des variables en prévision du code qui n'a pas encore été écrit.

4. Compilation conditionnelle : les variables peuvent rester inutilisées en fonction de la phase du préprocesseur. Un exemple standard est une variable définie uniquement à des fins de débogage. Votre code peut contenir quelque chose du formulaire
   

const auto value = compute_some_value();
const auto value_for_comparison_only = compute_same_value_differently();
assert( value == value_for_comparison_only );

Si vous compilez avec -DNDEBUG, alors le compilateur pourrait vous avertir que value_for_comparison_only n'est jamais utilisé : en effet, l'instruction assert a été remplacée par… rien.

Comment détecter les variables inutilisées

Différents compilateurs et paramètres de niveau d'avertissement peuvent influencer le fait qu'une variable soit signalée comme inutilisée pendant le processus de compilation.

Par exemple, GCC et Clang comportent l'indicateur -Wunused-variable, qui déclenche des avertissements concernant les variables inutilisées. Le drapeau est déjà impliqué par l'option d'avertissement -Wall, et il peut être désactivé via -Wno-unused-variable.

Ma recommandation est de toujours compiler avec -Wall, puis de désactiver sélectivement les avertissements lorsque cela est autorisé. Ce seront toutes les instances de variables inutilisées.

Comment ne pas détecter les variables inutilisées : les attributs

Bien que nous devrions toujours compiler avec autant d'avertissements activés que possible, il existe des circonstances dans lesquelles nous souhaitons désactiver de manière sélective les avertissements concernant certaines variables inutilisées. Une façon populaire de le faire est de lancer un plâtre pour annuler :

Object unused_object;
(void)unused_object;

Le cast to void compte comme une utilisation (pro forma) de la variable, donc aucun avertissement ne sera émis.

Bien que cela supprime les avertissements indiquant que unused_object n'est pas utilisé, comme prévu, il existe des moyens d'améliorer cela. Nous aimerions avoir une sémantique explicite indiquant que ce vide signifie un objet inutilisé. Une méthode courante consiste à définir une macro :

const auto value = compute_some_value();
const auto value_for_comparison_only = compute_same_value_differently();
assert( value == value_for_comparison_only );

Un avantage est que nous communiquons désormais explicitement l'intention (ou l'absence d'intention) de cette variable. De plus, si l'on décide de purger le code des variables inutilisées, alors leur recherche est beaucoup plus simple.

Au-delà des macros, nous avons des attributs variables : soit natifs du langage C, soit comme extension de langage fournie par les compilateurs C/C. Par exemple, Clang et GCC autorisent l'attribut variable __attribute__((unused)). C 17 prend en charge l'attribut [[maybe_unused]] :

Object unused_object;
(void)unused_object;

Ces attributs communiquent au compilateur (et à nous) que ces variables pourraient être inutilisées et que cela nous convient parfaitement.

Historiquement, les attributs GCC sont apparus en premier, étant des extensions de langage spécifiques au compilateur en C et C . À partir du C 17, les attributs font partie du standard linguistique. Cependant, non seulement l'orthographe est différente, mais les extensions standard et GCC ne s'accordent pas sur l'endroit où placer l'attribut.

L'attribut [[maybe_unused]] trouvera la plupart de ses applications avec la compilation conditionnelle. Par exemple, il s'agit d'un attribut naturel pour les variables de débogage uniquement. Pour des raisons purement esthétiques, je préfère personnellement définir une macro #define MAYBE_UNUSED [[maybe_unused]] .

Un avantage de __attribute__((unused)) est qu'il vous avertira si la variable est utilisée dans le code. Ce n'est pas peut-être inutilisé mais certainement jamais utilisé, et l'utilisation de la variable produira désormais un avertissement.

Garder les choses inutiles

Apparemment, les variables inutilisées sont suffisamment fréquentes et importantes pour justifier même leurs propres extensions de langage.

En comparaison, commenter la variable inutilisée est-il une bonne stratégie ? Pas toujours ! Il y a des raisons pour lesquelles vous conserveriez une variable inutilisée tout au long du code de développement et de la phase de débogage. Supposons que la variable ait été utilisée dans une version antérieure du code, peut-être n'avez-vous même pas encore décidé si l'ancien code doit être mis de côté ou réintégré ; ce qui signifie : vous ne savez pas si vous pourriez avoir à nouveau besoin de la variable inutilisée.

Il peut être utile à des fins de débogage de conserver le code comme :

#define UNUSED(x) (void)(x);
// ...
Object unused_object;
UNUSED(unused_object);

Même si le résultat du calcul compliqué n'est jamais utilisé, le conserver constitue un autre point d'échec… et c'est exactement ce que vous souhaitez lors du débogage. Même si elle n'est pas initialement destinée au débogage, faire en sorte que le programme initialise cette variable sera utile si jamais vous décidez que vous en avez (à nouveau) besoin.

J'espère que cet article sur les variables inutilisées vous a été utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!