This is a draft version of a MISRA C++ 202x rule proposed for public review.
MISRA Rule 0.2.1
Category: Advisory
Analysis Type: Decidable,Single Translation Unit
Amplification
A variable has limited visibility if it is not a function parameter, and it has internal linkage or no linkage.
A variable is used [1] when:
- It is part of an id-expression; or
- The variable is of class type and has a user-provided constructor or a user-provided destructor.
Rationale
Variables that are declared and never used within a project do not contribute to program output; they constitute noise and may indicate that the
wrong variable name has been used or that one or more statements are missing.
Note: this rule allows the introduction of variables for the sole purpose of providing scoped resource allocation and release. For
example:
{
std::lock_guard< std::mutex > lock { mutex }; // Compliant - has user-provided
// constructor
// ...
} // User-provided destructor implicitly called here
Exception
This rule does not apply to:
- Variables that have at least one declaration [2] with the
[[maybe_unused]] attribute.
- Constant variables at namespace scope that are declared within a header file [3].
Example
class C { }; // No user-provided constructor or destructor
namespace
{
C c; // Non-compliant - unused
}
void maybeUnused( int32_t a )
{
[[maybe_unused]]
bool b = a > 0; // Compliant (by exception #1 if NDEBUG is defined)
assert( b ); // Does not use b if NDEBUG is defined
usefn( a );
}
const int16_t x = 19; // Compliant - x is read in initializedButNotUsed
const int16_t y = 21; // Non-compliant - would be compliant by exception #2
// if declared in a header file
void initializedButNotUsed()
{
int16_t local_1 = 42; // Non-compliant - local_1 is never read
int16_t local_2; // Compliant
local_2 = x; // Use of local_2 for the purposes of this rule
}
void userProvidedCtor()
{
std::ifstream fs { "cfg.ini" }; // Compliant - user-provided constructor
}
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 MISRA C++ 2023 Rule 0.2.3 (Types with limited visibility should be used at least
once).
[2] Declaration
A declaration introduces the name of an entity into a translation unit (see [basic.def]/1).
An entity may be declared several times. The first declaration of an entity in a translation unit is
called an introduction [4]. All subsequent declarations are called redeclarations [5].
A definition [6] is a declaration, as described in [basic.def]/2.
[3] Header file
A header file is considered to be any file that is included during preprocessing (for example via the #include directive),
regardless of its name or suffix.
[4] Introduction
See declaration [2].
[5] Redeclaration
See declaration [2].
[6] Definition
See declaration [2].
Copyright The MISRA Consortium Limited © 2023
