Types d'héritage en C++ Que devez-vous savoir ?

Vous êtes-vous déjà demandé comment certains systèmes logiciels populaires sont construits ? Tout cela grâce à un puissant mécanisme appelé héritage dans la programmation orientée objet (POO). L'héritage permet aux programmeurs de créer de nouvelles classes basées sur celles existantes, permettant la réutilisation du code et un développement logiciel efficace. Imaginez que vous construisez un système qui nécessite plusieurs classes, chacune partageant des attributs et des comportements communs.

Au lieu d'écrire le même code à plusieurs reprises, vous pouvez utiliser l'héritage pour créer une classe de base et en dériver de nouvelles classes, ce qui vous fait gagner du temps et des efforts.

L'héritage est non seulement efficace mais aussi polyvalent. En C++, il existe plusieurs types d'héritage, chacun avec des avantages et des cas d'utilisation uniques.

Dans cet article, nous examinerons en détail les différents types d'héritage en C++ , en fournissant des codes pertinents, des explications et des exemples concrets tout au long de l'article.

Différents types d'héritage en C++

Le langage de programmation C++ offre cinq types différents d'options d'héritage à ses programmeurs. Selon le contexte et les exigences, les développeurs et les programmeurs peuvent travailler avec l'un ou l'autre de ces types d'héritage.

Héritage unique

L'héritage unique est le type d'héritage le plus courant en C++. En héritage unique, une classe dérivée hérite d'une seule classe de base. Cela signifie qu'une classe hérite de toutes les données membres publiques et protégées et des fonctions membres de la classe de base tout en ayant la possibilité d'ajouter ses propres données membres et fonctions membres.

Consultez l'extrait de code ci-dessous pour obtenir la syntaxe et la compréhension de l'héritage unique :

// Classe de base

classe Animaux {

public:

vide manger() {

std::cout << "L'animal mange" << std::endl;

}

} ;

// Classe dérivée

class Chien : public Animal {

public:

écorce vide() {

std::cout << "Le chien aboie" << std :: endl;

}

} ;

Dans cet exemple, nous avons une classe de base appelée Animal avec une seule fonction membre mange().Nous définissons ensuite une classe dérivéeDog qui hérite publiquement de Animal.Dog a également sa propre fonction membre bark().En utilisant l'héritage unique,Dog peut accéder à la fonction eat()de laclasse Animalet ajouter son propre comportement avec lafonction bark().

Quand utiliser l'héritage unique en C++

Les programmeurs peuvent utiliser l'héritage unique pour créer une classe dérivée qui ajoute des fonctionnalités à la classe de base.

Par exemple, vous pouvez utiliser l'héritage unique lors de la création d'un jeu impliquant différents personnages, tels que des guerriers, des mages et des archers. Tous ces personnages partagent des attributs et des comportements communs, tels que les points de vie, la puissance d'attaque et la vitesse de déplacement. En utilisant l'héritage unique, vous pouvez créer une classe de base appelée Character qui contient les attributs et comportements communs et en dériver chaque classe de caractères pour ajouter leur fonctionnalité unique.

Dans l'héritage multiple, une classe dérivée peut hériter de plusieurs classes de base. Cela signifie qu'une classe peut avoir plusieurs classes parentes directes. Par conséquent, la classe dérivée hérite de toutes les données membres publiques et protégées et des fonctions membres de chaque classe de base.

Voici un exemple d'héritage multiple :

// Classe de base 1

classe Forme {

public:

zone double virtuelle() = 0 ;

} ;

// Classe de base 2

couleur de classe {

public:

std virtuel :: chaîne getColor() = 0 ;

} ;

// Classe dérivée

class Rectangle : forme publique, couleur publique {

public:

double zone() remplacer {

retour largeur * hauteur ;

}

std::string getColor() remplacer {

retourner la couleur ;

}

privé:

double largeur = 5,0 ;

double hauteur = 3,0 ;

std ::string color = "bleu" ;

} ;

Dans cet exemple, nous avons deux classes de base, Shape et Color , chacune avec sa fonction virtuelle.Nous définissons ensuite une classe dérivéeRectangle qui hérite à la fois de Shape et de Color.Rectangle remplace les fonctions virtuelles des deux classes de base pour fournir sa propre implémentation. En utilisant l'héritage multiple,Rectangle peut hériter des propriétés des deux classes de base, ShapeetColor, pour créer un rectangle avec une couleur et une zone spécifiques.

Quand utiliser l'héritage multiple en C++

