![\"hand](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/hand-162127_640.png\")
<\/p>\nThe section to enumerations has eight rules. Since C++11, we have scoped enumerations which overcome a lot of the drawbacks of classical enumerations. <\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Enumerations are sets of integer values which behave like a type. Here is the summary of the rules:<\/p>\n
enum class<\/code>es over \u201cplain\u201d enum<\/code>s<\/a><\/li>\n- Enum.4: Define operations on enumerations for safe and simple use<\/a><\/li>\n
- Enum.5: Don\u2019t use
ALL_CAPS<\/code> for enumerators<\/a><\/li>\n- Enum.6: Avoid unnamed enumerations<\/a><\/li>\n
- Enum.7: Specify the underlying type of an enumeration only when necessary<\/a><\/li>\n
- Enum.8: Specify enumerator values only when necessary<\/a><\/li>\n<\/ul>\n
As I mentioned in the opening of this post: classical enumerations have a lot of drawbacks. Let me explicitly compare classical (unscoped) enumerations and scoped enumerations (sometimes called strongly-typed enumerations) because this important comparison is not explicitly described in the rules.<\/p>\n
Here is a classical enumeration:<\/p>\n
<\/p>\n
\nenum<\/span> Colour{\r\n red,\r\n blue,\r\n green\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
Here are the drawbacks of the classical enumerations:<\/p>\n
\n- The enumerators have no scope<\/li>\n
- The enumerators implicitly convert to int<\/span><\/li>\n
- The enumerators pollute the global namespace<\/li>\n
- The type of enumerator is not defined. It just has to be big enough to hold the enumerator.<\/li>\n<\/ul>\n
By using the keyword class<\/span> or struct,<\/span> the classical enumeration becomes a scoped enumeration (enum class):<\/p>\n<\/p>\n
\nenum class<\/span> ColourScoped{\r\n red,\r\n blue,\r\n green\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
Now, you must use the scope operator to access the enumerators: ColourScoped::red. ColourScoped::red <\/span>will not implicitly convert to int<\/span> and will not pollute the global namespace. Additionally, the underlying type is per default int. <\/span><\/p>\nAfter providing the background information, we can directly jump into the rules. <\/span><\/p>\nEnum.1: Prefer enumerations over macros<\/a><\/h3>\nMacros don’t respect scope and have no type. This means you can override a previously set macro that specifies a color.<\/p>\n
<\/p>\n
\n\/\/ webcolors.h <\/span>\r\n#define RED 0xFF0000<\/span>\r\n\r\n\/\/ productinfo.h<\/span>\r\n#define RED 0<\/span>\r\n\r\nint<\/span> webcolor =<\/span> RED; \/\/ should be 0xFF0000<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
With ColourScoped<\/span>, this will not happen because you have to use the scope operator: ColourScoped webcolour = ColourScoped::red;<\/span><\/p>\n<\/p>\nEnum.2: Use enumerations to represent sets of related named constants<\/a><\/h3>\nThis rule is quite evident because the enumerators are a set of integers that create a type. <\/p>\n
Enum.3: Prefer enum class<\/code>es over \u201cplain\u201d enum<\/code>s<\/a><\/h3>\nThe enumerators of a scoped enum (enum class) will not automatically convert to int<\/span>. You have to access them with the scope operator.<\/p>\n<\/p>\n
\n\/\/ scopedEnum.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nenum<\/span> class<\/span> ColourScoped<\/span>{\r\n red,\r\n blue,\r\n green\r\n};\r\n\r\nvoid<\/span> useMe<\/span>(ColourScoped color){\r\n\r\n switch<\/span>(color){\r\n case<\/span> ColourScoped::<\/span>red:<\/span>\r\n std::<\/span>cout <<<\/span> \"ColourScoped::red\"<\/span> <<<\/span> std::<\/span>endl;\r\n break<\/span>;\r\n case<\/span> ColourScoped::<\/span>blue:<\/span>\r\n std::<\/span>cout <<<\/span> \"ColourScoped::blue\"<\/span> <<<\/span> std::<\/span>endl;\r\n break<\/span>;\r\n case<\/span> ColourScoped::<\/span>green:<\/span>\r\n std::<\/span>cout <<<\/span> \"ColourScoped::green\"<\/span> <<<\/span> std::<\/span>endl;\r\n break<\/span>;\r\n }\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> static_cast<\/span><<\/span>int<\/span>><\/span>(ColourScoped::<\/span>red) <<<\/span> std::<\/span>endl; \/\/ 0<\/span>\r\n std::<\/span>cout <<<\/span> static_cast<\/span><<\/span>int<\/span>><\/span>(ColourScoped::<\/span>red) <<<\/span> std::<\/span>endl; \/\/ 0<\/span>\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n ColourScoped colour{ColourScoped::<\/span>red};\r\n useMe(colour); \/\/ ColourScoped::red<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Enum.4: Define operations on enumerations for safe and simple use<\/a><\/h3>\nThe rules define an enumeration Day<\/span> that supports the increment operation.<\/p>\n<\/p>\n
\nenum<\/span> Day { mon, tue, wed, thu, fri, sat, sun };\r\n\r\nDay&<\/span> operator<\/span>++<\/span>(Day&<\/span> d)\r\n{\r\n return<\/span> d =<\/span> (d ==<\/span> Day::<\/span>sun) ?<\/span> Day::<\/span>mon :<\/span> static_cast<\/span><<\/span>Day><\/span>(static_cast<\/span><<\/span>int<\/span>><\/span>(d)+<\/span>1<\/span>);\r\n}\r\n\r\nDay today =<\/span> Day::<\/span>sat;\r\nDay tomorrow =<\/span> ++<\/span>today;\r\n<\/pre>\n<\/div>\n <\/p>\n
The static_cast<\/span> is necessary in this example because applying the increment operator inside the increment operator would cause an infinite recursion:<\/p>\n<\/p>\n
\nDay&<\/span> operator<\/span>++<\/span>(Day&<\/span> d)\r\n{\r\n return<\/span> d =<\/span> (d ==<\/span> Day::<\/span>sun) ?<\/span> Day::<\/span>mon :<\/span> Day{++<\/span>d}; \/\/ error<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Enum.5: Don\u2019t use ALL_CAPS<\/code> for enumerators<\/a><\/h3>\nIf you use ALL_CAPS for enumerators, you may get a conflict with macros because they are typically written in ALL_CAPS.<\/p>\n
<\/p>\n
\n#define RED 0xFF0000<\/span>\r\n\r\nenum<\/span> class<\/span> ColourScoped<\/span>{ RED }; \/\/ error<\/span>\r\n<\/pre>\n<\/div>\nEnum.6: Avoid unnamed enumerations<\/a><\/h3>\nIf you can’t find a name for the enumerations, the enumerations maybe not be related. In this case, you should use a constexpr value.<\/p>\n
<\/p>\n
\n\/\/ bad<\/span>\r\nenum<\/span> { red =<\/span> 0xFF0000<\/span>, scale =<\/span> 4<\/span>, is_signed =<\/span> 1<\/span> };\r\n\r\n\/\/ good<\/span>\r\nconstexpr int<\/span> red =<\/span> 0xFF0000<\/span>;\r\nconstexpr short<\/span> scale =<\/span> 4<\/span>;\r\nconstexpr bool<\/span> is_signed =<\/span> true<\/span>;\r\n<\/pre>\n<\/div>\nEnum.7: Specify the underlying type of an enumeration only when necessary<\/a><\/h3>\nSince C++11, you can specify the underlying type of enumeration and save memory. Per default, the type of a scoped enum is int<\/span> and, therefore, you can forward declare an enum. <\/span><\/p>\n<\/p>\n
\n\/\/ typeEnum.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nenum<\/span> class<\/span> Colour1<\/span>{\r\n red,\r\n blue,\r\n green\r\n};\r\n \r\nenum<\/span> struct<\/span> Colour2:<\/span> char<\/span> {\r\n red,\r\n blue,\r\n green\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> sizeof<\/span>(Colour1) <<<\/span> std::<\/span>endl; \/\/ 4<\/span>\r\n std::<\/span>cout <<<\/span> sizeof<\/span>(Colour2) <<<\/span> std::<\/span>endl; \/\/ 1<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\nEnum.8: Specify enumerator values only when necessary<\/a><\/h3>\nBy specifying the enumerator values, you may set a value twice. The following enumeration Col2<\/span> has this issue.<\/p>\n<\/p>\n
\nenum<\/span> class<\/span> Col1<\/span> { red, yellow, blue };\r\nenum<\/span> class<\/span> Col2<\/span> { red =<\/span> 1<\/span>, yellow =<\/span> 2<\/span>, blue =<\/span> 2<\/span> }; \/\/ typo<\/span>\r\n