Chapitre VIII Structures dobjets. Chapitre VIII - Structures d'objets2 Structures d objets Il existe plusieurs relations entre les classes. Lhéritage

Chapitre VIIIChapitre VIII

Structures d’objets

Chapitre VIII - Structures d'objets 2

Structures d ’objets

Il existe plusieurs relations entre les classes.Il existe plusieurs relations entre les classes.

L’héritage n’est pas la seule technique permettant de relier 2 classes.L’héritage n’est pas la seule technique permettant de relier 2 classes.

D’autres possibilités:D’autres possibilités:

les classes internes: classes à l’intérieur d’une autre classe

limite la portée d’utilisation

les associations d’objets

les agrégations d’objets: un objet est défini à partir d’un ou plusieurs objets(objets composites)

On peut aussi gérer une collection d’objets: tableaux d’objets, listes d’objets, etc.On peut aussi gérer une collection d’objets: tableaux d’objets, listes d’objets, etc.


Tableaux statiques d’objetsSyntaxe Ex. Objet_2D Ensemble_objets[20];

nom d’une classe3 contraintes:Le nombre d’éléments doit être connu à la création du tableau.

La classe pour laquelle vous définissez un tableau doit obligatoirement posséder unconstructeur sans argument car, le constructeur de la classe sera appelé pour chacunde ces objets.Tous les objets appartiennent à la même classe.

Ex.: const Nombre_de_polygones = 25;Polygone_2D Scene_2D[Nombre_de_polygones];……..For (int i = 0; i < Nombre_de_polygones; i++)

cout << Scene_2D[i].Nombre_de_sommets();


Tableaux statiques de pointeurs d’objets

Pour définir un tableau qui soit capable de gérer des objets appartenant à plusieursclasses, vous devrez stocker dans ce tableau non pas des objets, mais des pointeursd’objets.

Si le type du pointeur correspond à un pointeur de la classe de base, ce tableau pourracontenir les adresses de n’importe quel objet dérivé de cette classe.

On dispose alors d’un seul et même tableau pouvant stocker les adressesd’objets différents.

On doit nous-même créer dynamiquement ces objets et stocker leurs adresses dans letableau (opérateur new).

Pour simplifier la gestion d’un tableau de pointeurs d’objets, il est conseillé de définirune classe spécialisée dans ce domaine.

On peut ainsi centraliser tous les traitements liés à la gestion du tableau.



const Nombre_maximum_elements = 20;class classe_de_base{};class Tableau_statique_de_pointeurs{/* Spécification fonctionnelle de la classe

"Tableau_statique_de_pointeurs" */

protected:int Nombre_elements_presents;classe_de_base *Tableau_statique[Nombre_maximum_elements];



public:Tableau_statique_de_pointeurs();/* Permet de créer un tableau statique de pointeurs où les

composantes sont initialisées à NULL.Pré - Nil.Post - Un tableau vide de pointeurs d'objets est créé.*/

void Inserer_pointeur_objet(int i, classe_de_base * pObjet);/* Permet d'insérer le pointeur d'un objet en position i.

Pré - 1 <= i <= Nombre_maximum_elements.Il n'existe pas de pointeur d'objet à cette position.

Post - L'élément est inséré en position i. */



classe_de_base * Enlever_pointeur_objet(int i);/* Permet s'il existe d'enlever l'objet en position i du tableau

et de retourner son adresse. Autrement, NULL est retournée.Pré - 1 <= i <= Nombre_maximum_elements.Post - Il n'existe plus d'objet en position i du tableau.

S'il en existait un, son adresse est retournée. */int Rechercher_place_disponible();/* Retourne la position d'un élément du tableau où il n'y a pas

d'objet. S'il n'existe aucune place disponible, la valeur 0est retournée.Pré - NilPost - Retourne la position d'un espace disponible.0 autrement.*/



int Nb_elements_presents();/* Retourne le nombre d'objets présents dans le tableau.

Pré - NilPost - Retourne le nombre de pointeurs d'objets présents

dans le tableau. */};