Utilisez l'héritage multiple lorsque vous souhaitez combiner les fonctionnalités de plusieurs classes de base. Par exemple, considérez une application graphique qui nécessite différents types de contrôles, tels que des boutons, des cases à cocher et des zones de texte. Chaque type de contrôle a ses fonctionnalités et son comportement, mais ils partagent également certaines fonctionnalités communes, telles que la gestion des événements utilisateur et l'affichage de texte.

En utilisant l'héritage multiple, vous pouvez créer une classe de base appeléeControl qui contient la fonctionnalité commune et en dériver chaque type de contrôle, ainsi que d'autres classes de base qui contiennent leur fonctionnalité spécifique.

Dans l'héritage hiérarchique, une seule classe de base est héritée par plusieurs classes dérivées. Comme l'héritage multiple, les classes dérivées dans l'héritage hiérarchique obtiennent toutes les données membres publiques et protégées et les fonctions membres de la classe de base.

Voici un extrait de code pour vous aider à comprendre l'implémentation de l'héritage hiérarchique en C++ :

// Classe de base

classe Animaux {

public:

vide virtuel makeSound() = 0 ;

} ;

// Classe dérivée 1

classe Chat : public Animal {

public:

void makeSound() override {

std :: cout << "Miaou" << std :: endl;

}

} ;

// Classe dérivée 2

class Chien : public Animal {

public:

void makeSound() override {

std :: cout << "Ouaf" << std :: endl;

}

} ;

Dans cet exemple, nous avons une classe de base appelée Animal avec une fonction virtuelle makeSound().Nous définissons ensuite deux classes dérivées,Cat et Dog, qui héritent toutes deux deAnimal. Chaque classe dérivée remplace la fonctionmakeSound() pour fournir sa propre implémentation.En utilisant l'héritage hiérarchique, nous pouvons créer différents types d'animaux qui partagent des comportements communs, comme émettre un son.

Quand utiliser l'héritage hiérarchique en C++

Utilisez l'héritage hiérarchique lorsque vous souhaitez créer plusieurs classes dérivées partageant des fonctionnalités communes. Par exemple, considérez une application bancaire qui nécessite différents types de comptes, tels que des comptes d'épargne, des comptes chèques et des comptes de carte de crédit. Tous ces types de comptes partagent certains attributs et comportements communs, tels que le numéro de compte, le solde et le taux d'intérêt.

En utilisant l'héritage hiérarchique, vous pouvez créer une classe de base appelée Account qui contient les attributs et comportements communs et en dériver chaque type de compte pour ajouter sa fonctionnalité unique.

Héritage à plusieurs niveaux

L'héritage multiniveau en C++ est un type d'héritage dans lequel une classe dérivée est héritée par une autre classe dérivée. Dans ce scénario, la classe dérivée hérite de toutes les données membres publiques et protégées et des fonctions membres de sa classe parent immédiate, qui à son tour hérite de sa propre classe parent, et ainsi de suite.

Voici comment implémenter par programme l'héritage multiniveau en C++ :

// Classe de base

Véhicule de classe {

public:

void start() {

std::cout << "Le véhicule démarre" << std :: endl;

}

} ;

// Classe Intermédiaire

Classe Voiture : Véhicule public {

public:

vider le lecteur() {

std::cout << "La voiture roule" << std :: endl;

}

} ;

// Classe dérivée

classe SportsCar : voiture publique {

public:

vide accélérer() {

std::cout << "La voiture de sport accélère" << std :: endl;

}

} ;

Quand utiliser l'héritage multiniveau en C++

Utilisez l'héritage à plusieurs niveaux lorsque vous souhaitez créer une classe dérivée qui hérite d'une autre classe dérivée et ajoute sa fonctionnalité. Par exemple, considérez un système logiciel qui nécessite différents types de véhicules, tels que des voitures, des camions et des motos. Ces types de véhicules partagent certains attributs et comportements communs, tels que la vitesse, l'accélération et le freinage.

En utilisant l'héritage à plusieurs niveaux, vous pouvez créer une classe de base appelée Vehicle qui contient les attributs et comportements communs et en dériver des classes intermédiaires telles que CaretTruckpour ajouter leurs fonctionnalités spécifiques. Ensuite, vous pouvez dériver laclasse SportsCar de la classe Carpour ajouter sa fonctionnalité unique.

L'héritage hybride est une combinaison de deux ou plusieurs types d'héritage. Également appelée héritage virtuel, une classe dérivée dans l'héritage hybride hérite de plusieurs classes de base, dont certaines sont héritées via plusieurs chemins. Cela peut créer des hiérarchies d'héritage complexes et peut être difficile à comprendre et à gérer.

