Classes abstraites et méthodes virtuelles pures
Définir des interfaces avec des méthodes virtuelles pures et imposer les contrats des classes dérivées
Classes abstraites et méthodes virtuelles pures est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Qu'est-ce qu'une classe abstraite ?
Une classe abstraite possède au moins une fonction purement virtuelle, déclarée avec = 0. Vous ne pouvez pas l'instancier directement.
class Animal {
public:
virtual void speak() const = 0; // pure virtual
virtual ~Animal() = default;
};
// Animal a; // ERROR: cannot instantiateFonctions virtuelles pures
= 0 indique qu'une fonction ne possède aucune implémentation par défaut. Les classes dérivées doivent la redéfinir avant que la classe puisse être instanciée.
Implémenter l'interface
Les classes dérivées fournissent un corps concret pour chaque fonction virtuelle pure.
class Dog : public Animal {
public:
void speak() const override {
std::cout << "Woof!\n";
}
};
Dog d;
d.speak(); // Woof!Les classes abstraites comme interfaces
Une classe abstraite composée uniquement de méthodes virtuelles pures et dépourvue de membres de données joue le rôle d'une interface dans d'autres langages.
class Drawable {
public:
virtual void draw() const = 0;
virtual ~Drawable() = default;
};Combiner implémentation et interface
Les classes abstraites peuvent posséder à la fois des méthodes virtuelles pures et des méthodes concrètes. Les fonctions virtuelles pures définissent le contrat ; les méthodes concrètes fournissent un comportement partagé.
class Logger {
public:
void logInfo(const std::string& msg) { log("INFO", msg); }
void logError(const std::string& msg) { log("ERROR", msg); }
protected:
virtual void log(const std::string& level, const std::string& msg) = 0;
};Fonction virtuelle pure avec un corps par défaut
Une fonction virtuelle pure peut avoir un corps, ce qui est utile comme comportement par défaut que les classes dérivées peuvent appeler.
class Base {
public:
virtual void f() = 0;
};
void Base::f() {
std::cout << "default behavior\n";
}
class Derived : public Base {
public:
void f() override {
Base::f(); // call the default
std::cout << "extra\n";
}
};Utiliser des pointeurs et des références
Le code polymorphe manipule les objets abstraits via des pointeurs ou des références vers le type de base.
void perform(const Animal& a) {
a.speak();
}Stocker dans des conteneurs
Les vecteurs ne peuvent pas contenir des types abstraits par valeur. Utilisez des pointeurs, généralement des pointeurs intelligents.
std::vector<std::unique_ptr<Animal>> zoo;
zoo.push_back(std::make_unique<Dog>());
zoo.push_back(std::make_unique<Cat>());
for (auto& a : zoo) a->speak();Quand utiliser les classes abstraites
Utilisez-les lorsque :
- vous souhaitez définir une interface commune pour plusieurs implémentations indépendantes
- vous avez besoin d'un type de base pour des conteneurs polymorphes
- vous souhaitez injecter un comportement via des sous-classes (patron Méthode modèle)
Alternatives : concepts et modèles
Pour le polymorphisme à la compilation, les concepts de C++20 et les modèles remplacent souvent les classes abstraites, sans coût d'exécution. Utilisez les fonctions virtuelles lorsque le polymorphisme est nécessaire à l'exécution.
Piège : le tronquage
Transmettez les classes abstraites par référence ou par pointeur. La transmission par valeur est de toute façon impossible, puisqu'un type abstrait ne peut pas être instancié, mais une classe dérivée transmise par valeur subirait un tronquage.
Vérification rapide
Qu'est-ce qui rend une classe abstraite en C++ ?
Récapitulatif
Les classes abstraites, c'est-à-dire celles qui possèdent au moins une méthode virtuelle pure, définissent des interfaces pour le code polymorphe. Utilisez-les avec des pointeurs ou des références, souvent des pointeurs intelligents, afin de choisir le comportement à l'exécution.
Questions Fréquemment Posées
La leçon « Classes abstraites et méthodes virtuelles pures » est-elle gratuite ?
Oui — le texte complet de « Classes abstraites et méthodes virtuelles pures » 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 « Classes abstraites et méthodes virtuelles pures » ?
Définir des interfaces avec des méthodes virtuelles pures et imposer les contrats des classes dérivées 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 3 sur 4.
Combien de temps prend la leçon « Classes abstraites et méthodes virtuelles pures » ?
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
- Héritage simple et multiple
- Fonctions virtuelles et vtable
- Classes abstraites et méthodes virtuelles pures
- Héritage ou composition : compromis