This rule is part of MISRA C++:2023.
Usage of this content is governed by Sonar’s terms and conditions. Redistribution is
prohibited.
Rule 0.2.2 - A named function parameter shall be used [1] at least once
Category: Required
Analysis: Decidable,Single Translation Unit
Amplification
This rule does not apply to parameters that are declared [[maybe_unused]].
Note: this rule also applies to the parameters of a lambda.
Rationale
It is expected that most functions will use [1] their parameters. If a function parameter is unused [2], it is possible that the
implementation of the function may not satisfy its requirements. This rule helps to highlight such potential mismatches.
In cases where an unused [2] parameter is required, for example when defining a virtual function or a callback [3] function, the
parameter can be left unnamed. Where the use of a parameter depends on the expansion of a macro or varies between different template instantiations,
then the parameter can be declared [[maybe_unused]].
Example
class B
{
public:
virtual int16_t f( int16_t a, int16_t b );
};
class D1 : public B
{
public:
int16_t f( int16_t a, int16_t b ) override // Non-compliant - 'b' unused
{
return a;
}
};
class D2 : public B
{
public:
int16_t f( int16_t a, // Compliant - 'a' is used
int16_t ) override // Rule does not apply - unnamed parameter
{
return a;
}
};
class D3 : public B
{
public:
int16_t f( int16_t a, int16_t b ) override // Compliant
{
return a + b;
}
};
class D4 : public B
{
public:
int16_t f( int16_t a, // Compliant
int16_t b [[maybe_unused]] ) override // Rule does not apply -
// declared [[maybe_unused]]
{
assert( b > 0 ); // assert macro may expand to nothing,
// leaving 'b' unused.
return a;
}
};
void f1(int32_t i, // Non-Compliant
int32_t j ) // Compliant - explicitly cast to void
{
( void )j;
auto l = []( int32_t m, // Compliant
int32_t n ) // Non-compliant
{
return m;
};
}
template< bool b >
int32_t f2( int32_t i, // Non-compliant for f2< false >
int32_t j [[maybe_unused]] ) // Rule does not apply - [[maybe_unused]]
{
if constexpr ( b )
{
return i + j;
}
return 0;
}
Glossary
[1] Use / used / using
An object is used if:
- It is the subject of a cast; or
- It is explicitly initialized at declaration time; or
- It is an operand in an expression; or
- It is referenced.
A function is used as defined in M23_331: MISRA C++ 2023 Rule 0.2.4.
A type is used as defined in M23_005: MISRA C++ 2023 Rule 0.2.3.
[2] Unused
An entity is unused if it is not used [1].
[3] Callback
A callback is a function that is called indirectly via a function pointer or a handle.
Copyright The MISRA Consortium Limited © 2023