Découvrezles cours de développement logiciel d'upGradpour vous perfectionner.

Voici un exemple d' héritage hybride en C++ :

// Classe de base 1

classe Animaux {

public:

vide virtuel makeSound() = 0 ;

} ;

// Classe de base 2

classe CanFly {

public:

vol vide virtuel () = 0 ;

} ;

// Classe de base 3

classe CanSwim {

public:

bain vide virtuel () = 0 ;

} ;

// Classe dérivée

class Bat : public Animal, public CanFly {

public:

void makeSound() override {

std :: cout << "Cri !"<< std ::endl;

}

void voler() remplacer {

std::cout << "Chauve-souris vole" << std::endl;

}

} ;

// Classe dérivée

class Penguin : public Animal, public CanSwim {

public:

void makeSound() override {

std :: cout << "Hooonk !"<< std ::endl;

}

void swim() remplacer {

std::cout << "Pingouin nage" << std::endl;

}

} ;

Explorez nos cours populaires de génie logiciel

Quand utiliser l'héritage hybride en C++

Outre les quatre types d'héritage évoqués précédemment, l'héritage hybride peut être utile dans certains scénarios où plusieurs types d'héritage sont requis. Utilisez l'héritage hybride pour combiner les avantages de plusieurs types d'héritage.

Par exemple, considérons un système logiciel qui nécessite différents types d'animaux, dont certains peuvent voler tandis que d'autres peuvent nager. Vous pouvez utiliser l'héritage hybride pour créer une classe de base appelée Animal et en dériver deux classes intermédiaires, CanFlyetCanSwim. Enfin, en utilisant l'héritage hybride, vous pouvez dériver les classesBat et Penguindes deux classes intermédiaires. La classeBat hériterait de AnimaletCanFly, tandis que la classePenguinhériterait deAnimaletCanSwim. De cette façon, vous pouvez créer différents types d'animaux avec des combinaisons uniques de capacités.

L'héritage hybride en C++ peut être utile dans les systèmes logiciels complexes où plusieurs types d'héritage sont requis. Cependant, cela peut également créer des hiérarchies d'héritage complexes qui peuvent être difficiles à comprendre et à gérer. Comme pour les autres types d'héritage, il est crucial de choisir le bon type pour les exigences spécifiques de votre projet de développement logiciel et vos objectifs de conception.

Lisez nos articles populaires liés au développement de logiciels

Consultez noscours de technologie gratuits pour vous démarquer de la concurrence.

Éléments importants à garder à l'esprit lors de l'utilisation de l'héritage :

Bien que l'héritage soit un mécanisme puissant en C++, il a également quelques facteurs à prendre en compte lors de l'implémentation.

1. Évitez les hiérarchies d'héritage profondes : les hiérarchies d'héritage profondes peuvent conduire à un code difficile à lire, à comprendre et à maintenir.Gardez vos hiérarchies d'héritage aussi superficielles que possible pour améliorer la lisibilité et la maintenabilité du code.
2. Utilisez les modificateurs d'accès à bon escient : les modificateurs d'accès (publics, protégés et privés) contrôlent la visibilité des données membres et des fonctions membres dans une classe.Utilisez-les judicieusement pour éviter d'exposer des détails d'implémentation qui ne devraient pas être visibles en dehors de la classe.
3. Éviter l'héritage de diamant : L'héritage de diamant se produit lorsqu'une classe hérite de deux classes qui héritent de la même classe de base.Cela peut conduire à l'ambiguïté et il vaut généralement mieux l'éviter.
4. Évitez d'abuser de l'héritage : bien que l'héritage puisse être utile, il est important d'éviter d'en abuser.Dans certains cas, la composition ou d'autres modèles de conception peuvent être un meilleur choix.

Explorez nos cours gratuits de développement de logiciels

Emporter

Pour résumer, l'héritage est un concept crucial de la programmation C++ que tout étudiant en programmation devrait maîtriser. En comprenant les différents types d'héritage et leurs cas d'utilisation, vous pouvez créer un code efficace, organisé et maintenable, devenant ainsi un meilleur développeur de logiciels.

Si vous avez trouvé cet article intéressant, vous pouvez approfondir vos connaissances en développement logiciel en vous inscrivant au programme de certification DevOps d'upGrad proposé en collaboration avec l'IIIT Bangalore. Ce programme couvre divers aspects du développement de logiciels, y compris le codage, les tests et le déploiement, et peut vous aider à devenir un développeur de logiciels qualifié dans l'industrie.