C++11 has given use strongly-typed enumeration types which are recommended to be used over the old style enumeration types. The problem with the latter is that the enumerators of such old-style enumeration types are automatically exported into the enclosing scope. This can cause naming collisions with names already defined in the enclosing scope. This is also the reason why enumerators of such types are often prefixed with some label to try to make sure they are unique. For example:<\/p>\n\n\n
\nenum Color { ColorRed, ColorGreen, ColorBlue };\n<\/pre><\/div>\n\n\nThe strongly-typed enumeration types from C++11 do not automatically export their enumerators to the enclosing scope.<\/p>\n\n\n\n
Let’s look at an example. The following defines and uses a strongly-type enumeration type called Color<\/strong>:<\/p>\n\n\n\nenum class Color { Red, Green, Blue };\nColor someColor = Color::Green;\n<\/pre><\/div>\n\n\nTo use the enumerators of the Color <\/strong>enumeration type, you need to fully qualify them with Color::<\/strong>. This can become a bit cumbersome if you, for example, need to have a switch<\/strong> statement on the different enumerators:<\/p>\n\n\n\nswitch (someColor) {\n case Color::Red:\n \/\/ ...\n break;\n case Color::Green:\n \/\/ ...\n break;\n case Color::Blue:\n \/\/ ...\n break;\n}\n<\/pre><\/div>\n\n\nSince C++20, you can use a using <\/strong>declaration to avoid having to fully qualify all the different enumerators in the switch <\/strong>cases:<\/p>\n\n\n\nswitch (someColor) {\n using enum Color;\n\n case Red:\n \/\/ ...\n break;\n case Green:\n \/\/ ...\n break;\n case Blue:\n \/\/ ...\n break;\n}\n<\/pre><\/div>\n\n\nOf course, it is recommended to have the scope of the using<\/strong> declaration as small as possible, otherwise you again introduce the risk of having naming collisions. That’s why the using<\/strong> declaration in the earlier example is inside the scope of the switch<\/strong> statement.<\/p>\n\n\n\n