C++ Academy · Lección

enum class con ámbito

Enumeraciones con seguridad de tipos

enum class con ámbito es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

Los enums simples filtran nombres

Un enum clásico al estilo de C introduce sus nombres en el ámbito circundante y se convierte silenciosamente a int. Esto facilita los conflictos de nombres y las comparaciones accidentales.

enum class resuelve ambos problemas.
Los valores tienen ámbito propio y están fuertemente tipados.

#include <iostream>
enum Color { Red, Green, Blue };
int main() {
    Color c = Green;
    int x = c; // implicit conversion to int
    std::cout << x << "\n";
}

Declarar un enum con ámbito

Añada la palabra clave class (o struct) para crear una enumeración con ámbito. Ahora debe calificar cada valor con el nombre de la enumeración.

#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
    Color c = Color::Green;
    if (c == Color::Green) std::cout << "green\n";
}

Sin conversión implícita

Un enum con ámbito no se convierte implícitamente en un int. Esto evita errores en los que un enum se usa accidentalmente en operaciones aritméticas.

Para obtener el número, debe realizar una conversión explícita.

#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
    Color c = Color::Blue;
    int n = static_cast<int>(c); // explicit
    std::cout << n << "\n"; // prints 2
}

Tipo subyacente

De forma predeterminada, el tipo subyacente es int, pero puede elegir un tipo entero más pequeño o específico para ahorrar espacio o ajustarse a un protocolo.

#include <iostream>
#include <cstdint>
enum class Status : std::uint8_t { Ok = 0, Warn = 1, Error = 2 };
int main() {
    Status s = Status::Warn;
    std::cout << static_cast<int>(s) << "\n";
}

Valores personalizados

Puede asignar valores explícitos a los enumeradores. Los valores posteriores a uno explícito continúan contando a partir de él.

#include <iostream>
enum class Http { Ok = 200, NotFound = 404, ServerError = 500 };
int main() {
    Http h = Http::NotFound;
    std::cout << static_cast<int>(h) << "\n";
}

Usar un enum en switch

Los enums resultan especialmente útiles dentro de las instrucciones switch. Enumerar todos los casos aclara la intención y permite que el compilador advierta sobre los casos que faltan.

#include <iostream>
enum class Dir { North, East, South, West };
const char* name(Dir d) {
    switch (d) {
        case Dir::North: return "N";
        case Dir::East:  return "E";
        case Dir::South: return "S";
        case Dir::West:  return "W";
    }
    return "?";
}
int main() { std::cout << name(Dir::East) << "\n"; }

Enums como argumentos de función

Pasar un enum con ámbito comunica la intención mucho mejor que pasar un int o bool sin más. El compilador garantiza que solo se usen valores válidos del enum.

#include <iostream>
enum class Align { Left, Center, Right };
void render(const char* text, Align a) {
    std::cout << text << " aligned " << static_cast<int>(a) << "\n";
}
int main() { render("Hi", Align::Center); }

Comparar valores de enums

Los enums con ámbito admiten directamente == y !=. Los operadores relacionales (<, >) también funcionan porque los valores están ordenados.

#include <iostream>
enum class Level { Low, Medium, High };
int main() {
    Level l = Level::High;
    std::cout << (l > Level::Low ? "above low\n" : "low\n");
}

Iteración conceptual

Los enums no se recorren automáticamente, pero un patrón habitual consiste en convertirlos a través de sus enteros subyacentes. Mantenga un valor centinela como Count para conocer el intervalo.

#include <iostream>
enum class Coin { Penny, Nickel, Dime, Count };
int main() {
    for (int i = 0; i < static_cast<int>(Coin::Count); ++i)
        std::cout << i << " ";
    std::cout << "\n";
}

Por qué es importante la seguridad de tipos

Dos enums con ámbito que no estén relacionados nunca pueden mezclarse accidentalmente, aunque ambos tengan un valor llamado None. El compilador los trata como tipos distintos.

#include <iostream>
enum class Fruit { None, Apple };
enum class Tool  { None, Hammer };
int main() {
    Fruit f = Fruit::None;
    // Tool t = f; // would NOT compile
    std::cout << (f == Fruit::None) << "\n";
}

Cuándo usar enums simples

Los enums simples todavía aparecen en API heredadas y en código de indicadores de bits, donde resulta práctica la conversión implícita a int. Para código nuevo, prefiera enum class salvo que tenga un motivo específico.

Comprobación rápida

Compruebe cuánto entiende de los enums con ámbito.

Repaso

Ha aprendido sobre los enums con ámbito:

enum class establece un ámbito para los valores y bloquea la conversión implícita a int.
Use static_cast<int> para obtener el número.
Elija un tipo subyacente con : type.
Prefiera enum class para escribir código seguro en cuanto a tipos y que documente su intención.

Preguntas frecuentes

¿La lección «enum class con ámbito» es gratis?

Sí — el texto completo de «enum class con ámbito» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «enum class con ámbito»?

Enumeraciones con seguridad de tipos Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «enum class con ámbito»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy