How do I best silence a warning about unused variables

Question

I have a cross platform application and in a few of my functions not all the values passed to functions are utilised   Hence I get a warning from GCC telling me that there are unused variables   What would be the best way of coding around the warning   An  ifdef around the function     ifdef  MSC VER void ProcessOps  sendToExternalApp QString sAppName  QString sImagePath  qreal qrLeft  qreal qrTop  qreal qrWidth  qreal qrHeight   else void ProcessOps  sendToExternalApp QString sAppName  QString sImagePath  qreal   qrLeft    qreal   qrTop    qreal   qrWidth    qreal   qrHeight     endif     This is so ugly but seems like the way the compiler would prefer   Or do I assign zero to the variable at the end of the function   which I hate because it s altering something in the program flow to silence a compiler warning    Is there a correct way

User · Answer

In C  11  this is the solution I m using   template lt typename    Ts gt  inline void Unreferenced Ts amp  amp          int Foo int bar         Unreferenced bar       return 0     int Foo2 int bar1  int bar2         Unreferenced bar1  bar2       return 0      Verified to be portable  at least on modern msvc  clang and gcc  and not producing extra code when optimizations are enabled  With no optimization  the extra function call is performed and references to the parameters are copied to the stack  but there are no macros involved   If the extra code is an issue  you can use this declaration instead    decltype Unreferenced bar1  bar2   0    but at that point  a macro provides better readability    define UNREFERENCED         decltype Unreferenced   VA ARGS     0

User · Answer

An even cleaner way is to just comment out variable names   int main int    argc     char const      argv         return 0

User · Answer

C  17 now provides the   maybe unused   attribute   http   en cppreference com w cpp language attributes  Quite nice and standard

User · Answer

You can use   unused to tell the compiler that variable might not be used   -  void myMethod    unused NSObject   theObject              there will be no warning about  theObject   because you wrote    unused         unused int theInt   0         there will be no warning  but you are still able to use  theInt  in the future

User · Answer

I have seen this instead of the  void param2 way of silencing the warning   void foo int param1  int param2        std  ignore   param2      bar param1       Looks like this was added in C  11

User · Answer

I found most of the presented answers work for local unused variable only  and will cause compile error for unused static global variable    Another macro needed to suppress the warning of unused static global variable   template  lt typename T gt  const T  UNUSED VARIABLE const T amp  dummy         return  amp dummy     define UNUSED GLOBAL VARIABLE x  namespace        const auto dummy   UNUSED VARIABLE x       static int a   0  UNUSED GLOBAL VARIABLE a    int main          int b   3      UNUSED VARIABLE b       return 0      This works because no warning will be reported for non-static global variable in anonymous namespace    C   11 is required though   g    -Wall -O3  -std c  11 test cpp

User · Answer

I don t see your problem with the warning  Document it in the method function header that compiler xy will issue a  correct  warning here  but that theses variables are needed for platform z   The warning is correct  no need to turn it off  It does not invalidate the program - but it should be documented  that there is a reason

User · Answer

Is it not safe to always comment out parameter names  If it s not you can do something like   ifdef  MSC VER   define P  n  n  else   define P  n   endif  void ProcessOps  sendToExternalApp      QString sAppName  QString sImagePath      qreal P  qrLeft   qreal P  qrTop   qreal P  qrWidth   qreal P  qrHeight     It s a bit less ugly

User · Answer

C  17 Update  In C  17 we gain the attribute   maybe unused   which is covered in  dcl attr unused      The attribute-token maybe unused indicates that a name or entity is possibly intentionally unused  It shall   appear at most once in each attribute-list and no attribute-argument-clause shall be present             Example      maybe unused   void f   maybe unused   bool thing1                            maybe unused   bool thing2        maybe unused   bool b   thing1  amp  amp  thing2      assert b            Implementations should not warn that b is unused  whether or not NDEBUG is defined     end example     For the following example   int foo   int bar        bool unused bool       return 0      Both clang and gcc generate a diagnostic using -Wall -Wextra for both bar and unused bool  See it live    While adding   maybe unused   silences the diagnostics   int foo    maybe unused   int bar          maybe unused   bool unused bool       return 0      see it live   Before C  17  In C  11 an alternative form of the UNUSED macro could be formed using a lambda expression via  Ben Deane  with an capture of the unused variable    define UNUSED x    amp x        The immediate invocation of the lambda expression should be optimized away  given the following example   int foo  int bar        UNUSED bar        return 0      we can see in godbolt that the call is optimized away   foo int   xorl     eax   eax ret

