C++ Academy · Aula

enum class com escopo

Enumerações com segurança de tipos

enum class com escopo é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Enumerações simples expõem nomes

Um enum clássico no estilo C despeja seus nomes no escopo ao redor e converte silenciosamente para int. Isso facilita conflitos de nomes e comparações acidentais.

enum class resolve os dois problemas.
Os valores têm escopo próprio e tipagem forte.

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

Declarando uma enumeração com escopo

Adicione a palavra-chave class (ou struct) para criar uma enumeração com escopo. Agora é necessário qualificar cada valor com o nome da enumeração.

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

Sem conversão implícita

Uma enumeração com escopo não se transforma implicitamente em um int. Isso evita erros em que uma enumeração é usada acidentalmente em operações aritméticas.

Para obter o número, é necessário fazer uma conversão 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 subjacente

Por padrão, o tipo subjacente é int, mas você pode escolher um tipo inteiro menor ou específico para economizar espaço ou corresponder a um 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

Você pode atribuir valores explícitos aos enumeradores. Os valores que vêm depois de um valor explícito continuam a contagem a partir dele.

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

Usando uma enumeração em switch

As enumerações são especialmente úteis em instruções switch. Listar todos os casos deixa a intenção clara e permite que o compilador avise sobre casos ausentes.

#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"; }

Enumerações como argumentos de funções

Passar uma enumeração com escopo comunica a intenção muito melhor do que passar um int ou bool simples. O compilador garante que apenas valores válidos da enumeração sejam usados.

#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); }

Comparando valores de enumerações

Enumerações com escopo aceitam diretamente == e !=. Operadores relacionais (<, >) também funcionam porque os valores são 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");
}

Iterando conceitualmente

As enumerações não são iteradas automaticamente, mas um padrão comum é fazer conversões usando os inteiros subjacentes. Mantenha um marcador final como Count para conhecer o 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 que a segurança de tipos é importante

Duas enumerações com escopo não relacionadas nunca podem ser misturadas acidentalmente, mesmo que ambas tenham um valor chamado None. O compilador as 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";
}

Quando usar enumerações simples

Enumerações simples ainda aparecem em APIs legadas e em código de sinalizadores de bits, nos quais a conversão implícita para int é conveniente. Para código novo, prefira enum class, a menos que tenha um motivo específico.

Verificação rápida

Teste a sua compreensão das enumerações com escopo.

Recapitulação

Você aprendeu sobre enumerações com escopo:

enum class define o escopo dos valores e impede a conversão implícita para int.
Use static_cast<int> para ler o número.
Escolha um tipo subjacente com : type.
Prefira enum class para obter código com segurança de tipos e autoexplicativo.

Perguntas Frequentes

A aula “enum class com escopo” é grátis?

Sim — o texto completo de “enum class com escopo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “enum class com escopo”?

Enumerações com segurança de tipos Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “enum class com escopo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy