{"id":5009,"date":"2016-11-01T16:40:14","date_gmt":"2016-11-01T16:40:14","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/strongly-typed-enums\/"},"modified":"2023-06-26T12:37:42","modified_gmt":"2023-06-26T12:37:42","slug":"strongly-typed-enums","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/strongly-typed-enums\/","title":{"rendered":"Strongly-Typed Enums"},"content":{"rendered":"

Enumerations are a convenient way to define integer constants with names. These integer constants are called enumerators. Sadly, classical enums have a few drawbacks.<\/p>\n

<\/p>\n

The drawbacks of enumerations in classical C++<\/h2>\n

 A short reminder. Three drawbacks of enumerations.<\/span><\/p>\n

    \n
  1. The enumerators implicitly convert to int.<\/span><\/li>\n
  2. They introduce the enumerators in the enclosing scope.<\/li>\n
  3. The type of enumeration can not be specified.<\/li>\n<\/ol>\n

    First to point 3: Enumerations can not be forward declared because their type is not known. There is only a guarantee for the enumerators in classical C++. The type must be integral and big enough to hold the enumerators.<\/p>\n

    Point 1 and point 2 are more surprising.<\/p>\n

    <\/p>\n

    \n\n\n\n
    \n
     1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21<\/pre>\n<\/td>\n
    		\n
    \/\/ enumClassic.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main(){\r\n\t\r\n  std::cout << std::endl;\r\n\t\r\n  enum<\/span> Colour{red= 0,green= 2,blue};\r\n  \r\n  std::cout << \"red: \"<\/span> << red << std::endl;\r\n  std::cout << \"green: \"<\/span> << green << std::endl;\r\n  std::cout << \"blue: \"<\/span> << blue << std::endl;\r\n  \r\n  int<\/span> red2= red;\r\n  \r\n  std::cout << \"red2: \"<\/span> << red2 << std::endl;\r\n  \r\n  \/\/ int red= 5;  ERROR<\/span>\r\n  \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    On the one hand are the enumerators red,<\/span> green,<\/span> and blue<\/span>, known in the enclosing scope. Therefore, the definition of the red variable in line 19 is impossible. On the other hand, red<\/span> can be implicitly converted to int.<\/span><\/p>\n
    \"enumClassic\"<\/p>\n
    If you use no name for an enumeration like enum{red, green, blue},<\/span>  the enumerators will be introduced in the enclosing scope.<\/p>\n
    But that surprise ends with C++11.<\/p>\n<\/p>\n
    Strongly-typed enumerations<\/h2>\n
    The strongly-typed enumerations have to follow stronger rules:<\/p>\n
      \n
    1. The enumerators can only be accessed in the scope of the enumeration.<\/li>\n
    2. The enumerators don’t implicitly convert to int.<\/span>
      <\/span><\/li>\n
    3. The enumerators aren’t imported in the enclosing scope.<\/li>\n
    4. The type of enumerators is, by default, int.<\/span> Therefore, you can forward the enumeration.<\/span><\/li>\n<\/ol>\n
      The syntactical difference between the classic enumerations and the strongly-typed enumerations is minimal. The strongly-typed enumerations additionally get the keyword class<\/span> or struct.<\/span><\/p>\n
      \"enumClassicStrongEng\"<\/p>\n
      If you want to use an enumerator as an int,<\/span> you must explicitly convert it with static_cast<\/code>.<\/span><\/p>\n
      <\/p>\n
      \n\n\n\n
      \n
       1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29<\/pre>\n<\/td>\n
      		\n
      \/\/ enumCast.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nenum<\/span> OldEnum{\r\n  one= 1,\r\n  ten=10,\r\n  hundred=100,\r\n  thousand= 1000\r\n};\r\n\r\nenum<\/span> struct<\/span> NewEnum{\r\n  one= 1,\r\n  ten=10,\r\n  hundred=100,\r\n  thousand= 1000\r\n};\r\n\r\nint<\/span> main(){\r\n\t\r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"C++11= \"<\/span> << 2*thousand + 0*hundred + 1*ten + 1*one << std::endl;\r\n  std::cout << \"C++11= \"<\/span> << 2*static_cast<\/span><int<\/span>>(NewEnum::thousand) + \r\n                            0*static_cast<\/span><int<\/span>>(NewEnum::hundred) + \r\n                            1*static_cast<\/span><int<\/span>>(NewEnum::ten) + \r\n\t                    1*static_cast<\/span><int<\/span>>(NewEnum::one) << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
      <\/p>\n
       <\/p>\n
      To calculate or output the enumerators, you must convert them into integral types. Either the addition or the output of strongly-typed enumerations is defined. <\/p>\n
      \"enumCast\" <\/div>\n
       <\/p>\n
      I often speak in this post about classical versus strongly-typed enumerations. Often there are called scoped and unscoped enumerations<\/strong>.<\/p>\n
      Explicitly specifying the type<\/h2>\n
      I ignored one feature of the enumerations in C++11. You can explicitly specify the type of enumerators. By default, it’s int.<\/span><\/p>\n
      But that does not have to be. You can use integral types like bool, char, short int, long int, or, long long int<\/span>.  Read msdn.microsoft.com<\/a> for the details. You can read in my post, Check types<\/a> how you can check at compile time if a type is integral. <\/p>\n
      You can independently use the scoped property and the explicit type specification of an enumeration. Dependent on the base types, the enumerations have different sizes.<\/p>\n
       <\/p>\n
      <\/p>\n
      \n\n\n\n
      \n
       1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46<\/pre>\n<\/td>\n
      		\n
      \/\/ enumType.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <climits><\/span>\r\n\r\nenum<\/span> struct<\/span> Colour0: bool<\/span>{\r\n  red,     \/\/ 0<\/span>\r\n  blue     \/\/ 1<\/span>\r\n};\r\n\r\nenum<\/span> Colour1{\r\n  red= -5,   \r\n  blue,      \/\/ -4<\/span>\r\n  green      \/\/ -3<\/span>\r\n};\r\n\r\nenum<\/span> struct<\/span> Colour2: char<\/span>{\r\n  red= 100,\r\n  blue, \/\/ 101<\/span>\r\n  green \/\/ 102<\/span>\r\n};\r\n\r\nenum<\/span> class<\/span> Colour3<\/span>: long<\/span> long<\/span> int<\/span>{\r\n  \/\/red= \tstd::numeric_limits<long long int>::min();<\/span>\r\n  red= LLONG_MIN,\r\n  blue,    \/\/ std::numeric_limits<long long int>::min() + 1<\/span>\r\n  green    \/\/ std::numeric_limits<long long int>::min() + 2<\/span>\r\n};\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"sizeof(Colour0)= \"<\/span>  << sizeof<\/span>(Colour0) << std::endl;\r\n  std::cout << \"sizeof(Colour1)= \"<\/span>  << sizeof<\/span>(Colour1) << std::endl;\r\n  std::cout << \"sizeof(Colour2)= \"<\/span>  << sizeof<\/span>(Colour2) << std::endl;\r\n  std::cout << \"sizeof(Colour3)= \"<\/span>  << sizeof<\/span>(Colour3) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"Colour0::red: \"<\/span> << static_cast<\/span><bool<\/span>>(Colour0::red) << std::endl;\r\n  std::cout << \"red: \"<\/span> << red << std::endl;\r\n  std::cout << \"Colour2::red: \"<\/span> << static_cast<\/span><char<\/span>>(Colour2::red) << std::endl;\r\n  std::cout << \"Colour3::red: \"<\/span> << static_cast<\/span><long<\/span> long<\/span> int<\/span>>(Colour3::red) << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
       <\/p>\n
      My in Microsoft Visual Studio 12.0 included C++ compiler cl.exe can not evaluate the expression std::numeric_limits<long long int>::min()<\/span> (line 24) at compile time. According to the C++11 standard, is std::numeric_limits<long long int>::min()<\/span> a constant expression. Therefore, I can use this expression to initialize an enumerator. Because of the missing feature in cl.exe, I have to use the macro <\/span>LLONG_MIN<\/span> in line 25. This macro is defined in the same header as the expression std::numeric_limits<\/span>: <climits>.<\/span><\/p>\n
       At the end, the output.<\/p>\n
       \"enumType\"<\/p>\n
      What’s next?<\/h2>\n
      Typically, you have in the embedded world a system of systems. Or, to say it differently: Many autonomous systems interact with each other to build the whole system. If I change the term autonomous system with the object, we are in the domain of object-oriented programming. From my perspective, object-oriented abstraction is an abstraction with significant added value for a deeper understanding of embedded systems. Therefore, I will write in the next post <\/a>about the new keywords override<\/span> and final<\/span>, which empowers you to manage the object hierarchies.<\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
      Enumerations are a convenient way to define integer constants with names. These integer constants are called enumerators. Sadly, classical enums have a few drawbacks.<\/p>\n","protected":false},"author":21,"featured_media":5005,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[458],"class_list":["post-5009","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-enum"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5009","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5009"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5009\/revisions"}],"predecessor-version":[{"id":6931,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5009\/revisions\/6931"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5005"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5009"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5009"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5009"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}