#include "Tableau_statique_de_pointeurs.h"#include "stdio.h"Tableau_statique_de_pointeurs::Tableau_statique_de_pointeurs(){

Nombre_elements_presents = 0;for (int i = 0; i < Nombre_maximum_elements; i++)

Tableau_statique[i] = NULL;}void Tableau_statique_de_pointeurs::Inserer_pointeur_objet

(int i, classe_de_base * pObjet){

Nombre_elements_presents += 1; Tableau_statique[i-1] = pObjet;}



classe_de_base * Tableau_statique_de_pointeurs::Enlever_pointeur_objet(int i)

{ classe_de_base * p;if (Tableau_statique[i-1] != NULL)

Nombre_elements_presents -= 1;p = Tableau_statique[i-1]; Tableau_statique[i-1] = NULL;return p;

}int Tableau_statique_de_pointeurs::Rechercher_place_disponible(){ for (int i = 0; i< Nombre_maximum_elements; i++)

if(Tableau_statique[i] == NULL) return i+1;return 0;

}



int Tableau_statique_de_pointeurs::Nb_elements_presents(){

return Nombre_elements_presents;}

#include <iostream.h>#include "Tableau_statique_de_pointeurs.h"class dossier_medical: public classe_de_base{

// .......};



void main(){

dossier_medical A, B, C;Tableau_statique_de_pointeurs T;T.Inserer_pointeur_objet(1, &A);T.Inserer_pointeur_objet(5, &B);T.Inserer_pointeur_objet(T.Rechercher_place_disponible(), &C);cout << "Nombre de dossiers medicaux: "

<< T.Nb_elements_presents();T.Enlever_pointeur_objet(5);cout << "Nombre de dossiers medicaux: "

<< T.Nb_elements_presents();}


Tableaux dynamiques de pointeurs d’objets

Tableaux dont le nombre d’éléments peut être fixé à l’exécution du programme.

pointeur = new Type[nombre];

où Type désigne un type du langage et peut correspondre. aux types primaires du C++,. à tout type créé (structure, classe, etc.)

où nombre peut correspondre à une variable ou à une expression,

où pointeur permet de stocker l’adresse du premier élément du tableau.

Un tableau dynamique doit être explicitement détruit.

delete [] pointeur;

Cette syntaxe estobligatoire

pour libérer toutel’espace mémoire.



Ex.: int Nombre_de_polygones = 25;Polygone_2D * pScene_2D = new Polygone_2D [Nombre_de_polygones];……..For (int i = 0; i < Nombre_de_polygones; i++)

cout << pScene_2D[i].Nombre_de_sommets();

Les tableaux dynamiques conservent un des inconvénients des tableaux statiques:

le nombre d’éléments ne peut pas être modifié après la création du tableau.

Listes chaînées (à venir)



class Classe_de_base{};typedef Classe_de_base * pClasse_de_base;class Tableau_dynamique_de_pointeurs{/* Spécification fonctionnelle de la classe

"Tableau_dynamique_de_pointeurs" */protected:

int Nombre_maximum_elements;int Nombre_elements_presents;pClasse_de_base * pTab_dynamique;



public:Tableau_dynamique_de_pointeurs(int Nb_maximum_elements);/* Permet de créer un tableau dynamique de pointeurs où les

composantes sont initialisées à NULL. Le nombred’éléments du tableau est passé en paramètre.Pré - Nil.Post - Un tableau vide de pointeurs d'objets est créé.*/

void Inserer_pointeur_objet(int i, Classe_de_base * pObjet);/* Permet d'insérer le pointeur d'un objet en position i.

Pré - 1 <= i <= Nombre_maximum_elements.Il n'existe pas de pointeur d'objet à cette position.

Post - L'élément est inséré en position i. */



Classe_de_base * Enlever_pointeur_objet(int i);/* Permet s'il existe d'enlever l'objet en position i du tableau

et de retourner son adresse. Autrement, NULL est retournée.Pré - 1 <= i <= Nombre_maximum_elements.Post - Il n'existe plus d'objet en position i du tableau.

S'il en existait un, son adresse est retournée. */int Rechercher_place_disponible();/* Retourne la position d'un élément du tableau où il n'y a pas

d'objet. S'il n'existe aucune place disponible, la valeur 0est retournée.Pré - NilPost - Retourne la position d'un espace disponible.0 autrement.*/



int Nb_elements_presents();/* Retourne le nombre d'objets présents dans le tableau.

Pré - NilPost - Retourne le nombre de pointeurs d'objets présents

dans le tableau. */};



