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.4 - Functions with limited visibility should be used [1] at least once
Category: Advisory
Analysis: Decidable,System
Amplification
A function has limited visibility if it:
- Is declared in an anonymous namespace; or
- Is a member of a class in an anonymous namespace; or
- Has namespace scope and is declared
static; or
- Is a
private, non-virtual member.
A function is used [1] when:
- Its address is taken (including by reference); or
- It is called; or
- It is an operand of an expression in an unevaluated context; or
- Another function in the same overload set is used [1].
This rule does not apply to:
- Special member functions;
- Functions defined as
= delete.
Rationale
Functions with limited visibility are not generally used within an extensible API. If they are present but remain unused, then there may
be an issue in the software design.
Unused functions in an overload set are acceptable as it allows the set to be internally consistent.
Exception
Functions that have at least one declaration [2] with the [[maybe_unused]] attribute are permitted to be unused as the intent
is explicit.
Example
struct Foo
{
int32_t m1() // Public - rule does not apply
{
return -1;
}
static int32_t m2() // Class scope - rule does not apply
{
return 42;
}
Foo()
{
m3();
}
private:
void m3() { } // Compliant - called
void m4() { } // Non-compliant - not used
void m5() { } // Compliant - used by a friend
friend void ( *f4() )();
protected:
void m6() { } // Protected - rule does not apply
};
static void f1() { } // Non-compliant - not used
namespace
{
void f2() { } // Non-compliant - not used
}
static void f3() { } // Compliant - address taken in f4()
void ( *f4() )() // Rule does not apply - visibility not limited
{
Foo bar;
bar.m5();
return &f3;
}
namespace A
{
struct C1 {};
static void swap( C1 &, C1 & ); // Compliant - overload set for call in f5
}
namespace B
{
struct C2 {};
static void swap( C2 &, C2 & ); // Non-compliant
}
namespace
{
template< typename T >
void swap( T &, T & ); // Compliant - overload set for call in f5
}
void f5( A::C1 c1, A::C1 c2 ) // Rule does not apply - visibility not limited
{
swap( c1, c2 );
}
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] 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 [3]. All subsequent declarations are called redeclarations [4].
A definition [5] is a declaration, as described in [basic.def]/2.
[3] Introduction
See declaration [2].
[4] Redeclaration
See declaration [2].
[5] Definition
See declaration [2].
Copyright The MISRA Consortium Limited © 2023
