GCC 7, -Wimplicit-fallthrough warnings, and portable way to clear them?

C++17 [[fallthrough]]

Example:

int main(int argc, char **argv) { switch (argc) { case 0: argc = 1; [[fallthrough]]; case 1: argc = 2; }; } 

Compile with:

g++ -std=c++17 -Wimplicit-fallthrough main.cpp 

If you remove the [[fallthrough]];, GCC warns:

main.cpp: In function ‘int main()’: main.cpp:5:15: warning: this statement may fall through [-Wimplicit-fallthrough=] argc = 1; ~~^~~ main.cpp:6:9: note: here case 1: ^~~~ 

Also note from the example that the warning only happens if you fall beacross two cases: the last case statement (case 1 here) generates no warnings even though it has no break.

The following constructs don't generate the warning either:

#include <cstdlib> [[noreturn]] void my_noreturn_func() { exit(1); } int main(int argc, char **argv) { // Erm, an actual break switch (argc) { case 0: argc = 1; break; case 1: argc = 2; } // Return also works. switch (argc) { case 0: argc = 1; return 0; case 1: argc = 2; } // noreturn functions are also work. // https://stackoverflow.com/questions/10538291/what-is-the-point-of-noreturn/47444782#47444782 switch (argc) { case 0: argc = 1; my_noreturn_func(); case 1: argc = 2; } // Empty case synonyms are fine. switch (argc) { case 0: case 1: argc = 2; } // Magic comment mentioned at: // https://stackoverflow.com/a/45137452/895245 switch (argc) { case 0: argc = 1; // fall through case 1: argc = 2; } switch (argc) { // GCC extension for pre C++17. case 0: argc = 1; __attribute__ ((fallthrough)); case 1: argc = 2; } switch (argc) { // GCC examines all braches. case 0: if (argv[0][0] == 'm') { [[fallthrough]]; } else { return 0; } case 1: argc = 2; } } 

We can see from the last one that GCC examines all possible branches, and warns if any of them don't have [[fallthrough]]; or break or return.

You might also want to check for feature availability with macros as in this GEM5 inspired snippet:

#if defined __has_cpp_attribute #if __has_cpp_attribute(fallthrough) #define MY_FALLTHROUGH [[fallthrough]] #else #define MY_FALLTHROUGH #endif #else #define MY_FALLTHROUGH #endif 

See also: https://en.cppreference.com/w/cpp/language/attributes/fallthrough

Tested on GCC 7.4.0, Ubuntu 18.04.

See also

C version of this question: How to do an explicit fall-through in C

Another example: The Linux kernel provides a fallthrough pseudo-keyword macro. Which can be used as:

switch (cond) { case 1: foo(); fallthrough; case 2: bar(); break; default: baz(); } 

In kernel v5.10 its implemented like this:

#if __has_attribute(__fallthrough__) # define fallthrough __attribute__((__fallthrough__)) #else # define fallthrough do {} while (0) /* fallthrough */ #endif 

Clean C solution:

int r(int a) { switch(a) { case 0: a += 3; case 1: a += 2; default: a += a; } return a; } 

becomes:

int h(int a) { switch(a) { case 0: a += 3; goto one; case 1: one: a += 2; goto others; default: others: a += a; } return a; } 

EDIT: Moved the labels after case statements, as suggested by Stéphane Gourichon in comments, to see the fallthrough more easily.

Nobody mentioned disabling the warning altogether and this might not be the answer the OP was looking for but I think it should be included for completeness since it also works for both compilers:

-Wno-implicit-fallthrough

If for some reason you are not able to change the source code, this keeps the compile output clean allowing for a clear view on other problems (but of course one has to be aware of what one loses).

You can also try:

#pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" // your code #pragma GCC diagnostic pop