#include "Tableau_dynamique_de_pointeurs.h"#include <iostream.h>Tableau_dynamique_de_pointeurs::Tableau_dynamique_de_pointeurs

(int Nb_maximum_elements){

Nombre_maximum_elements = Nb_maximum_elements;Nombre_elements_presents = 0;pTab_dynamique = new pClasse_de_base

[Nombre_maximum_elements];for (int i = 0; i < Nombre_maximum_elements; i++)

pTab_dynamique[i] = NULL;}



void Tableau_dynamique_de_pointeurs::Inserer_pointeur_objet(int i, Classe_de_base * pObjet)

{Nombre_elements_presents += 1;pTab_dynamique[i-1] = pObjet;

}Classe_de_base * Tableau_dynamique_de_pointeurs::

Enlever_pointeur_objet(int i){ Classe_de_base * p;

if (pTab_dynamique[i-1] != NULL)Nombre_elements_presents -= 1;

p = pTab_dynamique[i-1]; pTab_dynamique[i-1] = NULL;return p;

}



int Tableau_dynamique_de_pointeurs::Rechercher_place_disponible(){

for (int i = 0; i< Nombre_maximum_elements; i++)if(pTab_dynamique[i] == NULL) return i+1;

return 0;}

int Tableau_dynamique_de_pointeurs::Nb_elements_presents(){

return Nombre_elements_presents;}



#include <iostream.h>#include "Tableau_dynamique_de_pointeurs.h"class dossier_medical: public Classe_de_base{

// .......};



void main(){

dossier_medical A, B, C;Tableau_dynamique_de_pointeurs T(10);T.Inserer_pointeur_objet(1, &A);T.Inserer_pointeur_objet(5, &B);T.Inserer_pointeur_objet(T.Rechercher_place_disponible(), &C);cout << "Nombre de dossiers medicaux: "

<< T.Nb_elements_presents();T.Enlever_pointeur_objet(5);cout << "Nombre de dossiers medicaux: "

<< T.Nb_elements_presents();}


Listes chaînées

Liste_simple

Pile

File

Monceau

etc.

d ’"element " s

On peut créer des structures d’objetsdérivés de la classe "element ".


Classes internes ou imbriquéesPermet de définir une classe à l’intérieur de la déclaration d’une autre classe.Permet de réduire l’utilisation de la classe interne à la classe qui la contient.

Les classes internes respectent les étiquettes de protection.

class Auto{

protected:char Reference[20+1]; char Marque[20+1];int Prix_vente;class Moteur;

public:Auto(char * Ref = "", char * M = "", int Prix = 0,

char * Caract = "", float Duree = 0.0);/* Permet de créer un objet Auto.

Pré - Nil.Post - L'objet Auto est créé en tenant compte des valeurs

par défaut pour les différents arguments */

référence avancée


Classes internes

void Init_Prix_vente(int P);/* Initialise le prix de vente.

Pré - L'objet Auto est créé.Post - Le prix de vente est conservé. */

int Acces_Prix_vente();/* Fournit le prix de vente.

Pré - L'objet Auto est créé.Post - Retourne le prix de vente de l'auto. */

};


Classes internes

class Auto::Moteur{

protected:char Caracteristiques[20+1];float Duree_de_vie;

public:void Init_Duree_de_vie(float D);/* Initialise la durée de vie.

Pré - L'objet Auto est créé.Post - La durée de vie est conservée.*/

float Acces_Duree_de_vie();/* Fournit la durée de vie.

Pré - L'objet Auto est créé.Post - Retourne la durée de vie du moteur de l’auto.*/

};

On fait toujours référence à la classe par son nom complet.


Classes internes

