http://robert.cireddu.free.fr/SNIR/
Extrait du référentiel : BTS Systèmes Numériques option A (Informatique et Réseaux) Niveau(x) S4. Développement logiciel
S4.6. Programmation orientée objet (Support : C++)
S4.7. Langages de programmation
Définition de classes (encapsulation) et modèle canonique (dit de Coplien)
Surcharges d’opérateurs (injection, etc.) C++
3 3 3
Objectifs du cours :
- Héritage :
- héritage simple et constructeur - règles à respecter
- règles de visibilité - statut protected
HÉRITAGE
Le concept d’héritage constitue l’un des fondements de la programmation orientée objet.
Dans la vie courante, l’héritage naturel se fait entre grands-parents et parents. L’intérêt est que les parents puissent bénéficier des « richesses » des grands-parents en apportant également leur propre « richesse » personnelle.
En informatique, l’idée de base est identique.
L’héritage autorise de définir une nouvelle classe appelée classe dérivée, à partir d’une classe existante appelée classe de base. On parle de spécialisation.
On spécialise la classe dérivée : il ne figure dans cette classe que les attributs et méthodes propres.
Classe de base ou Super-Classe ou Classe-mère : c’est la classe « donatrice ».
Classe dérivée ou Classe fille : c’est la classe qui hérite.
Lorsque l’on dérive une classe : on effectue une spécialisation.
Lorsque l’on remonte sur une classe de base : on effectue une généralisation.
HÉRITAGE SIMPLE ET CONSTRUCTEUR
En langage C++, la déclaration d’une classe dérivée s’écrit :
class <nom de la classe dérivée> : public <nom de la classe de base>
Exemple :
On spécialise la classe Cpoint en une classe Cptcouleur :
#include <iostream>
using namespace std;
class Cpoint {
private: // membres privés int x;
int y;
public: // membres publics Cpoint(int, int);
~Cpoint();
void affiche();
};
class Cptcouleur : public Cpoint // la classe dérivée {
private:
char color; // une lettre
public:
Cptcouleur(int, int, char); // déclaration du constructeur de la classe dérivée ~Cptcouleur();
void affiche();
};
Cpoint::Cpoint(int abs, int ord) {
x = abs;
y = ord;
cout << "Constructeur point" << endl;
}
Cpoint::~Cpoint() {
cout << "Destructeur point" << endl;
}
{
cout << "Les coordonnees du point sont: " << x << '\t' << y << endl;
}
Cptcouleur::Cptcouleur(int abs, int ord, char car):Cpoint(abs, ord) {
color = car;
cout << "Constructeur ptcouleur" << endl;
}
Cptcouleur::~Cptcouleur() {
cout << "Destructeur ptcouleur" << endl;
}
void Cptcouleur::affiche() {
Cpoint::affiche();
cout << "et la couleur du point est : " << color << endl;
}
int main() {
Cpoint UnPoint(2, 8);
UnPoint.affiche();
Cptcouleur a(10, 20, 'b'); // objet automatique a.affiche();
Cptcouleur *adr; // objet dynamique adr = new Cptcouleur(12, 25, 'n');
adr->affiche();
delete adr;
return 0;
}
Résultat :
Constructeur point
Les coordonnees du point sont: 2 8 Constructeur point
Constructeur ptcouleur
Les coordonnees du point sont: 10 20 et la couleur du point est : b
Constructeur point Constructeur ptcouleur
Les coordonnees du point sont: 12 25 et la couleur du point est : n
Destructeur ptcouleur Destructeur point Destructeur ptcouleur Destructeur point Destructeur point
La définition du constructeur de la classe dérivée :
Attributs de la classe de base Attribut de la classe dérivée Constructeur appelé de la classe de base
Cptcouleur::Cptcouleur(int abs, int ord, char car):Cpoint(abs, ord) {
color = car;
cout << "Constructeur ptcouleur" << endl;
}
Si la classe de base possède plusieurs constructeurs (surdéfinition de méthodes), le constructeur appelé est celui correspondant à la liste et type des arguments fournis.
Les attributs destinés au constructeur de la classe de base lui sont passés. Attention à ne pas redéclarer de nouveau ces variables. Les variables doivent être passées au
constructeur de recopie dans le même ordre qui est prévu pour le constructeur de la classe de base.
RÈGLES À RESPECTER
Il faut impérativement que la classe de base soit préalablement déclarée avant de créer la nouvelle classe dérivée.
On peut dériver autant de fois que l’on souhaite une même classe.
Il faut impérativement que le constructeur de la classe dérivée possède un nombre d’arguments supérieur ou égal à ceux du constructeur de la classe de base (avec concordance des types).
Le constructeur de la classe dérivée doit recevoir tous les arguments à initialiser pour un objet dérivé. Cependant, le constructeur de la classe dérivée initialisera que les attributs de sa classe, les autres arguments étant passés au constructeur de la classe de base.
Lors de la création d’un objet d’une classe dérivée, l’ordre d’appel des constructeurs se déroule de la façon suivante :
Appel du constructeur de la classe dérivée qui appel le constructeur de la classe de base.
Les arguments propres au constructeur de la classe de base lui sont passés en paramètres.
Exécution des instructions du constructeur de la classe de base.
Exécution des instructions du constructeur de la classe dérivée.
Lors de la destruction d’un objet d’une classe dérivée, il y a appel dans l’ordre inverse des destructeurs par rapport à celui des constructeurs.
RÈGLES DE VISIBILITÉ
En langage C++, il existe trois types de dérivations :
- dérivation publique ; - dérivation privée ; - dérivation protégée.
Seule la dérivation publique est au programme.
- private : un membre privé n’est accessible qu’aux fonctions membres (publics ou privées) de la classe.
- public : un membre public est accessible non seulement aux fonctions membres, mais également à l’utilisateur de la classe (une instance de cette classe).
- protected : un membre protégé est inacessible à l’utilisateur de la classe, pour qui il se
comporte comme un membre privé. Mais il est accessible pour les membres privés ou publics de la classe.
Dérivation publique :
- les membres publics de la classe de base sont accessibles par tous, fonctions membres et objets de la classe de base et de la classe dérivée.
- les membres protégés de la classe de base sont accessibles à la fois aux fonctions membres de la classe de base et de la classe dérivée. Mais ils sont inaccessibles aux utilisateurs.
- les membres privés de la classe de base sont inaccessibles à la fois aux fonctions membres et aux utilisateurs de la classe dérivée.
STATUT PROTECTED Exemple :
#include <iostream>
using namespace std;
class Cpoint {
protected: // membres protégés int x;
int y;
public: // membres publics void initialise(int, int);
void deplace(int, int);
void affiche();
};
class Cptcouleur : public Cpoint {
private:
int color;
public:
void initialisecouleur(int, int, int);
void affichecouleur();
};
void Cpoint::initialise(int abs, int ord) {
x = abs;
y = ord;
}
void Cpoint::deplace(int dx, int dy) {
x = x + dx;
y = y + dy;
}
void Cpoint::affiche() {
cout << "Les coordonnees du point sont : " << x << '\t' << y << endl;
}
void Cptcouleur::initialisecouleur(int abs, int ord, int coul) {
initialise(abs, ord); // appel de la fonction membre de la classe Cpoint color = coul;
}
void Cptcouleur::affichecouleur() {
cout << "Je suis en " << x << " " << y << endl;
cout << "et ma couleur est : " << color << endl;
}
int main() {
Cptcouleur p; // p est un objet de la classe Cptcouleur p.initialisecouleur(10, 20, 5);
p.affichecouleur();
p.affiche();
p.deplace(2, 4);
p.affichecouleur();
p.affiche();
return 0;
}
Résultat :
Je suis en 10 20 et ma couleur est : 5
Les coordonnees du point sont : 10 20 Je suis en 12 24
et ma couleur est : 5
Les coordonnees du point sont : 12 24
Les coordonnées du point ont été déclarées en statut protected au lieu du statut habituel private dans la classe de base Cpoint. De ce fait, la méthode affichecouleur() de la classe dérivée peut accéder aux attributs (x, y) de la classe de base, tout en protégeant ces derniers (les coordonnées x, y) de leur utilisation par un objet de la classe de base ou de la classe dérivée.
