Classe enum à portée limitée
Utiliser des énumérations sûres du point de vue des types
Classe enum à portée limitée est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
Les énumérations classiques exposent leurs noms
Une enum classique de style C déverse ses noms dans la portée environnante et se convertit silencieusement en int. Les conflits de noms et les comparaisons accidentelles deviennent ainsi faciles.
- Une énumération à portée corrige ces deux problèmes.
- Les valeurs ont une portée propre et sont fortement typées.
#include <iostream>
enum Color { Red, Green, Blue };
int main() {
Color c = Green;
int x = c; // implicit conversion to int
std::cout << x << "\n";
}Déclarer une énumération à portée
Ajoutez le mot-clé class (ou struct) pour créer une énumération à portée. Vous devez alors qualifier chaque valeur avec le nom de l'énumération.
#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
Color c = Color::Green;
if (c == Color::Green) std::cout << "green\n";
}Aucune conversion implicite
Une énumération à portée ne se transforme pas implicitement en int. Cela évite les erreurs où une énumération serait accidentellement utilisée dans un calcul.
- Pour obtenir le nombre, vous devez effectuer une conversion explicite.
#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
}Type sous-jacent
Par défaut, le type sous-jacent est int, mais vous pouvez choisir un type entier plus petit ou particulier pour économiser de l'espace ou respecter un protocole.
#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";
}Valeurs personnalisées
Vous pouvez attribuer des valeurs explicites aux énumérateurs. Les valeurs qui suivent une valeur explicite continuent à être comptées à partir de celle-ci.
#include <iostream>
enum class Http { Ok = 200, NotFound = 404, ServerError = 500 };
int main() {
Http h = Http::NotFound;
std::cout << static_cast<int>(h) << "\n";
}Utiliser une énumération dans une instruction de sélection
Les énumérations sont particulièrement utiles dans les instructions switch. Énumérer chaque cas clarifie l'intention et permet au compilateur de signaler les cas manquants.
#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"; }Énumérations comme arguments de fonction
Transmettre une énumération à portée exprime bien mieux l'intention que de transmettre un simple int ou bool. Le compilateur impose que seules des valeurs d'énumération valides soient utilisées.
#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); }Comparer des valeurs d'énumération
Les énumérations à portée prennent directement en charge == et !=. Les opérateurs relationnels (<, >) fonctionnent également, car les valeurs sont ordonnées.
#include <iostream>
enum class Level { Low, Medium, High };
int main() {
Level l = Level::High;
std::cout << (l > Level::Low ? "above low\n" : "low\n");
}Parcourir conceptuellement
Les énumérations ne sont pas parcourables automatiquement, mais une méthode courante consiste à effectuer une conversion via les entiers sous-jacents. Conservez une valeur sentinelle comme Count pour connaître la plage.
#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";
}Pourquoi la sûreté des types est importante
Deux énumérations à portée indépendantes ne peuvent jamais être mélangées accidentellement, même si elles possèdent toutes deux une valeur nommée None. Le compilateur les traite comme des types distincts.
#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";
}Quand utiliser des énumérations classiques
Les énumérations classiques apparaissent encore dans les API anciennes et dans le code utilisant des indicateurs binaires, où la conversion implicite en int est pratique. Pour le nouveau code, préférez une énumération à portée, sauf raison particulière.
Vérification rapide
Vérifiez votre compréhension des énumérations à portée.
Récapitulatif
Vous avez découvert les énumérations à portée :
enum classdéfinit la portée des valeurs et bloque la conversion implicite vers int.- Utilisez
static_cast<int>pour lire le nombre. - Choisissez un type sous-jacent avec
: type. - Préférez
enum classpour un code sûr du point de vue des types et auto-documenté.
Questions Fréquemment Posées
La leçon « Classe enum à portée limitée » est-elle gratuite ?
Oui — le texte complet de « Classe enum à portée limitée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Classe enum à portée limitée » ?
Utiliser des énumérations sûres du point de vue des types Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Classe enum à portée limitée » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Classe enum à portée limitée
- Unions et risques associés
- std::variant
- std::visit