Enums em C++: enum class vs enum comum explicado

Para que serve um enum

Uma struct agrupa vários valores relacionados em um único objeto. Um enum resolve um problema diferente: ele dá nomes a um conjunto pequeno e fixo de opções. Em vez de lembrar que 0 significa "vermelho", 1 significa "verde" e 2 significa "azul", você escreve Color::Red e o compilador te mantém honesto.

Recorrer a um enum sempre que uma variável só pode assumir um de um punhado de estados nomeados — a cor de um semáforo, o naipe de uma carta, um status de conexão — torna o código autoexplicativo e permite que o compilador pegue erros de digitação e casos faltantes que inteiros puros nunca pegariam.

Declarando um enum

O C++ moderno tem duas variantes. Comece pela que você deve usar quase sempre: o enum class com escopo. Você lista os nomes, e cada enumerador é acessado pelo nome do enum com :::

#include <iostream>
using namespace std;

enum class Color { Red, Green, Blue };

int main() {
    Color c = Color::Green;

    if (c == Color::Green) {
        cout << "It's green!" << endl;
    }

    return 0;
}

Repare que você escreve Color::Green, nunca um Green solto. Os valores em si são apenas rótulos: você os compara, atribui e passa adiante, mas raramente se importa com o número subjacente. Por padrão Red é 0, Green é 1 e Blue é 2, contando a partir de zero.

enum comum vs enum class

O enum mais antigo e sem escopo (sem a palavra-chave class) despeja seus nomes diretamente no escopo ao redor e se converte para int sozinho. Isso parece conveniente, mas causa dois problemas reais:

enum Color { Red, Green, Blue };
enum Fruit { Apple, Banana, Red };  // error: 'Red' already declared

enum Status { Active, Inactive };
int x = Active;          // compiles silently - is this what you meant?
if (Active == Banana) {  // compares unrelated enums via int - allowed!
}

Como os enumeradores comuns são nomes globais, dois enums podem colidir só por compartilharem um rótulo. E como eles decaem para int, o compilador compara tranquilamente valores de enums totalmente sem relação. Um enum class com escopo corrige as duas coisas: os nomes vivem dentro do tipo, e o tipo não vai se transformar silenciosamente em um int:

#include <iostream>
using namespace std;

enum class Status { Active, Inactive };
enum class Fruit { Apple, Banana };

int main() {
    Status s = Status::Active;

    // s == Fruit::Apple;     // won't compile - different types, good
    // int x = s;             // won't compile - no implicit conversion

    cout << (s == Status::Active) << endl;  // prints 1 (true)
    return 0;
}

A regra prática: use enum class por padrão. Só recorra a um enum comum quando você quiser especificamente a conversão implícita para int, como nas antigas constantes de flags no estilo C.

Valores personalizados e o tipo subjacente

Você pode atribuir números explícitos aos enumeradores. Os que você deixar de fora continuam contando a partir do anterior, o que é prático para coisas como códigos de status HTTP ou flags de bits:

#include <iostream>
using namespace std;

enum class HttpStatus {
    Ok = 200,
    NotFound = 404,
    ServerError = 500
};

int main() {
    HttpStatus s = HttpStatus::NotFound;
    cout << "Status code: " << static_cast<int>(s) << endl;
    return 0;
}

Todo enum é respaldado por um tipo inteiro — int por padrão. Você pode fixá-lo em um tipo menor quando se importa com o tamanho, por exemplo ao armazenar muitos enums em uma estrutura compacta ou ao corresponder a um formato de transmissão:

#include <iostream>
#include <cstdint>
using namespace std;

enum class Direction : uint8_t { North, East, South, West };

int main() {
    cout << "size: " << sizeof(Direction) << " byte" << endl;  // 1
    return 0;
}

Escolher o tipo subjacente também garante a faixa em que seus valores devem caber: um enum uint8_t não pode conter um valor acima de 255.

Convertendo entre enum e int

Um enum class com escopo nunca se converte implicitamente, e esse é justamente o objetivo. Quando você realmente precisa do número — para imprimi-lo, indexar um array ou lê-lo de um arquivo — recorra ao static_cast. Ir de enum para int é sempre seguro:

#include <iostream>
using namespace std;

enum class Suit { Hearts, Diamonds, Clubs, Spades };

int main() {
    Suit s = Suit::Clubs;
    int index = static_cast<int>(s);   // 2
    cout << "index: " << index << endl;
    return 0;
}

Converter um int de volta para um enum é a direção perigosa. O cast não verifica que o número corresponda a um enumerador real: ele vai te entregar um valor que tecnicamente está fora do conjunto de nomes do enum:

Suit s = static_cast<Suit>(2);   // fine - that's Clubs
Suit bad = static_cast<Suit>(99); // compiles, but 99 is not a valid Suit
// using `bad` in a switch or as an array index is a lurking bug

Se o inteiro vem da entrada do usuário ou de um arquivo, valide você mesmo a faixa antes de fazer o cast, ou você criará um valor que nenhum case jamais trata — uma fonte sutil de comportamento indefinido mais adiante.

Usando enums com switch

Como um enum é "um de um conjunto fixo", ele combina perfeitamente com um switch. Quando você cobre todos os enumeradores, muitos compiladores vão avisar se mais tarde você adicionar um valor novo e esquecer de tratá-lo: uma segurança de graça que você não tem com inteiros puros:

#include <iostream>
using namespace std;

enum class TrafficLight { Red, Yellow, Green };

void describe(TrafficLight light) {
    switch (light) {
        case TrafficLight::Red:
            cout << "Stop" << endl;
            break;
        case TrafficLight::Yellow:
            cout << "Slow down" << endl;
            break;
        case TrafficLight::Green:
            cout << "Go" << endl;
            break;
    }
}

int main() {
    describe(TrafficLight::Yellow);
    return 0;
}

Uma pegadinha: não há uma forma nativa de imprimir o nome de um enumerador. cout << TrafficLight::Red não vai compilar para um enum com escopo, e mesmo para um enum comum ele imprime o número, não "Red". Um pequeno switch ou uma tabela de consulta como a acima é a forma usual de transformar um enum em uma string legível para humanos.

Próximo: Exceções

Enums e structs permitem modelar como seus dados se parecem. Mas programas reais também precisam lidar com coisas dando errado — um arquivo que não abre, um número que não dá para parsear, um valor fora da faixa. C++ trata esses caminhos de falha com exceções, e esse é o tema da próxima página.