Variadic UNUSED function/macro

I took Dabo's (https://stackoverflow.com/a/23238813/5126486) awesome solution and improved a little bit so it's easier to extend to more than 5:

#define UNUSED0()
#define UNUSED1(a)                  (void)(a)
#define UNUSED2(a,b)                (void)(a),UNUSED1(b)
#define UNUSED3(a,b,c)              (void)(a),UNUSED2(b,c)
#define UNUSED4(a,b,c,d)            (void)(a),UNUSED3(b,c,d)
#define UNUSED5(a,b,c,d,e)          (void)(a),UNUSED4(b,c,d,e)

#define VA_NUM_ARGS_IMPL(_0,_1,_2,_3,_4,_5, N,...) N
#define VA_NUM_ARGS(...) VA_NUM_ARGS_IMPL(100, ##__VA_ARGS__, 5, 4, 3, 2, 1, 0 )

#define ALL_UNUSED_IMPL_(nargs) UNUSED ## nargs
#define ALL_UNUSED_IMPL(nargs) ALL_UNUSED_IMPL_(nargs)
#define ALL_UNUSED(...) ALL_UNUSED_IMPL( VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__ )

Here is a very simple approach that does not require any special tricks nor does it incur any runtime overhead.

Original Answer (C++ only)

#define UNUSED(...) (void)sizeof(__VA_ARGS__)

https://godbolt.org/z/Gz8MfvaTz

Updated Answer (C and C++)

I had forgotten to change the compiler from C++ to C, and thus the revised answer.

int main(int argc, char ** argv)
{
    /* different types */
    UNUSED(argc, argv);

    /* many variables */
    int w, x, y, z;
    UNUSED(w, x, y, z);

    /* single variable */
    void * ptr;
    UNUSED(ptr);
}

MSVC
/O2 /W4
No warnings from C and C++ compilers.

Clang
-O3 -Wall -Wextra
No warnings from C and C++ compilers.

GCC
-O3 -Wall -Wextra
No warnings from C++ compiler only. For the C compiler, only the last parameter is ignored without warning. So at worst case, this version of UNUSED is on par with the traditional #define UNUSED(x) ((void)x).

What do you think about this:

#define UNUSED(...) [__VA_ARGS__](){};

Example:

void f(int a, char* b, long d)
{
    UNUSED(a, b, d);
}

Should be expanded ad a lambdas definition:

[a,b,d](){}; //optimized by compiler (I hope!)

===== Tested with http://gcc.godbolt.org ===== I've tryed with this code:

#define UNUSED(...) [__VA_ARGS__](){};

int square(int num, float a) {
  UNUSED(a);
  return num * num;
}

The resulting output (compiled with -O0 -Wall) is:

square(int, float):
    pushq   %rbp
    movq    %rsp, %rbp
    movl    %edi, -4(%rbp)
    movss   %xmm0, -8(%rbp)
    movl    -4(%rbp), %eax
    imull   -4(%rbp), %eax
    popq    %rbp
    ret

EDIT:

If you can use C++11 this could be a better solution :

template <typename ...Args>
void UNUSED(Args&& ...args)
{
    (void)(sizeof...(args));
}

The following causes no warnings with -Wall -Wextra on both GCC and Clang, but only works for C11 and higher:

#define UNUSED(...) ((void)sizeof((_Bool[]){__VA_ARGS__}))

A little refined version of the solution in the question that accepts any type of arguments:

static inline void UNUSED2(int dummy, ...)
{
    (void)dummy;
}
#define UNUSED(...) UNUSED2(0, __VA_ARGS__)

Seems to be working with several compilers, not only GCC.

You can use compile time __VA_ARGS__ macro.

#define UNUSED(...) (void)(__VA_ARGS__)

UPDATE: After lot of trials, I came up to an optimized solution:

#define UNUSED(...)  __VA_ARGS__

int main()
{
    int e, x;
    char **a, **b, *c, d[45];
    x = x, UNUSED(a, b, c, d, e), x; 

    return 0;
}

NOTES:

1. It doesn't eliminate warnings completely but reduces them to just 3 same type of warnings:
   warning: value computed is not used

2. The first and last x ensure assignment of same datatypes.

3. I will say it is optimized because for any number of unused variables it gives 3 warnings (I may be wrong, please test it yourself and do report me if you get more) and the amount of code (MACRO manipulations) required to achieve it is less.

4. I am still working on it, will post if I reach to any better solution.