Contenu du cours
Programmation Orientée Objet en C++
Programmation Orientée Objet en C++
Méthode Virtuelle Pure
Le concept de méthodes virtuelles est essentiel pour atteindre le polymorphisme, permettant une conception logicielle flexible et extensible. Les méthodes virtuelles pures vont plus loin en définissant des interfaces et en prenant en charge la liaison dynamique.
Syntaxe d'une méthode virtuelle pure
Une méthode virtuelle pure est déclarée avec le mot-clé virtual et initialisée à zéro. Cela indique que la fonction n'a pas de définition dans la class et doit être redéfinie par toute sous-classe avant que des objets de cette class puissent être instanciés.
virtual.h
virtual void example() = 0;
Cette méthode fonctionne de manière similaire à une méthode standard, à l'exception qu'elle ne possède pas de corps délimité par { } et se termine par = 0;, indiquant ainsi l'absence d'implémentation. Cependant, les autres règles pour cette méthode sont identiques à celles des méthodes ordinaires.
Déclarer une méthode virtuelle pure rend la class dans laquelle elle est déclarée abstraite, ce qui signifie qu'il devient impossible d'instancier des objets de cette classe. Cette restriction existe car chaque méthode de la class doit être implémentée avant de créer et d'utiliser une instance, afin de prévenir les erreurs et les comportements imprévisibles. Examinez le code ci-dessous :
Animal.h
class Animal { public: virtual void speak() = 0; };
La Animal class comporte une méthode virtuelle pure nommée speak(), empêchant l'instanciation d'objets à partir de cette classe. Cette conception est logique, car l'objectif de la méthode virtuelle est de représenter les sons distinctifs produits par chaque animal.
En rendant la méthode virtuelle, chaque sous-classe peut fournir sa propre implémentation, reflétant l'individualité du son de chaque animal. La déclaration en tant que virtuelle pure indique qu'aucune implémentation par défaut n'existe, soulignant la nécessité d'implémentations concrètes dans les classes dérivées.
main.cpp
#include "Animal.h" int main() { // cannot declare variable 'animal' to be of abstract type Animal animal; }
Cela est également cohérent. Créer des instances de la Animal class serait impraticable et contre-intuitif, car elle représente un concept abstrait servant de catégorie pour différents animaux. Aucun comportement spécifique n'est associé à un animal générique, ce qui renforce le caractère abstrait de la class et met en avant l'importance de créer des sous-classes spécialisées pour représenter les sons uniques de chaque animal spécifique.
main.cpp
#include <iostream> class Animal { public: // Pure virtual function to enforce implementation in derived classes virtual void speak() = 0; }; class Cat : public Animal { public: void speak() override { std::cout << "Meow!" << std::endl; } }; class Dog : public Animal { public: void speak() override { std::cout << "Bark!" << std::endl; } }; class Cow : public Animal { public: void speak() override { std::cout << "Moo!" << std::endl; } }; void pet(Animal& animal) { animal.speak(); } int main() { // Replace `Cat` with `Dog` or `Cow` to see their specific behavior Cat cat; pet(cat); }
Bien qu'il ne soit pas possible de créer un objet de type Animal directement, il est tout de même possible de l'utiliser comme paramètre dans une fonction. À l'instar de l'exemple précédent avec le bouton, cette approche exploite le polymorphisme pour concevoir un programme polyvalent capable de modifier dynamiquement son comportement à l'exécution.
Essayez de passer un objet d'une autre class à la fonction et observez le résultat. Essayez également de créer un objet de la class abstraite afin de constater comment le compilateur empêche l'instanciation en raison de méthodes virtuelles pures non implémentées.
Merci pour vos commentaires !
