Comment supprimer les avertissements de «parameters non utilisés» dans C?

Par exemple:

Bool NullFunc(const struct timespec *when, const char *who) { return TRUE; } 

En C ++ j’ai pu mettre un commentaire /*...*/ autour des parameters. Mais pas dans C bien sûr, où il me donne l’erreur d’ error: parameter name omitted .

J’écris habituellement une macro comme ceci:

 #define UNUSED(x) (void)(x) 

Vous pouvez utiliser cette macro pour tous vos parameters inutilisés. (Notez que cela fonctionne sur n’importe quel compilateur.)

Par exemple:

 void f(int x) { UNUSED(x); ... } 

Dans gcc, vous pouvez étiqueter le paramètre avec l’ atsortingbut unused .

Cet atsortingbut, attaché à une variable, signifie que la variable est destinée à être éventuellement inutilisée. GCC ne produira pas d’avertissement pour cette variable.

En pratique, ceci est accompli en mettant __atsortingbute__ ((unused)) juste après le paramètre. Par exemple

 auto lambda = [](workerid_t workerId) -> void { }; 

devient

 auto lambda = [](__atsortingbute__((unused)) _workerid_t workerId) -> void { } ; 

Vous pouvez utiliser l’atsortingbut inutilisé de gcc / clang, cependant, j’utilise ces macros dans un en-tête pour éviter d’avoir des atsortingbuts spécifiques à gcc sur toute la source, et avoir __atsortingbute__ partout est un peu compliqué / moche.

 #ifdef __GNUC__ # define UNUSED(x) UNUSED_ ## x __atsortingbute__((__unused__)) #else # define UNUSED(x) UNUSED_ ## x #endif #ifdef __GNUC__ # define UNUSED_FUNCTION(x) __atsortingbute__((__unused__)) UNUSED_ ## x #else # define UNUSED_FUNCTION(x) UNUSED_ ## x #endif 

Alors vous pouvez faire …

 void foo(int UNUSED(bar)) { ... } 

Je préfère cela parce que vous obtenez une erreur si vous essayez d’utiliser des bar dans le code, vous ne pouvez donc pas laisser l’atsortingbut par erreur.

et pour les fonctions …

 static void UNUSED_FUNCTION(foo)(int bar) { ... } 

Note 1):
Pour autant que je sache, MSVC n’a pas d’équivalent à __atsortingbute__((__unused__)) .

Note 2):
La macro UNUSED ne fonctionnera pas pour les arguments contenant des parenthèses,
donc si vous avez un argument comme float (*coords)[3] vous ne pouvez pas le faire,
float UNUSED((*coords)[3]) ou float (*UNUSED(coords))[3] , c’est le seul inconvénient de la macro UNUSED j’ai trouvée jusqu’ici, dans ces cas, je retombe sur des (void)coords;

Avec gcc avec l’atsortingbut inutilisé:

 int foo (__atsortingbute__((unused)) int bar) { return 0; } 

L’étiquetage de l’atsortingbut est le moyen idéal. MACRO mène parfois à la confusion. et en utilisant void (x), nous ajoutons une surcharge au traitement.

Si vous n’utilisez pas l’argument d’entrée, utilisez

 void foo(int __atsortingbute__((unused))key) { } 

Si vous n’utilisez pas la variable définie dans la fonction

 void foo(int key) { int hash = 0; int bkt __atsortingbute__((unused)) = 0; api_call(x, hash, bkt); } 

Maintenant plus tard, en utilisant la variable de hachage pour votre logique, mais sans bkt. définissez bkt comme inutilisé, sinon le compilateur dit que ‘bkt set bt non utilisé “.

NOTE: Ceci est juste pour supprimer l’avertissement pas pour l’optimisation.

Un moyen spécifique de gcc / g ++ pour supprimer l’avertissement de paramètre non utilisé pour un bloc de code source consiste à le joindre aux instructions pragma suivantes:

 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter"  #pragma GCC diagnostic pop 

J’ai le même problème. J’ai utilisé une bibliothèque de troisième partie. Lorsque je comstack cette bibliothèque, le compilateur (gcc / clang) se plaindra des variables non utilisées.

Comme ça

test.cpp: 29: 11: avertissement: variable ‘magic’ définie mais non utilisée [-Wunused-but-set-variable] short magic [] = {

test.cpp: 84: 17: avertissement: variable non utilisée ‘before_write’ [-Wunused-variable] int64_t before_write = Thread :: currentTimeMillis ();

Donc, la solution est assez claire. Ajouter -Wno-unused tant que gcc / clang CFLAG supprime tous les avertissements “inutilisés”, même si vous avez -Wall défini.

De cette façon, vous n’avez pas besoin de changer de code.

Dans MSVC pour supprimer un avertissement particulier, il suffit de spécifier le numéro à comstackr sous / wd #. Mon CMakeLists.txt contient un tel bloc:

 If (MSVC) Set (CMAKE_EXE_LINKER_FLAGS "$ {CMAKE_EXE_LINKER_FLAGS} / NODEFAULTLIB: LIBCMT") Add_definitions (/W4 /wd4512 /wd4702 /wd4100 /wd4510 /wd4355 /wd4127) Add_definitions (/D_CRT_SECURE_NO_WARNINGS) Elseif (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUC) Add_definitions (-Wall -W -pedantic) Else () Message ("Unknown comstackr") Endif () 

Maintenant, je ne peux pas dire exactement ce que / wd4512 / wd4702 / wd4100 / wd4510 / wd4355 / wd4127 signifient, car je ne fais pas attention à MSVC depuis trois ans, mais ils suppriment les avertissements superpédantiques qui n’influencent pas le résultat.

J’ai vu ce style être utilisé:

 if (when || who || format || data || len); 

Voyant que cela est marqué comme gcc, vous pouvez utiliser le commutateur de ligne de commande Wno-unused-parameter .

Par exemple:

 gcc -Wno-unused-parameter test.c 

Bien sûr, cela affecte l’intégralité du fichier (et peut-être le projet en fonction de l’endroit où vous avez défini le commutateur), mais vous n’avez pas à modifier de code.

Pour mémoire, j’aime la réponse de Job ci-dessus, mais je suis curieux de savoir si une solution consiste à utiliser le nom de la variable par lui-même dans une déclaration “do-nothing”:

 void foo(int x) { x; /* unused */ ... } 

Bien sûr, cela a des inconvénients; par exemple, sans la note “inutilisée”, cela ressemble à une erreur plutôt qu’à une ligne de code intentionnelle.

L’avantage est que DEFINE n’est pas nécessaire et qu’il élimine l’avertissement.

Existe-t-il des performances, optimisations ou autres différences?