How to mark a constexpr function's parameter unused?

Question

Consider this classic example:

template <typename T, std::size_t N>
constexpr std::size_t arraySize(T (&array)[N]) noexcept { return N; }

Now this works fine, but there is one annoyance, gcc gives a warning:

warning: unused parameter ‘array’ [-Wunused-parameter]

Known solutions:

• Doesn't work: If I add the classic (void)arr; to the function, I get error: body of constexpr function ‘...‘ not a return-statement.
• Unsatisfactory: I can have arraySize(T (&)[N]), but I want to name the argument for two reasons:
  1. It makes compiler error message more understandable.
  2. More subjectively, I think it makes the code clearer, especially to those who don't live and breathe that syntax.
• Not good: In this particular example, I could also return sizeof(array)/sizeof(array[0]);, but this approach is not universal solution, and also I think return N; is much nicer, definitely easier on the eye.
• Good but not always possible: switch to using C++14 and compiler which supports it fully. Then constexpr function body like { (void)array; return N; } is allowed.

How can I get rid of the unused parameter warning nicely, when using C++11?

Answer 1

Try this. I use this method sometimes

template <typename T, std::size_t N>
constexpr std::size_t arraySize(T (& /*array*/ )[N]) noexcept { return N; }

Answer 2

I'd suggest the following (ab)use of the comma operator:

return (void)array, N;

Answer 3

For new googlers:

C++17 adds a [[maybe_unused]] attribute which could be used like this:

template <typename T, std::size_t N>
constexpr std::size_t arraySize(T (&array)[N] [[maybe_unused]]) noexcept { return N; }

Answer 4

The best solution is the one forbidden with the second point, that is to use T(&)[N].

Another possible approach, as from the comment, is to use the following return value:

return array ? N : N;

I'm quite sure that the compiler will get rid of it and there will be no performance issue at runtime.

Answer 5

As @fnc12 and @skypjack both point out, the idiomatic way to silence an unused parameter compiler warning is to not give a name to the parameter.

constexpr std::size_t arraySize(T (& /*array*/ )[N]) noexcept { return N; }

Using the /**/ comments solves the readability objection. It doesn't fix the name in a compiler message, but I would argue that the most likely situation to arise from this is "undeclared identifier", which is pretty easy and obvious to solve once you notice the identifier is commented.

If you're really dead set against the idiomatic way, then just suppress the warning (locally if your compiler allows it).

Suppressing warnings in GCC using #pragma GCC diagnostic.

Suppressing warnings in Visual Studio using #pragma warning suppress

I recommend against adding "dummy" references to the code to shut up the compiler. Referencing an otherwise unused parameter for no reason than to suppress a compiler warning needlessly adds complexity to your code, and can confuse future maintainers as to why it's there.

Answer 6

The unnamed argument is the right solution.

So you may use a intermediate function:

template <typename T>
constexpr void avoid_warning_for_unused_parameter(T&&) noexcept{}

and then:

template <typename T, std::size_t N>
constexpr std::size_t arraySize(T (&array)[N]) noexcept
{
    avoid_warning_for_unused_parameter(array);
    return N;
}

For C++11, you have to hack little more:

template <typename... Ts>
constexpr auto return_first_and_avoid_warning_for_unused_parameters(T&&t, Ts&&) noexcept
-> decltype(t)
{
    return t;
}

template <typename T, std::size_t N>
constexpr std::size_t arraySize(T (&array)[N]) noexcept
{
    return return_first_and_avoid_warning_for_unused_parameters(N, array);
}

Answer 7

gcc provides the unused attribute which can be used as follows:

constexpr std::size_t arraySize(__attribute__((unused)) T (&array)[N]) noexcept { return N; }
                                ^^^^^^^^^^^^^^^^^^^^^^^

Ben Deane recently tweatted about a C++11 way to suppress this warning using lambdas which combined with the comma operator would look something like this:

#define UNUSED(x) [&x]{}()

//...

return UNUSED(array), N;