User · Answer

You can put it in   void var   expression  does nothing  so that a compiler sees it is used  This is portable between compilers   E g   void foo int param1  int param2         void param2      bar param1       Or    define UNUSED expr  do    void  expr     while  0       void foo int param1  int param2        UNUSED param2       bar param1

User · Answer

Using an UNREFERENCED PARAMETER p  could work  I know it is defined in WinNT h for Windows systems and can easily be defined for gcc as well  if it doesn t already have it    UNREFERENCED PARAMETER p  is defined as   define UNREFERENCED PARAMETER P            P    in WinNT h

User · Answer

Using preprocessor directives is considered evil most of the time  Ideally you want to avoid them like the Pest  Remember that making the compiler understand your code is easy  allowing other programmers to understand your code is much harder  A few dozen cases like this here and there makes it very hard to read for yourself later or for others right now   One way might be to put your parameters together into some sort of argument class  You could then use only a subset of the variables  equivalent to your assigning 0 really  or having different specializations of that argument class for each platform  This might however not be worth it  you need to analyze whether it would fit   If you can read impossible templates  you might find advanced tips in the  Exceptional C    book  If the people who would read your code could get their skillset to encompass the crazy stuff taught in that book  then you would have beautiful code which can also be easily read  The compiler would also be well aware of what you are doing  instead of hiding everything by preprocessing

User · Answer

First off the warning is generated by the variable definition in the source file not the header file  The header can stay pristine and should  since you might be using something like doxygen to generate the API-documentation    I will assume that you have completely different implementation in source files  In these cases you can either comment out the offending parameter or just write the parameter    Example   func int a  int b        b      foo a       This might seem cryptic  so defined a macro like UNUSED  The way MFC did it is    ifdef  DEBUG  define UNUSED x   else  define UNUSED x  x  endif   Like this you see the warning still in debug builds  might be helpful

User · Answer

Your current solution is best - comment out the parameter name if you don t use it  That applies to all compilers  so you don t have to use the pre-processor to do it specially for GCC

User · Answer

This works well but requires C  11  template  lt typename    Args gt  void unused Args amp  amp     args       void  sizeof    args

User · Answer

In GCC and Clang you can use the   attribute    unused   preprocessor directive to achieve your goal  For example   int foo    attribute    unused   int bar       return 0

User · Answer

Lol  I dont think there is another question on SO that reveal all the heretics corrupted by Chaos better that this one    With all due respect to C  17 there is a clear guideline in C   Core Guidelines  AFAIR  back in 2009 this option was available as well as today  And if somebody says it is considered as a bug in Doxygen then there is a bug in Doxygen

User · Answer

Use compiler s flag  e g  flag for GCC  -Wno-unused-variable

User · Answer

A coworker just pointed me to this nice little macro here  For ease I ll include the macro below    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

User · Answer

gcc doesn t flag these warnings by default   This warning must have been turned on either explicitly by passing -Wunused-parameter to the compiler or implicitly by passing -Wall -Wextra  or possibly some other combination of flags    Unused parameter warnings can simply be suppressed by passing -Wno-unused-parameter to the compiler  but note that this disabling flag must come after any possible enabling flags for this warning in the compiler command line  so that it can take effect

User · Answer

macro-less and portable way to declare one or more parameters as unused   template  lt typename    Args gt  inline void unused Args amp  amp          int main int argc  char  argv          unused argc  argv       return 0

[c++] How do I best silence a warning about unused variables?

Examples related to c++

Examples related to gcc

Examples related to warnings

Examples related to gcc-warning