Declaración de enumeración

Una enumeración es un tipo distinto cuyo valor está restringido a un rango de valores (véase más abajo para más detalles), que puede incluir varias constantes nombradas explícitamente ("enumeradores"). Los valores de las constantes son valores de un tipo integral conocido como el tipo subyacente de la enumeración.

Una enumeración se define utilizando la siguiente sintaxis:

Hay dos tipos distintos de enumeraciones: enumeración sin ámbito (declarada con la clave-de-enum enum) y enumeración con ámbito (declarada con la clave-de-enum enum class o enum struct).

[editar] Enumeración sin ámbito

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

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

Cada enumerador está asociado con un valor del tipo subyacente. Cuando los inicializadores se proporcionan en la lista-de-enumeradores, los valores de los enumeradores están definidos por esos inicializadores. Si el primer enumerador no tiene un inicializador, el valor asociado es cero. Para cualquier otro enumerador cuya definición no tenga un inicializador, 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

Los valores del tipo enumeración sin ámbito son implícitamente convertibles a tipos enteros. Si el tipo subyacente no es fijo, el valor es convertible al primer tipo de la siguiente lista capaz de mantener todo su rango de valores: int, unsigned int, long, unsigned long, long long, o unsigned long long. Si el tipo subyacente es fijo, los valores se pueden convertir a su tipo subyacente promocionado.

enum color { rojo, amarillo, verde = 20, azul };
color col = rojo;
int n = azul; // n == 21

Los valores de tipos enteros, de punto flotante y enumeración se pueden convertir mediante una conversión estática (static_cast) o una conversión explícita, a cualquier tipo enumeración. Si el tipo subyacente no es fijo y el valor de origen está fuera de rango, el resultado no está especificado (hasta C++17) está indefinido (desde C++17). (El valor de origen, como se convierte al tipo subyacente de la enumeración si es de punto flotante, está dentro del rango si se ajusta en el campo de bits más pequeño lo suficientemente grande para contener todos los enumeradores de la enumeración destino). De lo contrario, el resultado es el mismo que el resultado de la conversión explícita al tipo subyacente.

Observa que el valor después de dicha conversión puede no ser necesariamente igual a ninguno de los enumeradores definidos por la enumeración.

enum acceso_t { lectura = 1, escritura = 2, ejecucion = 4 }; // enumeradores: 1, 2, 4 rango: 0..7
acceso_t lej = static_cast<acceso_t>(7);
assert((lej & lectura) && (lej & escritura) && (lej & ejecucion));
 
acceso_t x = static_cast<acceso_t>(8.0); // comportamiento indefinido a partir de C++17
acceso_t y = static_cast<acceso_t>(8);   // comportamiento indefinido a partir de C++17
 
enum foo { a = 0, b = UINT_MAX }; // rango: [0, UINT_MAX]
foo x= foo(-1); // comportamiento indefinido a partir de C++17, 
                // aún si el tipo subyacente de foo es unsigned int

Se puede omitir el nombre de una enumeración sin ámbito: dicha declaración solo introduce a 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 sin ámbito es un miembro de clase, se puede acceder a sus enumeradores utilizando operadores de acceso a miembros de la clase . and ->:

struct X
{
    enum direccion { izquierda = 'i', derecha = 'd' };
};
X x;
X* p = &x;
 
int a = X::direccion::left; // permitido solamente en C++11 y posterior
int b = X::izquierda;
int c = x.izquierda;
int d = p->izquierda;

[editar] Enumeraciones con ámbito

enum class Color { rojo, verde = 20, azul };
Color r = Color::azul;
switch(r)
{
    case Color::rojo  : std::cout << "rojo\n";   break;
    case Color::verde : std::cout << "verde\n";  break;
    case Color::azul  : std::cout << "azul\n";   break;
}
// int n = r; // ERROR: no existe conversión de enum con ámbito a int
int n = static_cast<int>(r); // de acuerdo, n = 21

enum byte : unsigned char {}; // byte es un nuevo tipo de entero
byte b { 42 }; // de acuerdo a partir de C++17 (inicialización de lista directa)
byte c = { 42 }; // ERROR
byte d = byte{ 42 }; // de acuerdo a partir de C++17; mismo valor que b
byte e { -1 }; // ERROR
 
struct A { byte b; };
A a1 = { { 42 } }; // ERROR
A a2 = { byte{ 42 } }; // de acuerdo a partir de C++17
 
void f(byte);
f({ 42 }); // ERROR
 
enum class Identificador : std::uint32_t { Invalido = 0 };
Identificador h { 42 }; // de acuerdo a partir de C++17

enum class fruta { naranja, manzana };
struct S {
  using enum fruta; // de acuerdo: introduce a naranja y manzana en S
};
void f()
{
    S s;
    s.naranja;  // de acuerdo: denomina a fruta::naranja
    S::naranja; // de acuerdo: denomina a fruta::naranja
}

enum class fruta { naranja, manzana };
enum class color { rojo, naranja };
void f()
{
    using enum fruta; // de acuerdo
    // using enum color; // ERROR: color::naranja y fruta::orange en conflicto
}

[editar] Ejemplo

#include <iostream>
 
// enum que toma 16 bits
enum smallenum: int16_t
{
    a,
    b,
    c
};
 
 
// color puede ser rojo (valor 0), amarillo (valor 1), verde (valor 20), o azul (valor 21)
enum color
{
    rojo,
    amarillo,
    verde = 20,
    azul
};
 
// altitud puede ser altitud::alta o altitud::baja
enum class altitud: char
{ 
     alta = 'a',
     baja = 'b', // C++11 permite la coma extra
}; 
 
// la constante d es 0, la constante e es 1, la constante f es 3
enum
{
    d,
    e,
    f = e + 2
};
 
// tipos enumeración (tanto con ámbito como sin ámbito)
// pueden tener operadores sobrecargados
std::ostream& operator<<(std::ostream& os, color c)
{
    switch(c)
    {
        case rojo     : os << "rojo";     break;
        case amarillo : os << "amarillo"; break;
        case verde    : os << "verde";    break;
        case azul     : os << "azul";     break;
        default       : os.setstate(std::ios_base::failbit);
    }
    return os;
}
 
std::ostream& operator<<(std::ostream& os, altitude al)
{
    return os << static_cast<char>(al);
}
 
int main()
{
    color col = rojo;
    altitud a;
    a = altitud::baja;
 
    std::cout << "col = " << col << '\n'
              << "a = "   << a   << '\n'
              << "f = "   << f   << '\n';
}

col = rojo
a = b
f = 3

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también