Anenumeration is a distinct type whose value is restricted to a range of values (see below for details), which may include several explicitly named constants ("enumerators").

The values of the constants are values of an integral type known as theunderlying type of the enumeration. An enumeration has the samesize,value representation, andalignment requirements as its underlying type. Furthermore, each value of an enumeration has the same representation as the corresponding value of the underlying type.

An enumeration is (re)declared using the following syntax:

There are two distinct kinds of enumerations:unscoped enumeration (declared with theenum-keyenum) andscoped enumeration (declared with theenum-keyenum class orenum struct).

[edit]Unscoped enumerations

Eachenumerator becomes a named constant of the enumeration's type (that is,name), visible in the enclosing scope, and can be used whenever constants are required.

enum Color{ red, green, blue};Color r= red; switch(r){case red:std::cout<<"red\n";break;case green:std::cout<<"green\n";break;case blue:std::cout<<"blue\n";break;}

Each enumerator is associated with a value of the underlying type. When= are provided in anenumerator-list, the values of enumerators are defined by those associatedconstant-expressions. If the first enumerator does not have=, the associated value is zero. For any other enumerator whose definition does not have an=, the associated value is the value of the previous enumerator plus one.

enum Foo{ a, b, c=10, d, e=1, f, g= f+ c};//a = 0, b = 1, c = 10, d = 11, e = 1, f = 2, g = 12

Thename of an unscoped enumeration may be omitted: such declaration only introduces the enumerators into the enclosing scope:

enum{ a, b, c=0, d= a+2};// defines a = 0, b = 1, c = 0, d = 2

When an unscoped enumeration is a class member, its enumerators may be accessed using class member access operators. and->:

struct X{enum direction{ left='l', right='r'};};X x;X* p=&x; int a= X::direction::left;// allowed only in C++11 and laterint b= X::left;int c= x.left;int d= p->left;

struct S{enum E1:int{};enum E1:int{};// error: redeclaration of enumeration,// NOT parsed as a zero-length bit-field of type enum E1}; enum E2{ e1}; void f(){false? newenum E2:int();// OK: 'int' is NOT parsed as the underlying type}

[edit]Enumeration name for linkage purposes

An unnamed enumeration that does not have atypedef name for linkage purposes and that has an enumerator is denoted, forlinkage purposes, by its underlying type and its first enumerator; such an enumeration is said to have an enumerator as aname for linkage purposes.

[edit]Scoped enumerations

#include <iostream> int main(){enumclass Color{ red, green=20, blue};    Color r= Color::blue; switch(r){case Color::red:std::cout<<"red\n";break;case Color::green:std::cout<<"green\n";break;case Color::blue:std::cout<<"blue\n";break;} // int n = r; // error: no implicit conversion from scoped enum to intint n=static_cast<int>(r);// OK, n = 21std::cout<< n<<'\n';// prints 21}

enum byte:unsignedchar{};// byte is a new integer type; see also std::byte (C++17)byte b{42};// OK as of C++17 (direct-list-initialization)byte c={42};// errorbyte d= byte{42};// OK as of C++17; same value as bbyte e{-1};// error struct A{ byte b;};A a1={{42}};// error (copy-list-initialization of a constructor parameter)A a2={byte{42}};// OK as of C++17 void f(byte);f({42});// error (copy-list-initialization of a function parameter) enumclass Handle:std::uint32_t{ Invalid=0};Handle h{42};// OK as of C++17

enum E{ x}; void f(){int E;usingenum E;// OK} using F= E;usingenum F;// OK template<class T>using EE= T; void g(){usingenum EE<E>;// OK}

enumclass fruit{ orange, apple}; struct S{usingenum fruit;// OK: introduces orange and apple into S}; void f(){    S s;    s.orange;// OK: names fruit::orange    S::orange;// OK: names fruit::orange}

enumclass fruit{ orange, apple};enumclass color{ red, orange}; void f(){usingenum fruit;// OK// using enum color; // error: color::orange and fruit::orange conflict}

[edit]Notes

Values of unscoped enumeration type can bepromoted orconverted to integral types:

enum color{ red, yellow, green=20, blue};color col= red;int n= blue;// n == 21

Values of integer, floating-point, and enumeration types can be converted to any enumeration type by usingstatic_cast. Note that the value after such conversion may not necessarily equal any of the named enumerators defined for the enumeration:

enum access_t{ read=1, write=2, exec=4};// enumerators: 1, 2, 4 range: 0..7access_t rwe=static_cast<access_t>(7);assert((rwe& read)&&(rwe& write)&&(rwe& exec)); access_t x=static_cast<access_t>(8.0);// undefined behavior since CWG 1766access_t y=static_cast<access_t>(8);// undefined behavior since CWG 1766 enum foo{ a=0, b=UINT_MAX};// range: [0, UINT_MAX]foo x= foo(-1);// undefined behavior since CWG 1766,// even if foo's underlying type is unsigned int

[edit]Keywords

enum,struct,class,using

[edit]Example

#include <cstdint>#include <iostream> // enum that takes 16 bitsenum smallenum:std::int16_t{    a,    b,    c}; // color may be red (value 0), yellow (value 1), green (value 20), or blue (value 21)enum color{    red,    yellow,    green=20,    blue}; // altitude may be altitude::high or altitude::lowenumclass altitude:char{    high='h',    low='l',// trailing comma only allowed after CWG 518};  // the constant d is 0, the constant e is 1, the constant f is 3enum{    d,    e,    f= e+2}; // enumeration types (both scoped and unscoped) can have overloaded operatorsstd::ostream& operator<<(std::ostream& os, color c){switch(c){case red: os<<"red";break;case yellow: os<<"yellow";break;case green: os<<"green";break;case blue: os<<"blue";break;default: os.setstate(std::ios_base::failbit);}return os;} std::ostream& operator<<(std::ostream& os, altitude al){return os<<static_cast<char>(al);} // The scoped enum (C++11) can be partially emulated in earlier C++ revisions: enumstruct E11{ x, y};// since C++11 struct E98{enum{ x, y};};// OK in pre-C++11 namespace N98{enum{ x, y};}// OK in pre-C++11 struct S98{staticconstint x=0, y=1;};// OK in pre-C++11 void emu(){std::cout<<(static_cast<int>(E11::y)+ E98::y+ N98::y+ S98::y)<<'\n';// 4} namespace cxx20{enumclass long_long_long_name{ x, y}; void using_enum_demo(){std::cout<<"C++20 `using enum`: __cpp_using_enum == ";switch(auto rnd=[]{return long_long_long_name::x;}; rnd()){#if defined(__cpp_using_enum)usingenum long_long_long_name;case x:std::cout<< __cpp_using_enum<<"; x\n";break;case y:std::cout<< __cpp_using_enum<<"; y\n";break;#elsecase long_long_long_name::x:std::cout<<"?; x\n";break;case long_long_long_name::y:std::cout<<"?; y\n";break;#endif}}} int main(){    color col= red;    altitude a;    a= altitude::low; std::cout<<"col = "<< col<<'\n'<<"a = "<< a<<'\n'<<"f = "<< f<<'\n';     cxx20::using_enum_demo();}

col = reda = lf = 3C++20 `using enum`: __cpp_using_enum == 201907; x

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

[edit]See also

• In other languages

• العربية
• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文