Comment supprimer les avertissements de «paramètre inutilisé» en C?

Par exemple:

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

En C ++, j'ai pu mettre un /*...*/commentaire sur les paramètres. Mais pas en C bien sûr, où ça me donne l'erreur error: parameter name omitted.

J'écris généralement une macro comme celle-ci:

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

Vous pouvez utiliser cette macro pour tous vos paramètres 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' unusedattribut .

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

En pratique, cela se fait en mettant __attribute__ ((unused))juste avant le paramètre. Par exemple:

void foo(workerid_t workerId) { }

devient

void foo(__attribute__((unused)) workerid_t workerId) { }

Vous pouvez utiliser l'attribut inutilisé de gcc / clang, mais j'utilise ces macros dans un en-tête pour éviter d'avoir des attributs spécifiques à gcc partout dans la source, avoir aussi __attribute__partout est un peu bavard / laid.

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

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

Ensuite, vous pouvez faire ...

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

Je préfère cela parce que vous obtenez une erreur si vous essayez d'utiliser barle code n'importe où, vous ne pouvez donc pas laisser l'attribut 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 à __attribute__((__unused__)).

Note 2):
La UNUSEDmacro ne fonctionnera pas pour les arguments qui contiennent 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 UNUSEDmacro que j'ai trouvé jusqu'à présent, dans ces cas, je retombe à(void)coords;

Avec gcc avec l'attribut inutilisé:

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

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'ensemble du fichier (et peut-être le projet en fonction de l'endroit où vous définissez le commutateur), mais vous n'avez pas à modifier de code.

Une manière spécifique à gcc / g ++ de supprimer l'avertissement de paramètre inutilisé pour un bloc de code source consiste à le joindre aux instructions pragma suivantes:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
<code with unused parameters here>
#pragma GCC diagnostic pop

L'étiquetage de l'attribut est le moyen idéal. MACRO conduit parfois à la confusion. et en utilisant void (x), nous ajoutons une surcharge dans le traitement.

Si vous n'utilisez pas d'argument d'entrée, utilisez

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

Si vous n'utilisez pas la variable définie à l'intérieur de la fonction

void foo(int key)
{
   int hash = 0;
   int bkt __attribute__((unused)) = 0;

   api_call(x, hash, bkt);
}

Maintenant, utilisez plus tard la variable de hachage pour votre logique, mais n'a pas besoin de bkt. définir bkt comme inutilisé, sinon le compilateur dit "bkt set bt not used".

REMARQUE: il s'agit simplement de supprimer l'avertissement et non d'optimiser.

J'ai le même problème. J'ai utilisé une bibliothèque tierce. Lorsque je compile cette bibliothèque, le compilateur (gcc / clang) se plaindra des variables inutilisé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 inutilisée 'before_write' [-Wunused-variable] int64_t before_write = Thread :: currentTimeMillis ();

La solution est donc assez claire. L'ajout en -Wno-unusedtant que gcc / clang CFLAG supprimera tous les avertissements "inutilisés", même si vous les avez -Walldéfinis.

De cette façon, vous N'AVEZ PAS BESOIN de modifier un code.

Dans MSVC pour supprimer un avertissement particulier, il suffit de spécifier le numéro à compiler sous / wd #. Mon CMakeLists.txt contient tel le 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 compiler")
Endif ()

Maintenant, je ne peux pas dire ce que signifie exactement / wd4512 / wd4702 / wd4100 / wd4510 / wd4355 / wd4127, car je ne prête aucune attention à MSVC pendant trois ans, mais ils suppriment les avertissements superpédantaires qui n'influencent pas le résultat.

J'ai vu ce style utilisé:

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

Pour mémoire, j'aime la réponse de Job ci-dessus, mais je suis curieux de voir une solution utilisant simplement le nom de variable par lui-même dans une instruction "ne rien faire":

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 qu'aucun DEFINE n'est nécessaire et il supprime l'avertissement.

Existe-t-il des différences de performances, d'optimisation ou autres?