For unused function parameters or unused local variables, the compiler will issue a corresponding warning. Generally, if you want to avoid seeing this warning, you can disable it using preprocessor directives, although the syntax for these directives varies slightly between different compilers and needs to be adapted. However, starting from C++17, a new attribute specifier was introduced, which is the “maybe_unused” specifier. This specifier allows programmers to mark a symbol as maybe_unused at the syntax level, thus preventing the compiler from generating compilation warnings.
1 Marking Unused Variables
Despite the confusion regarding the value of this feature, its existence is justified. After all, using this specifier means you no longer have to consider the differences in preprocessor directives across different compilers. Now, let’s discuss its usage. First, it is used to mark unused variables to avoid compiler warnings. Consider this example:
bool result = .....;assert(result);The Debug version has no issues, but in the Release version, the assert is optimized out by the compiler, so result is not used. The solution in C++17 is to mark result as “maybe_unused”, like this:
[[maybe_unused]] bool result = .....;assert(result);2 Marking Function Parameters
Parameters declared in the function parameter list that are not used can also lead to compiler warnings. This situation often occurs in predefined callback interfaces, where the modules implementing these interfaces may not necessarily need to use these parameters. The past solution was to suppress this warning or use a meaningless statement to deceive the compiler. For example, in this function, the param1 parameter is not used, and you can deceive the compiler with a meaningless assignment statement:
void Func(int param1, int param2) { param1 = param1; //using param2...}With C++17, you no longer need to do this; simply mark the parameter as “maybe_unused”:
void Func([[maybe_unused]] int param1, int param2) { //using param2...}3 Marking Members of Union/Struct/Enum/Class
Members of data structures can also be marked as “maybe_unused”. For example, in a union, members that are often defined but not used can trigger compiler warnings. Consider this example:
union IpPort { int iv; char bv[4]; unsigned short sv[2];};
IpPort ia;ia.sv[0] = 17701;ia.sv[1] = 33559;char b1 = ia.bv[0];In this example, iv is not used, and the compiler will generate a warning. If iv’s existence is meaningful and may be used in the future, you can keep iv and mark it as “maybe_unused”:
union IpPort { [[maybe_unused]] int iv; char bv[4]; unsigned short sv[2];};Similarly, enums can also mark certain unused enumeration variables as “maybe_unused” (note the position of the mark):
enum { EnumName1 [[maybe_unused]], EnumName2 [[maybe_unused]] = 42};4 Marking Functions
When creating libraries (lib), unused interface functions can sometimes generate warnings about “function defined but not used”. The “maybe_unused” specifier can also be used to mark functions. Here’s an example:
[[maybe_unused]]void Func(int param1, int param2) {}5 Marking typedef and using Declarations
This is an example from the C++ standard; just remember their syntax positions. If you are the author of a library or framework, and you think your users might use these types, you can retain this type in this way. For ordinary developers, for unused typedefs, just comment them out with a couple of keystrokes; no one likes to type a dozen extra keystrokes:
[[maybe_unused]] typedef S* PS;using PS [[maybe_unused]] = S*;Information, Code, and Previous ArticlesC++ Monadic InterfaceC++20 Designated InitializersC++ Covariant Return TypesC++ Size and ssize FunctionsC++ Latch and BarrierC++ SemaphoreC++ Lock() and Try_lock() FunctionsC++ Various LocksC++ Various std::mutexC++ SpanC++ Copy ElisionC++ Time Library Part 8: Format and FormattingC++20 PIC++ [[noreturn]] SpecifierHow C++ Declares Lambda as FriendC++ Cache Line InterfaceC++ Clamp FunctionC++ Three and Five RulesC++ Strict Aliasing RulesC++ Construct_at FunctionContent and Notification Summary