class Auto_usagee : public Auto{

protected:char Nom_Ancien_Proprietaire[20+1];char Prenom_Ancien_Proprietaire[20+1];int Cout_achat;

public:Auto_usagee(char * Ref = "", char * M = "", int Prix = 0,

char * Caract = "", float Duree = 0.0, int Cout = 0,char * Nom = "", char * Prenom = "");

/* Permet de créer un objet Auto_usagee.Pré - Nil.Post - L'objet Auto_usagee est créé en tenant compte des valeurs

par défaut pour les différents arguments. */


Classes internes

void Init_Cout_achat(int C);/* Initialise le coût d'achat.

Pré - L'objet Auto_usagee est créé.Post - Le coût d'achat est conservé. */

int Acces_Cout_achat();/* Fournit le coût d'achat.

Pré - L'objet Auto_usagee est créé.Post - Retourne le coût d'achat de l'auto usagée. */

};


Classes internes#include <string.h>#include "Auto.h"Auto::Auto(char * Ref, char * M, int Prix, char * Caract, float Duree){

Prix_vente = Prix; strcpy(Marque, M); strcpy(Reference, Ref);Auto::Moteur::Duree_de_vie = Duree;strcpy(Auto::Moteur::Caracteristiques, Caract);

}void Auto::Moteur::Init_Duree_de_vie(float D){

Moteur::Duree_de_vie = D;}float Auto::Moteur::Acces_Duree_de_vie(){

return Moteur::Duree_de_vie;}

On fait toujours référence à laclasse par son nom complet.


Classes internes

Auto_usagee::Auto_usagee(char * Ref, char * M, int Prix,char * Caract, float Duree, int Cout,char * Nom, char * Prenom)

:Auto(Ref, M, Prix, Caract, Duree){

Cout_achat = Cout;strcpy(Nom_Ancien_Proprietaire, Nom);strcpy(Prenom_Ancien_Proprietaire, Prenom);

}


Classes internes#include <iostream.h>#include "Auto.h"void main(){

Auto A("R025", "Honda Civic", 22500, "Caracteristiques I", 8.5);Auto_usagee B("C2534", "Toyota", 18500, "Caracteristiques II",

7, 12550, "Duval", "Luc");Auto_usagee C("D123", "Capri");cout << A.Acces_Prix_vente();cout << B.Acces_Prix_vente(); cout << B.Acces_Cout_achat();cout << C.Acces_Prix_vente(); cout << C.Acces_Cout_achat();


Classes internes/* La classe Moteur n'est pas accessible à cause de l'étiquette

protected.

Même si nous avions l'étiquette public, les fonctionsInit_Duree_de_vie et Acces_Duree_de_vie ne seraient pasdisponibles à partir de A, B ou C;

par contre, nous pourrions déclarer une variable de type Moteur:

Auto::Moteur M;M.Init_Duree_de_vie(7.5);

Les fonctions Init_Duree_de_vie & Acces_Duree_de_viedevraient plutôt être utilisées par les fonctions membres de la classe Auto. */

}

Classes internes "Classes locales"

Note : Les classes imbriquées sont utilisées dans la librairie STL pour construireune classe Iterator dans chaque structure de données.


Association et agrégation d’objets

En dehors de l’héritage, il existe d’autres types de relation entre les classes.

Association

- La relation entre les classes qui est la plus générale mais aussi la plusfaible.

Ex.: Une liste chaînée où chaque objet dispose d’un lien vers l’objet suivant.

- Permet à un objet de posséder un lien vers un autre objet mais, aucun nefait partie de l’autre.

- Habituellement, une donnée membre de type pointeur vers l’objet associé.



Association

Employé

Département

Compagnie

Directeurdirige

dirige

travaille

fait partie



Agrégation

- Correspond à la définition d’un objet compositei.e. un objet créé à partir de plusieurs autres de classes distinctes.

On représente des composantes faisant partie d’un tout.

- Alternative à l’utilisation de l’héritage. Héritage et agrégation ont en com-mun le fait de créer automatiquement un objet à partir d’une autre classe.

relation composante / structure

Document Paragraphe Phrase

Le document est composé de paragraphes qui sont à leur tour composés dephrases.Relation transitive.



