How do I best silence a warning about unused variables?

Question

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);
}

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;
}

C++17 now provides the [[maybe_unused]] attribute.

http://en.cppreference.com/w/cpp/language/attributes

Quite nice and standard.

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.

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 && 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) [&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

An even cleaner way is to just comment out variable names:

int main(int /* argc */, char const** /* argv */) {
  return 0;
}