What is the best/neatest way to suppress a C compiler (for example GCC) like "Unused variable x" warning?
GCC's doumentation explains
-Wunused-variable
Warn whenever a local variable or non-constant static variable is unused aside from its declaration
I don't want to give any certain flags to my compiler to remove all these warnings, just for special cases.
(void) variable might work for some compilers.
For C++ code, also see Mailbag: Shutting up compiler warnings where Herb Sutter recommends using:
template<class T> void ignore( const T& ) { } ... ignore(variable); 
-std=c99
template<class T> void ignore( const T& ) { } works great!
(void) variable is cool because it works for any unused variables, not just function parameters like with the accepted answer.See individual answers for __attribute__((unused)), various #pragmas and so on. Optionally, wrap a preprocesor macro around it for portability.
IDEs can signal unused variables visually (different color, or underline). Having that, compiler warning may be rather useless.
In GCC and Clang, add -Wno-unused-parameter option at the end of the command line (after all options that switch unused parameter warning on, like -Wall, -Wextra).
void foo(int bar) { (void)bar; } As per jamesdlin's answer and Mailbag: Shutting up compiler warnings.
Not allowed in C before the C23 standard, but with a latest compiler (in 2023) and in in C++ (since like forever) one can do
void foo(int /*bar*/) { ... } See the N2480 Allowing unnamed parameters in a function definition (pdf) proposal, and check the implementation status at https://en.cppreference.com/w/c/compiler_support
GCC 11, Clang 11, and ICX 2022.2 (oneAPI 2022.3) support this.
I found an article, http://sourcefrog.net/weblog/software/languages/C/unused.html, that explains UNUSED. It is interesting that the author also mangles the unused variable name, so you can't inadvertently use it in the future.
Excerpt:
#ifdef UNUSED #elif defined(__GNUC__) # define UNUSED(x) UNUSED_ ## x __attribute__((unused)) #elif defined(__LCLINT__) # define UNUSED(x) /*@unused@*/ x #else # define UNUSED(x) x #endif void dcc_mon_siginfo_handler(int UNUSED(whatsig)) 
static const char cvsid[] = "$Id$";. That's short and sweet and readable, but gcc -Wall throws a wobbly on it. I don't want to have to write all this impenetrable code just to suppress that error.
If this is really what you want, you could use the unused attribute (GCC only), something like:
void foo(int __attribute__((__unused__)) bar) { ... } Not just for function parameters, of course, but that's the most common use case, since it might be a callback function for an API where you don't actually need all the input.
Additionally, GLib has a G_GNUC_UNUSED macro which I believe expands to that attribute.
You can silence the warning using #pragma
#pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunused" int unususedVariable = 1; #pragma clang diagnostic pop If you are using GCC, use #pragma gcc ...
#pragma unused <variable>
#pragma unused (variable)The cast to a void is the best approach because it shows that you didn't "accidentally" keep the variable in your code - ie: this function might be an instance where you have a table of function pointers that need the same parameter types and return types, but in this particular table entry you are not using the parameter.
That said, if you don't need it, get rid of it. ;)
It's a very hackish solution, but try simply assigning the variable to itself.
I think that should fool most compilers into thinking that the variable is used. It should be quite portable too.
= operator might be overloaded with side-effects. you never know. cast to void seems better. eg (void)my_unused_thing;
Assign it to itself:
void f(int unused) { unused = unused; } It works in GCC, but Clang needs -Wno-self-assign.
I think casting to void is the most portable solution: Both GCC and Clang understand this, even with full warnings -W{all,extra,pedantic}:
(void)unused; Delete the unused variable declaration from the code (pun intended).
(What??? It's what I do: point that the obvious is most likely the best solution.)
Now, from comments on other answers, apparently it's garbage generated from macros. Well, that's a pleonasm.
Solutions:
If it’s used and you are shipping the project, delete it. Worst, comment it.
void function_name(int par1, char *par2);and you only need to work on par2.void function_name(int par1, char*);which is perfectly valid and won't generate warnings.error: parameter name omitted.