Carte mère Processeur Mémoire RAM

Agrégation

Ventilateur

Moniteur Boîte Souris Clavier

Ordinateur

38


Ex.:

class dossier_medical{

…..};class dossier_financier{

…..};class curriculum_vitae{

…..};

class description_entreprise{

…..};class personne{

protected:dossier_medical * S;dossier_financier * P;curriculum_vitae * T;description_entreprise * E;…..

};

agrégation

association

Note : Les objets membres se construisent selon l’ordre dans lequel ils sont déclaréset avant que les objets de la classe qui les renferme ne soient construits.

39


Exemple: class Date // Deitel et Deitel, chap. 7{

private : int jour;int mois;int annee;int verifierJour(int J); // Utilitaire pour tester le

// le nombre de jours.public : Date(int J = 1, int M = 1, int A = 1900);

void affichage() const; // format jour/mois/annéeDate(); // fourni pour confirmer

// l’ordre de destruction};

40


Exemple:….Date::Date(int jr, int ms, int an){

if (ms > 0 && ms <= 12) mois = ms;else { mois = 1;

cout << "Mois " << ms << " non valide. Ajuster au mois 1." << endl; }

annee = an;jour = verifierJour(jr);cout << " Constructeur de la classe Date ";affichage();cout << endl;

}void Date::affichage() const{ cout << jour << "/" << mois << "/" << annee; }

Ne nécessite pas d’argumentscar elle contient un pointeurimplicite this.

41

Association et agrégation d’objetsExemple:

