Enumeration declaration

Una enumeración es un tipo distinto cuyo valor está restringido a un rango de valores (ver más abajo para detalles), que puede incluir varias constantes explícitamente nombradas (" enumeradores ").

Los valores de las constantes son valores de un tipo integral conocido como el tipo subyacente de la enumeración. Una enumeración tiene el mismo tamaño , representación de valor , y requisitos de alineación que su tipo subyacente. Además, cada valor de una enumeración tiene la misma representación que el valor correspondiente del tipo subyacente.

Una enumeración se (re)declara utilizando la siguiente sintaxis:

Existen dos tipos distintos de enumeraciones: enumeración no acotada (declarada con la enum-key enum ) y enumeración acotada (declarada con la enum-key enum class o enum struct ).

Enumeraciones no delimitadas

Cada enumerador se convierte en una constante con nombre del tipo de la enumeración (es decir, name ), visible en el ámbito circundante, y puede utilizarse siempre que se requieran constantes.

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

Cada enumerador está asociado con un valor del tipo subyacente. Cuando se proporcionan = en una enumerator-list , los valores de los enumeradores se definen por esas constant-expression s asociadas. Si el primer enumerador no tiene = , el valor asociado es cero. Para cualquier otro enumerador cuya definición no tenga un = , el valor asociado es el valor del enumerador anterior más uno.

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

El nombre de una enumeración no delimitada puede omitirse: dicha declaración solo introduce los enumeradores en el ámbito circundante:

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

Cuando una enumeración no delimitada es un miembro de clase, sus enumeradores pueden ser accedidos usando los operadores de acceso a miembros de clase . y -> :

struct X
{
    enum direction { left = 'l', right = 'r' };
};
X x;
X* p = &x;
int a = X::direction::left; // permitido solo en C++11 y posteriores
int b = X::left;
int c = x.left;
int d = p->left;

struct S
{
    enum E1 : int {};
    enum E1 : int {}; // error: redeclaración de enumeración,
                      // NO se analiza como un campo de bits de longitud cero de tipo enum E1
};
enum E2 { e1 };
void f()
{
    false ? new enum E2 : int(); // OK: 'int' NO se analiza como el tipo subyacente
}

Nombre de enumeración para fines de vinculación

Una enumeración sin nombre que no tiene un typedef name for linkage purposes y que tiene un enumerador se denota, para linkage purposes , por su tipo subyacente y su primer enumerador; se dice que dicha enumeración tiene un enumerador como name for linkage purposes .

Enumeraciones con ámbito

#include <iostream>
int main()
{
    enum class 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 hay conversión implícita de enum con ámbito a int
    int n = static_cast<int>(r); // OK, n = 21
    std::cout << n << '\n'; // imprime 21
}

enum byte : unsigned char {}; // byte es un nuevo tipo entero; ver también std::byte (C++17)
byte b{42};        // OK desde C++17 (inicialización de lista directa)
byte c = {42};     // error
byte d = byte{42}; // OK desde C++17; mismo valor que b
byte e{-1};        // error
struct A { byte b; };
A a1 = {{42}};     // error (inicialización de lista por copia de un parámetro del constructor)
A a2 = {byte{42}}; // OK desde C++17
void f(byte);
f({42}); // error (inicialización de lista por copia de un parámetro de función)
enum class Handle : std::uint32_t { Invalid = 0 };
Handle h{42}; // OK desde C++17

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

enum class fruit { orange, apple };
struct S
{
    using enum fruit; // OK: introduce orange y apple en S
};
void f()
{
    S s;
    s.orange;  // OK: nombra fruit::orange
    S::orange; // OK: nombra fruit::orange
}

enum class fruit { orange, apple };
enum class color { red, orange };
void f()
{
    using enum fruit;    // OK
    // using enum color; // error: color::orange y fruit::orange entran en conflicto
}

Notas

Los valores de tipo enumeración no delimitada pueden ser promocionados o convertidos a tipos integrales:

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

Los valores de tipos enteros, de punto flotante y de enumeración pueden convertirse a cualquier tipo de enumeración utilizando static_cast . Nótese que el valor después de dicha conversión puede no necesariamente igualar ninguno de los enumeradores definidos para la enumeración:

enum access_t { read = 1, write = 2, exec = 4 }; // enumeradores: 1, 2, 4 rango: 0..7
access_t rwe = static_cast<access_t>(7);
assert((rwe & read) && (rwe & write) && (rwe & exec));
access_t x = static_cast<access_t>(8.0); // comportamiento indefinido desde CWG 1766
access_t y = static_cast<access_t>(8);   // comportamiento indefinido desde CWG 1766
enum foo { a = 0, b = UINT_MAX }; // rango: [0, UINT_MAX]
foo x = foo(-1); // comportamiento indefinido desde CWG 1766,
                 // incluso si el tipo subyacente de foo es unsigned int

Palabras clave

enum , struct , class , using

Ejemplo

#include <cstdint>
#include <iostream>
// enumeración que ocupa 16 bits
enum smallenum: std::int16_t
{
    a,
    b,
    c
};
// color puede ser red (valor 0), yellow (valor 1), green (valor 20), o blue (valor 21)
enum color
{
    red,
    yellow,
    green = 20,
    blue
};
// altitude puede ser altitude::high o altitude::low
enum class altitude: char
{
    high = 'h',
    low = 'l', // coma final solo permitida después de CWG 518
}; 
// la constante d es 0, la constante e es 1, la constante f es 3
enum
{
    d,
    e,
    f = e + 2
};
// los tipos de enumeración (tanto con ámbito como sin ámbito) pueden tener operadores sobrecargados
std::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);
}
// La enumeración con ámbito (C++11) puede ser emulada parcialmente en revisiones anteriores de C++:
enum struct E11 { x, y }; // desde C++11
struct E98 { enum { x, y }; }; // OK en pre-C++11
namespace N98 { enum { x, y }; } // OK en pre-C++11
struct S98 { static const int x = 0, y = 1; }; // OK en pre-C++11
void emu()
{
    std::cout << (static_cast<int>(E11::y) + E98::y + N98::y + S98::y) << '\n'; // 4
}
namespace cxx20
{
    enum class 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)
            using enum long_long_long_name;
            case x: std::cout << __cpp_using_enum << "; x\n"; break;
            case y: std::cout << __cpp_using_enum << "; y\n"; break;
#else
            case 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 = rojo
a = l
f = 3
C++20 `using enum`: __cpp_using_enum == 201907; x

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Referencias

Véase también