Héritage C++
Héritage C++
Dans ce didacticiel, nous allons découvrir l'héritage en C++ à l'aide d'exemples.
L'héritage est l'une des principales caractéristiques de la programmation orientée objet en C++. Il nous permet de créer une nouvelle classe (classe dérivée) à partir d'une classe existante (classe de base).
La classe dérivée hérite des fonctionnalités de la classe de base et peut avoir des fonctionnalités supplémentaires qui lui sont propres. Par exemple,
class Animal {
// eat() function
// sleep() function
};
class Dog : public Animal {
// bark() function
};
Ici, le Dog la classe est dérivée du Animal classer. Depuis Dog est dérivé de Animal , membres de Animal sont accessibles à Dog .
Remarquez l'utilisation du mot-clé public tout en héritant Dog de Animal.
class Dog : public Animal {...};
On peut aussi utiliser les mots clés private et protected au lieu de public . Nous apprendrons les différences entre l'utilisation de private , public et protected plus loin dans ce didacticiel.
est-une relation
L'héritage est une est-une relation . Nous utilisons l'héritage uniquement si une est-une relation est présent entre les deux classes.
Voici quelques exemples :
- Une voiture est un véhicule.
- L'orange est un fruit.
- Un chirurgien est un médecin.
- Un chien est un animal.
Exemple 1 :Exemple simple d'héritage C++
// C++ program to demonstrate inheritance
#include <iostream>
using namespace std;
// base class
class Animal {
public:
void eat() {
cout << "I can eat!" << endl;
}
void sleep() {
cout << "I can sleep!" << endl;
}
};
// derived class
class Dog : public Animal {
public:
void bark() {
cout << "I can bark! Woof woof!!" << endl;
}
};
int main() {
// Create object of the Dog class
Dog dog1;
// Calling members of the base class
dog1.eat();
dog1.sleep();
// Calling member of the derived class
dog1.bark();
return 0;
}
Sortie
I can eat! I can sleep! I can bark! Woof woof!!
Ici, chien1 (l'objet de la classe dérivée Dog ) peut accéder aux membres de la classe de base Animal . C'est parce que Dog est hérité de Animal .
// Calling members of the Animal class
dog1.eat();
dog1.sleep(); Membres protégés C++
Le modificateur d'accès protected est particulièrement pertinent lorsqu'il s'agit d'héritage C++.
Comme private membres, protected les membres sont inaccessibles en dehors de la classe. Cependant, ils sont accessibles par les classes dérivées et classes/fonctions d'amis .
Nous avons besoin de protected membres si nous voulons masquer les données d'une classe, mais voulons toujours que ces données soient héritées par ses classes dérivées.
Pour en savoir plus sur protected, consultez notre tutoriel sur les modificateurs d'accès C++.
Exemple 2 :Membres protégés C++
// C++ program to demonstrate protected members
#include <iostream>
#include <string>
using namespace std;
// base class
class Animal {
private:
string color;
protected:
string type;
public:
void eat() {
cout << "I can eat!" << endl;
}
void sleep() {
cout << "I can sleep!" << endl;
}
void setColor(string clr) {
color = clr;
}
string getColor() {
return color;
}
};
// derived class
class Dog : public Animal {
public:
void setType(string tp) {
type = tp;
}
void displayInfo(string c) {
cout << "I am a " << type << endl;
cout << "My color is " << c << endl;
}
void bark() {
cout << "I can bark! Woof woof!!" << endl;
}
};
int main() {
// Create object of the Dog class
Dog dog1;
// Calling members of the base class
dog1.eat();
dog1.sleep();
dog1.setColor("black");
// Calling member of the derived class
dog1.bark();
dog1.setType("mammal");
// Using getColor() of dog1 as argument
// getColor() returns string data
dog1.displayInfo(dog1.getColor());
return 0;
} Sortie
I can eat! I can sleep! I can bark! Woof woof!! I am a mammal My color is black
Ici, la variable type est protected et est donc accessible depuis la classe dérivée Dog . Nous pouvons le voir car nous avons initialisé type dans le Dog classe utilisant la fonction setType() .
En revanche, le private variable couleur ne peut pas être initialisé en Dog .
class Dog : public Animal {
public:
void setColor(string clr) {
// Error: member "Animal::color" is inaccessible
color = clr;
}
};
De plus, depuis le protected le mot-clé masque les données, nous ne pouvons pas accéder à type directement depuis un objet de Dog ou Animal classe.
// Error: member "Animal::type" is inaccessible
dog1.type = "mammal"; Modes d'accès dans l'héritage C++
Dans nos tutoriels précédents, nous avons découvert les spécificateurs d'accès C++ tels que public, private et protected.
Jusqu'à présent, nous avons utilisé le public mot clé afin d'hériter d'une classe d'une classe de base préexistante. Cependant, nous pouvons également utiliser le private et protected mots-clés pour hériter des classes. Par exemple,
class Animal {
// code
};
class Dog : private Animal {
// code
};
class Cat : protected Animal {
// code
}; Les différentes façons dont nous pouvons dériver des classes sont appelées modes d'accès . Ces modes d'accès ont les effets suivants :
- public : Si une classe dérivée est déclarée en
publicmode, alors les membres de la classe de base sont hérités par la classe dérivée tels quels. - privé : Dans ce cas, tous les membres de la classe de base deviennent
privatemembres de la classe dérivée. - protégé : Le
publicles membres de la classe de base deviennentprotectedmembres de la classe dérivée.
Le private les membres de la classe de base sont toujours private dans la classe dérivée.
Pour en savoir plus, consultez notre didacticiel C++ sur l'héritage public, privé et protégé.
Remplacement de la fonction membre dans l'héritage
Supposons que la classe de base et la classe dérivée aient des fonctions membres avec le même nom et les mêmes arguments.
Si nous créons un objet de la classe dérivée et essayons d'accéder à cette fonction membre, la fonction membre de la classe dérivée est appelée à la place de celle de la classe de base.
La fonction membre de la classe dérivée remplace la fonction membre de la classe de base.
En savoir plus sur la substitution de fonction en C++.
Lecture recommandée : Héritage multiple C++
Langue C