Date::~Date(){

cout << "Destructeur de la classe Date ";affichage();cout << endl;

}int Date::verifierJour(int testJour){

static const int joursParMois[13] ={0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

if (testJour > 0 && testJour <= joursParMois[mois]) return testJour;if (mois == 2 && testJour == 29 &&

( annee % 400 == 0 || (annee % 4 == 0 && annee % 100 != 0)))return testJour;

cout << "Jour " << testJour << " non valide. Ajuster au jour 1." << endl;return 1; }

42


…..class Employe{

private : char prenom[25];char nomFamille[25];const Date dateNaissance;const Date dateEmbauche;

public : Employe(char * pnom, char * nomf, int moisn, int journ, int anneen,int moise, int joure, int anneee );

void affichage() const;~Employe(); // fourni pour confirmer l’ordre de

// destruction.};

43


…..Employe::Employe (char * pnom, char * nomf, int moisn, int journ, int anneen,

int moise, int joure, int anneee ): dateNaissance(journ, moisn, anneen), // Initialisation des membres dateEmbauche(joure, moise, anneee) // Passage des paramètres au

{ // constructeur de la classe Date.// Copie de pnom dans prenom.int longueur = strlen(pnom);longueur = ( longueur < 25 ? longueur: 24 );strncpy(prenom, pnom, longueur);prenom[ longueur ] = "\0";// Copie de nomf dans nomFamille.…..cout << "Constructeur de l’objet Employe: "

<< prenom << " " << nomFamille << endl;}

Obligatoirecar

de constructeurpar défaut

pour laclasse Date

44


void Employe::affichage() const{

cout << nomFamille << ", " << prenom << "\nEmbauché: ";dateEmbauche.affichage();cout << " Date de naissance: ";dateNaissance.affichage();cout << endl;

}

Employe::~Employe(){

cout << "Destructeur de l’objet Employe: " << nomFamille << ", " << prenom << endl;

}

Utilisation des fonctionnalitésde la classe Date.

45


….void main(){

Employe e( "Bob" , "Binet" , 24, 7, 1949, 12, 3, 1988 );cout << "\n" ;e.affichage();

cout << "\nTest du constructeur Date avec valeurs non valides: \n";Date d(35, 14, 1994); // valeurs de Date non valides.cout << endl;

}

46

Association et agrégationd’objetsAffichage:

Constructeur de la classe Date 24/7/1949Constructeur de la classe Date 12/3/1988Constructeur de l’objet Employe: Bob Binet

Binet, BobEmbauché: 12/3/1988 Date de naissance: 24/7/1949

Test du constructeur Date avec valeurs non valides:Mois 14 non valide. Ajuster au mois 1.Jour 35 non valide. Ajuster au jour 1.Constructeur de la classe Date 1/1/1994

Destructeur de la classe Date 1/1/1994Destructeur de l’objet Employe: Binet, BobDestructeur de la classe Date 12/3/1988Destructeur de la classe Date 24/7/1949

Les objets sont construitsà l’envers.

Les objets sont détruitsdans l’ordre inversede leur construction.

47

Relation d’héritage

L’héritage permet de partager les similitudes entre les classes tout en préservantleurs différences.

Les méthodes et les attributs de la super-classe sont partagés avec toutes lessous-classes.

Pompe centrifuge Pompe à diaphragme Pompe à ventouse

Pompe Échangeur de chaleur Réservoir

ÉquipementEx. : (Yves Roy)

48

Relation d’héritage : quand l’utiliser ?

Ne pas oublier que l’héritage est une relation de « est un ».

Si on a une relation de « a un », on utilise l’agrégation.

Ex. : Un triangle est un polygone.

Une voiture a des pneus; une voiture est un véhicule.

Lorsqu’une classe dérivée n’hérite de rien, c’est mauvais signe.


Classe "Objet_2D"Classe "Objet_2D"

Objet_2D

Caracteristiques_physiques Polygone_2Dagrégation


Classe "Objet_2D"Classe "Objet_2D"#include "Polygone_2D.h"#include "Caracteristiques_physiques.h"

class Objet_2D{

protected:Polygone_2D * pPolygone_2D;Caracteristiques_physiques *pCaracteristiques_physiques;int repere_x;int repere_y;


Classe "Objet_2D"Classe "Objet_2D"public:

Objet_2D(Polygone_2D * P, Caracteristiques_physiques * C,int x, int y);

/* Permet de créer un objet 2D avec sa forme géométrique,ses caractéristiques physiques, et un repère x, y.Pré - Nil.Post - Un objet 2D est créé. */

void Modifier_Polygone_2D(Polygone_2D * P);/* Permet de modifier la forme géométrique de l'objet.

Pré - L'objet 2D a été créé.Post - La forme géométrique de l'objet est donnée par P*/


Classe "Objet_2D"Classe "Objet_2D"void Modifier_Caracteristiques_physiques

(Caracteristiques_physiques * CP);/* Permet de modifier les caractéristiques physiques de l'objet.

Pré - L'objet 2D a été créé.Post - Les caractéristiques physiques de l'objet sont données

par CP. */

Polygone_2D * Acces_Polygone_2D();/* Retourne la forme géométrique de l'objet.

Pré - L'objet 2D a été créé.Post - La forme géométrique de l'objet est retournée. */


Classe "Objet_2D"Classe "Objet_2D"Caracteristiques_physiques * Acces_Caracteristiques_physiques();/* Retourne les caractéristiques physiques de l'objet.

Pré - L'objet 2D a été créé.Post - Les caractéristiques physiques de l'objet sont retournées.*/

void Modifier_repere(int x, int y);/* Permet de modifier le repère de l'objet 2D.

Pré - L'objet 2D a été créé.Post - Le repère de l'objet est maintenant x, y. */

void Donner_repere(int * x, int * y);/* Retourne en paramètre le repère de l'objet.

Pré - L'objet 2D a été créé.Post - Le repère de l'objet est retourné. */

};


Classe "Objet_2D"Classe "Objet_2D"#include "Objet_2D.h"Objet_2D::Objet_2D(Polygone_2D * P,

Caracteristiques_physiques * C, int x, int y){

pCaracteristiques_physiques = C;pPolygone_2D = P;repere_x = x;repere_y = y;

}void Objet_2D::Modifier_Polygone_2D(Polygone_2D * P){

pPolygone_2D = P;}


Classe "Objet_2D"Classe "Objet_2D"void Objet_2D::Modifier_Caracteristiques_physiques

(Caracteristiques_physiques * CP){

pCaracteristiques_physiques = CP;}Polygone_2D * Objet_2D::Acces_Polygone_2D(){

return pPolygone_2D;}Caracteristiques_physiques * Objet_2D

::Acces_Caracteristiques_physiques(){

return pCaracteristiques_physiques;}


Classe "Objet_2D"Classe "Objet_2D"

void Objet_2D::Modifier_repere(int x, int y){

repere_x = x;repere_y = y;

}

void Objet_2D::Donner_repere(int * x, int * y){

*x = repere_x;*y = repere_y;

}


Classe "Objet_2D"Classe "Objet_2D"#include <iostream.h>#include "Objet_2D.h"void main(){

int x, y;Polygone_2D * P; P = new Polygone_2D;Caracteristiques_physiques *C = new Caracteristiques_physiques;Polygone_2D * R; Caracteristiques_physiques * S;P -> Ajouter_sommet(1, 1); P -> Ajouter_sommet(1, 3);P -> Ajouter_sommet(2, 3); P -> Ajouter_sommet(2, 2);P -> Ajouter_sommet(3, 2); P -> Ajouter_sommet(3, 3);P -> Ajouter_sommet(4, 3); P -> Ajouter_sommet(4, 1);


Classe "Objet_2D"Classe "Objet_2D"C -> Init_couleur_remplissage(2); C -> Init_couleur_contour(3);Objet_2D Q(P, C, 1, 2);

Q.Donner_repere(&x, &y);cout << "Repere : " << x << " " << y;

R = Q.Acces_Polygone_2D();cout << "Nombre de sommets : " <<R ->Nombre_de_sommets();

S = Q.Acces_Caracteristiques_physiques();cout << "Couleur de contour: " <<S ->Donner_couleur_contour();

}


Classe autoréférentielleClasse autoréférentielle

#include <iostream.h>#include <string.h>

// Classe autoréférentielle : classe contenant un pointeur membre qui pointe// vers un objet du même type de classe.

class element {};

class pile{/* Spécification fonctionnelle de la classe " pile ".

Éléments : Chaque sommet de la pile renferme l'adresse d'un élémentet non pas l'élément lui-même où le type de chaque élémentest une classe dérivée de la classe de base "element".

Structure : Les éléments sont reliés entre eux permettant dedéterminer l'ordre d'arrivée des éléments dans la pile. */


Classe autoréférentielleClasse autoréférentielleprivate:class Sommet{

public: element * pDonnee; // Pointeur vers une donnée.Sommet * pSommet_suivant; // Pointeur vers le sommet suivant

// dans la structure dynamique.public:

Sommet(element * pElement);/* Post - Un nouveau sommet est créé renfermant un pointeur vers

une donnée (pElement) sans posséder de sommet suivant.

*/

element * obtenirDonnee() const;/* Post - Retourne un pointeur vers une donnée. */

};Sommet * pPremier; // Pointeur vers le premier sommet de la pile.

// Met en relief les propriétés d’une structure de données.

Classe localeDonne accès directement auxdonnées membres.

NULLelement


Classe autoréférentielleClasse autoréférentielleLa spécification de la classe pile demeure inchangée.

La spécification et l’implantation de la classe dossierainsi que le programme d’application demeurent inchangés.

Implantation de la classe locale Sommet :

pile::Sommet::Sommet(element * pElement) :pDonnee( pElement), pSommet_suivant( NULL )

{ }

element * pile::Sommet::obtenirDonnee() const{

return pDonnee;}


Classe autoréférentielleClasse autoréférentielleImplantation de la classe pile :

pile::pile() :pPremier(NULL) { }

void pile::Inserer(element * pElement){

Sommet * ptr = new Sommet( pElement);(ptr -> Sommet::pSommet_suivant) = pPremier;pPremier = ptr;

}

element * pile::Enlever(){

element * pElem = pPremier -> obtenirDonnee();Sommet * pSom = pPremier;pPremier = pPremier -> pSommet_suivant;delete pSom;return pElem;

} /* etc. */

pElement NULL

ptr

pElement pPremier

Documents

Chapitre VIII Structures dobjets. Chapitre VIII - Structures d'objets2 Structures d objets Il existe plusieurs relations entre les classes. Lhéritage