et Programmation Objet

Transcription

1 FACULTE POLYTECHNIQUE DE MONS Service d Informatique et Programmation Objet Mohammed Benjelloun 2 ème Bachelier Année académique

2 Table des matières Avant-propos Chap 1 : Les structures et fonctions membres Principes des structures Structures et fonctions membres Exercices Chap 2 : Les listes simplement chaînées Généralités Listes Simplement chaînées Exercices Chap3 : Les Classes Classes et objets Concept d encapsulation Création d'objets Affectation d objets Déclaration d une fonction membre Notions de constructeur et de destructeur Constructeurs par défaut Constructeur de copie Listes d initialisation des constructeurs Affectation d un objet par un autre de la même classe Tableau d objets Surcharge des opérateurs Exercices Chap4 : Les patrons et amis Patrons de fonctions Classe template : patron de classes Utilisation d un patron de classes M.BENJELLOUN Info II S. Informatique

3 4.4. Fonctions et classes amies Fonctions amies Méthodes amies Classes amies Exercices Chap5 : L'héritage Classes de base et classes dérivées Mode de dérivation Héritage public Redéfinition de membres dans la classe dérivée Redéfinition des fonctions membres Redéfinition des données membres Héritage et Constructeurs/destructeurs Polymorphisme Exercices Chap6 : La bibliothèque STL Introduction Les conteneurs Vector List Les itérateurs Les algorithmes Exercices Syllabus2d_2 : Transparents des séances d exercices M.BENJELLOUN Info II S. Informatique

4 Avant-propos Ces notes constituent le support des travaux pratiques et des exercices dans le cadre de l'enseignement du cours d'informatique II de la deuxième année de bachelier à la Faculté Polytechnique de Mons. Il représente aussi une partie du cours Programmation et Algorithmique dispensé aux étudiants d IG Charleroi. Lors des séances d'exercices, où la présence est obligatoire, un complément de matière sera abordé. Donc le présent document ne peut être considéré comme complet. Ce cours s appuie sur des notions préliminaires de programmation procédurale. La syntaxe du langage C++ ainsi que les notions fondamentales de programmation ont été étudiées durant le cours d Informatique I et sont supposées acquises. Durant ce cours, les notions fondamentales de la programmation orientée objet sont abordées. Nous commençons par un rappel sur les structures auxquelles nous introduisons les fonctions membres. Le chapitre 2 peut être considéré comme une brève introduction aux listes simplement chaînées dont le rôle est de remédier aux limitations des tableaux statiques ou dynamiques. Avec le chapitre sur les classes, généralisation de la notion de type défini par l'utilisateur, nous abordons véritablement les possibilités de "programmation (orientée) objets". Nous introduisons la définition d une classe, la notion de méthode, l encapsulation et le type de membre (publique, privé, protégé), ainsi que les notions très importantes de constructeur et de destructeur indispensables à ce type de programmation. Nous montrons aussi comment définir une famille de fonctions ou de classes paramétrées par un ou plusieurs types grâce à la notion de patron de fonctions et de classes. Par la suite nous proposons un principe propre à la programmation orientée objet : l'héritage qui permet de créer une nouvelle classe à partir d'une classe existante. Un autre concept des langages objet qui découle directement de l'héritage est le polymorphisme. Pour terminer, nous esquissons la bibliothèque STL (Standard Template Library : Bibliothèque standard générique.) qui est certainement l un des atouts de C++ et qui peut être considérée comme un outil très puissant. Comme la programmation par l exemple vaut mieux que tous les beaux discours, nous avons illustré et agrémenté ces notes, comme les Slides des séances d'exercices, de nombreux programmes permettant à l étudiant d assimiler les principales notions présentées. Tous les programmes sont fournis complets avec le résultat de leur exécution. Le code source de ces programmes est accessible sur le site Web de la Faculté. Nous ne pouvons qu insister sur la quasi-nécessité de les tester, et mieux encore de les comprendre et de les modifier. En ce qui concerne les exercices, nous incitons l étudiant à les programmer, car la programmation est un art qui s apprend en pratiquant. Vous l aurez compris, ces notes n ont pas la prétention d expliquer en détail tous les concepts du C++, mais se proposent en tant qu introduction à la programmation orientée objet. Ce syllabus ne peut donc être considéré comme autosuffisant pour apprendre tout le

5 langage C++. En effet, la matière est vaste et le temps attribué est court. Mais la programmation orientée objet, sera approfondie durant le cours de 3 ème année en préparation au master d Informatique et Gestion. Nous renvoyons, néanmoins le lecteur désireux d'en savoir plus à l'un des très nombreux ouvrages de référence sur le C++, notamment à: Claude Delannoy Programmer en langage C++, Eyrolles, 2004 ou l édition 2007 Très bon livre pour commencer le C++, livre très pédagogique et assez complet. Plusieurs chapitres sont dédiés aux composants de la bibliothèque standard du C++. John R. Hubbard Programmer en C++, Collection Schaum s Ediscience, Dunod Un ouvrage expliquant les concepts de base de la programmation C++ à l'aide d'exemples. On y trouve entre autre: Classes, Surcharge d'opérateurs, Composition et héritage, Modèles et itérateurs, C++ standard et les vecteurs, Classes conteneur. John R. Hubbard Structures de données en C++, Collection Schaum s Ediscience, Dunod Ce volume est complémentaire au précédent. Près de 455 exercices et problèmes résolus sont décortiqués pour une meilleure compréhension. On y trouve entre autre : Classes, Listes, Tables, Arbres, classes conteneurs standard, algorithmes génériques. 2 Sur le Web : Cours, tutoriels, livres électroniques et Docs sur C++ : Mega Cours C++ en français Je voudrais remercier ici les collègues du Service d'informatique qui ont pris soin de relire ces notes et de suggérer corrections et améliorations. Je suis bien conscient qu'il reste des erreurs et/ou des imprécisions. Merci au lecteur assidu de les signaler! Si vous notez la moindre erreur ou si vous souhaitez me proposer vos suggestions, n'hésitez pas à le faire à l adresse suivante : Mohammed.Benjelloun@fpms.ac.be

6 Chap 1 : Les structures et fonctions membres Ce chapitre est un prolongement du chapitre 8 du syllabus de la 1 ère année de bachelier sur l'utilisation des structures en C++. Certaines notions du chapitre 8 vont être rappelées ici, brièvement ; d'autres, complètement nouvelles comme les fonctions membres, seront introduites Principes des structures Une structure est un ensemble de variables (de types éventuellement différents), définissant un nouveau type sous un seul nom, adapté à une gestion spécifique et à une manipulation facile des données. Une structure se définit par un identificateur suivant le mot-clé struct, ainsi que par une liste de champs ou membres définis par un identificateur d'un type donné. Par exemple, pour gérer les coordonnées d'un point (abscisse et ordonnée) ou des étudiants, on pourra définir les types suivants : struct point { int x; int y; ; struct Etudiant { int Id; string Nom; ; Quant à x et y, on dit que ce sont des champs ou des membres de la structure point, alors que Nom et Id sont des champs de la structure Etudiant. On déclare ensuite des variables du type point (Etudiant) par des instructions telles que : struct point a, b; struct Etudiant Etud1, Etud2; Etudiant Etud[10] ; // a et b deux variables de type structure point // Etud est un tableau de 10 éléments de type structure Etudiant Celle-ci réserve l'emplacement pour des structures nommées a et b de type point, Etud1 et Etud2 de type Etudiant et finalement un tableau de 10 éléments de type Etudiant. L'accès aux membres de a, b ou de Etud1 et Etud2 se fait à l'aide de l'opérateur point (.). Par exemple, a.y désigne le membre y de la structure a et Etud1.Nom désigne le nom du Etudiant Etud1. Rq En C++ le mot clé struct n'est pas nécessaire devant la structure lors de la déclaration. En C++, nous allons pouvoir, dans une structure, associer aux données constituées par ses membres des méthodes qu'on nommera "fonctions membres".

7 Chap 1 : Les structures et fonctions membres Structures et fonctions membres Supposons qu en plus de la déclaration des données Id et Nom, nous souhaitions associer à la structure Etudiant deux fonctions : void Saisie() : pour saisir l identifiant et le nom d un seul Etudiant ; void Affiche() : pour afficher les information d un seul Etudiant. Voici comment nous pourrions éventuellement déclarer la structure Etudiant : struct Etudiant { int Id; string Nom; void Saisie() ; void Affiche() ; ; Dans la déclaration d'une structure, il est permis (mais généralement peu conseillé) d'introduire les données et les fonctions dans un ordre quelconque (nous avons systématiquement placé les données avant les fonctions). Le programme suivant reprend la déclaration du type Etudiant, la définition de ses fonctions membres et un exemple d utilisation dans la fonction main : #include <iostream> #include <string> using namespace std ; struct Etudiant { int Id; string Nom; void Saisie() ; // Saisir un élément void Affiche() ; ; // Définition des fonctions membres du type Etudiant ---- void Etudiant::Saisie() { cout << "donnez un identifiant : "; cin >> Id; cout << "donnez un nom : " ; cin >> Nom; void Etudiant::Affiche() { cout << " Identifiant ="<< Id << endl; cout << " Son nom : "<< Nom << endl; void main(){ Etudiant Etud3, Etud[3]; cout << "----> Etud >"<< endl; for(int i=0 ; i<3 ; i++){ Etud[i].Saisie(); Etud[i].Affiche(); cout << "----> Etud3 ---->"<< endl; Etud3.Saisie(); // accès à la fonction Saisie du Etudiant Etud1 Etud3.Affiche(); Programme 1.1.

8 Chap 1 : Les structures et fonctions membres 5 SOLUTION ----> Etud > donnez un identifiant : 0 donnez un nom : Etud0 Identifiant =0 Son nom : Etud0 donnez un identifiant : 1 donnez un nom : Etud1 Identifiant =1 Son nom : Etud1 donnez un identifiant : 2 donnez un nom : Etud222 Identifiant =2 Son nom : Etud > Etud3 ----> donnez un identifiant : 33 donnez un nom : ETUD33 Identifiant =33 Son nom : ETUD33 Dans l'en-tête, le nom de la fonction Etudiant::Saisie(), signifie que la fonction Saisie() est celle définie dans la structure Etudiant. En l'absence de ce "préfixe" (Etudiant::), nous définirions effectivement une fonction nommée Saisie(), mais celle-ci ne serait plus associée à Etudiant; il s'agirait d'une fonction "ordinaire" et non plus de la fonction membre de la structure Etudiant. Dans les fonctions Saisie() et Affiche(), il faut remarquer l utilisation de Id et du Nom qui ne sont ni des arguments de fonctions ni des variables locales. En fait, ils désignent les membres Id et Nom de la structure Etudiant. L association est réalisée par Etudiant:: de Rq l en-tête des fonctions. Voici un autre exemple utilisant cette fois ci la structure point. #include <iostream> using namespace std ; struct point { int x ; int y ; // Déclaration des fonctions membres (méthodes) void initialise(int, int) ; void affiche() ; ; void Affiche2(point A, point B){ // fonction non membre cout << "\n...je suis dans Affiche2..."<<"\n" ; A.affiche(); B.affiche(); // --- Définition des fonctions membres du type point --- void point::initialise (int abs, int ord) { x = abs ; y = ord ; void point::affiche () { cout << "Je suis en " << x << " " << y << "\n" ;

9 Chap 1 : Les structures et fonctions membres 6 void main() { point a, b, TabPoint[3]; a.initialise (3, 7) ; a.affiche () ; b.x = 10; b.y = 20 ; b.affiche (); for(int i=0 ; i<3 ; i++){ TabPoint[i].initialise(i, i+4); TabPoint[i].affiche(); SOLUTION Affiche2(a, b); Programme 1.2. Je suis en 3 7 Je suis en Je suis en 0 4 Je suis en 1 5 Je suis en Je suis dans Affiche2... Je suis en 3 7 Je suis en Rqs Dans le cas des structures, un appel tel que a.initialise (3,7) ; pourrait être remplacé par: a.x = 3 ; a.y = 7 ; Dans un programme, nous pouvons évidemment mélanger fonctions membres et fonctions non membres. Exercices 1.1. Ecrire un programme qui gère un ensemble de Personnes (Nmax=10). Chaque Personne aura une structure avec un identifiant Id de type entier et un nom de type string dont la déclaration est: struct Personne { int Id; string nom; ; Ce programme doit gérer en boucle le menu suivant : 1 : Saisie et Affichage 2 : Ajouter au (début, milieu ou fin) et Affichage 3 : Supprimer le début et Affichage 4 : Tri selon NOM et Affichage 5 : Tri selon Id et Affichage 6 : Quitter Le menu sera affiché via une fonction, les choix seront traités via l instruction case. Votre programme utilisera une série de fonctions permettant de séparer les tâches Transformez l exercice précédent en utilisant dans la structure deux fonctions membres saisie() et affichage(). Apporter les modifications nécessaires à la structure, aux fonctions et au programme.

10 Chap 2 : Les listes simplement chaînées 2.1. Généralités Jusqu'à présent, nous n'avons travaillé qu'avec des structures de données statiques, dont l'espace mémoire occupé pouvait être défini avant l'exécution. Dans le cas d une déclaration d un tableau de structure par la syntaxe: struct Etudiant Tab[100] ; Cette déclaration permet de réserver automatiquement une zone mémoire d une longueur de 100 éléments de type Etudiant. Les cellules du tableau sont alors accessibles par Tab[0] à Tab[99]. Cependant, le problème réside dans le fait que la déclaration du tableau avec une dimension constante fige le nombre d éléments de ce tableau. Autrement dit, même si un programme n a besoin que de 20 éléments, on réservera malgré tout 100 cellules de type Etudiant. Comme nous l avons déjà vu en 1 ère Bachelier, nous pouvons remédier à cela en utilisant les pointeurs. Les instructions deviennent dans ce cas-ci : struct Etudiant *Tab; Pour pouvoir stocker en mémoire une valeur de type Etudiant, il faut donc explicitement demander une adresse disponible en utilisant le mot réservé new et la libérer avec delete. L allocation dynamique de la mémoire correspondant au nombre de cellules est maintenant au gré de l utilisateur. On peut, par exemple, lui demander d introduire un nombre N, puis nous réservons l espace mémoire strictement nécessaire. cout<< " Dimension du Tableau N : " ; cin >> N; // Allocation mémoire : new[] Tab = new Etudiant[N]; // Restituer la mémoire : delete[] delete[] Tab; Supposons qu à un moment donné dans le programme même, nous n ayons plus besoin que de (N-5) éléments. La logique, comme nous désirons optimiser la gestion de la mémoire, est de libérer la place de mémoire pour 5 cellules. Mais cela ne peut se faire ni automatiquement ni directement. Donc cela reste bien sûr limitatif. En effet, cela ne permet pas d'exploiter les structures tels que les listes chaînées, les piles, les arbres, structures fondamentales pour de nombreux algorithmes Listes Simplement chaînées Une liste chaînée est une séquence d'objets dynamiques dont chacun contient une indication explicite vers l'élément suivant. Une liste est faite de cellules. Chaque cellule contient un élément de la liste et l'adresse de l'élément suivant (structure de même type).

11 Chap 2 : Les listes simplement chaînées 8 Considérons donc la définition d'une liste simplement chaînée de structures contenant des strings. "Etud1" "Etud2" "Etud3" "Etud4" NULL Chaque cellule de la liste chaînée peut être définie comme une structure: struct Etudiant { string Nom; struct Etudiant *next; ; // Etudiant suivant Chaque cellule comporte donc une zone mémoire pour stocker son contenu (ici string Nom), ainsi qu'une zone mémoire pour stocker un pointeur vers la cellule suivante (c'est-à-dire l'adresse de la cellule suivante). Pour pouvoir travailler avec une liste simplement chaînée, il faut connaître l'adresse de sa première cellule. Nous définirons donc un pointeur: struct Etudiant *debut; Si les tableaux permettent un accès direct aux éléments, les listes chaînées en sont dépourvues. La définition et la nature même de la liste chaînée font apparaître que l on ne peut parcourir intégralement la liste qu en partant du premier élément et en visitant les éléments l un après l autre. En contrepartie nous gagnons en souplesse lorsqu il s agit de modifier la liste. Des opérations telles que : ajout, suppression d un élément à une position quelconque dans la liste, la suppression avec libération de mémoire d un nombre quelconque d éléments consécutifs, Voici un programme simple mais complet, dans lequel nous traitons un certain nombre d opérations sur la liste. Par exemple : l'insertion d'une nouvelle cellule en début de liste, le parcours de la liste pour l affichage, l effacement d'une cellule, la libération de la mémoire. #include <iostream> #include <string> using namespace std ; typedef struct Etudiant{ string Nom; struct Etudiant *next; // le lien : pointeur sur la cellule suivante liste; //insérer un nouvel élément en tête de liste et retourner un pointeur sur la liste. liste *insere_en_tete(string x, liste *lis ) { liste *c; c = new liste ; // créer une cellule if (c!=null){ c Nom=x; // assignation de x c next=lis; // assignation de suivant: chaîner avec la première cellule de la liste lis=c; return (lis); // chaînage: faire pointer la tête de liste vers la nouvelle cellule.

12 Chap 2 : Les listes simplement chaînées 9 void parcours (liste *lis) { liste *p; p = lis; cout << "Affichage : "<< endl; while ( p!= NULL) { cout << p Nom << endl; p = p next; cout <<endl<<endl; void liberation (liste *lis) { liste *p; p = lis; while ( p!= NULL) { lis=lis next; delete p; p = lis; void main() { int i, n; string Name; liste *debut; debut=null; // si p=null, donc fin de liste // liste vide cout << "nombre d'elements N: " ; cin >> n; // cout << "\n Creer une liste avec insertion en tete de liste + affichage \n"; for(i=1; i<=n; i++){ cout << "\n Nom "<< i << " : "; cin >> Name; debut=insere_en_tete(name, debut); parcours(debut); // Affichage // cout << "Inserer une nouvelle cellule apres la cellule debut " << endl; liste *p; p = new liste; p Nom = "Nouveau"; p next = debut next; debut next = p; parcours (debut); // cout << "Supprimer la 1ere cellule " << endl; liste *q; q=debut; debut=debut next; delete q; // mémoire dynamique n'est plus utilisée doit être libérée. parcours (debut); // // Libération cout << " Liberation de la memoire "; liberation (debut); Programme 2.1.

13 Chap 2 : Les listes simplement chaînées 10 nombre d'elements N: 3 Creer une liste avec insertion en tete de liste + affichage Nom 1 : premier Nom 2 : second Nom 3 : nom3 Affichage : nom3 second premier S O L U T I N Inserer une nouvelle cellule apres la cellule debut Affichage : nom3 Nouveau second premier Supprimer la 1ere cellule Affichage : Nouveau second premier Liberation de la memoire Exercices 2.1. Transformer l exercice 1.2. en remplaçant le tableau statique de structures Personne par une liste simplement chaînée.

14 Chap 2 : Les listes simplement chaînées 2.2. Parcours Vita 11 Ecrire un programme permettant de manipuler plusieurs listes dont le nombre est NL< Nmax=15. Il s agit d un Parcours Vita avec NL activités et un nombre de participants NP<Nmax. Les informations caractérisant chaque participant dans la liste sont les suivantes: Nom : chaîne de caractères Code : un caractère (A, B, ) Créer la (les) structure(s) nécessaire(s) à ce problème. Les fonctions Saisie(..) et Affichage(..) pour chaque élément (participant) sont déclarées dans la structure participant. Ce programme doit gérer en boucle le menu suivant : 1- SaisieL Liste1 et Affichage 2- Liste1 TO Liste2 et Affichage 3- Parcours et Affichage 4- Fin 1- Saisie Liste1 et Affichage: Est constitué au moins de deux fonctions : SaisieL (.) ; Dans cette fonction on demandera et on testera le nombre de participants (NP) à saisir et on effectuera la saisie des participants dans une liste par insertion en tête. Par exemple si NP=4 et l utilisateur introduit au clavier : (NomD D) puis (NomC C) puis (NB B) et enfin (NA A) La liste est : Affichage(.) ; (NA A) --- (NB B) --- (NomC C) --- (NomD D) 2- Liste1 Liste2 et Affichage: Ici, comme si les participants sautent, un par un, de la poutre1 (Liste1) à la poutre2 (Liste2). On applique (FIFO), c'est-àdire, on retire d abord le D de Liste1, on insère D dans Liste2 et on affiche liste1 et liste2. Liste1 : (NA A) --- (NB B) --- (NomC C) Liste2 : (NomD D) Puis on transfert (NomC C) de Liste1 vers Liste2. Ce dernier sera inséré dans Liste2 après (NomD D). Liste1 : (NA A) --- (NB B) Liste2 : (NomD D) --- (NomC C) Tant que liste1 n est pas vide, on continue. A la fin on aura l affichage suivant : Liste1 : Vide Liste2 : (NomD D) --- (NomC C) --- (NB B) ----(NA A) Attention : Ici on affiche l état des deux listes chaque fois qu un participant passe de la liste1 à la liste2. Il faut soigner tous les affichages afin de bien suivre et comprendre les différentes séquences. 3- Parcours et Affichage: Ici on demandera à l utilisateur le nombre NL et on y fera traverser les NP participants comme le montre la figure générale (début). On affiche toutes les listes chaque fois que toute l équipe passe d une liste à l autre. Si par exemple NL=3 on affichera: Liste1 : (NA A) --- (NB B) --- (NomC C) --- (NomD D) Liste2 : Vide Liste3 : Vide Liste1 : Vide Liste2 : (NomD D) --- (NomC C) --- (NB B) ----(NA A) Liste3 : Vide Liste1 : Vide Liste2 : Vide Liste3 : (NA A) --- (NB B) --- (NomC C) --- (NomD D) RQs : Utilisez les règles de bonnes pratiques étudiées durant les travaux pratiques telles que l indentation syntaxique, la programmation modulaire, libérer la mémoire d un élément supprimé!!

15 Chap3 : Les Classes Le but de ce chapitre est d introduire les concepts de base des objets. Ainsi, les termes de "programmation (orientée) objets", de classe, d'objet, de méthode, d encapsulation et type de membre (publique, privé) vont être définis. Ce chapitre n a pas la prétention d expliquer en détail ce type de conception, mais se propose d en introduire les idées maîtresses en préambule à l étude du langage C++. Afin d illustrer par la programmation ces concepts, ce chapitre est agrémenté de nombreux programmes permettant à l étudiant d assimiler les principales notions et de comprendre quelques subtilités de cette matière. Pour plus de précisions, le lecteur pourra se reporter aux références. Des notions comme l'héritage, le polymorphisme, seront abordées dans d autres chapitres de ce syllabus Classes et objets Une classe définit un regroupement de données et de fonctions ou méthodes. D'un point de vue syntaxique, une classe ressemble beaucoup à la définition d une structure, il suffit de remplacer le mot clé struct par le mot réservé class; préciser quels sont les membres publics (fonctions ou données) et les membres privés en utilisant les mots clés public et private. struct Etudiant { int Id; string Nom; void Saisie(); void Affiche(); ; Class Etudiant { private : // Cachées aux fonctions externes int Id; string Nom; // Accessibles depuis l'extérieur de la classe void Saisie(); void Affiche(); ; La déclaration d une classe commence par le mot-clé class suivi du nom de la classe et se termine par le point-virgule obligatoire. Le nom de la classe dans cet exemple est Etudiant. On appelle objet, une donnée d'un type class, c est une instanciation d une classe. Class Etudiant Etud1 ; // Etudiant est une classe, Etud1 est une instance d un objet. fonction membre ou méthode, un membre d'une classe qui est une fonction (Saisie), donnée membre, un membre qui est une variable (Id et Nom). Le C++ introduit des concepts de programmation orientée objet. Un des concepts majeurs est l'encapsulation des données.

16 Chap3 : Les Classes Concept d encapsulation Dans la classe Etudiant, toutes les fonctions membres sont désignées comme public et toutes les données membres comme private; les premières étant accessibles depuis l extérieur de la classe, les secondes l étant seulement depuis la classe. L'association de membres et fonctions au sein d'une classe, avec la possibilité de rendre privées certains d'entre eux, s'appelle l'encapsulation des données, un des concepts majeurs de la programmation orientée objet. Intérêt de la démarche: puisqu'elles ont été déclarées privées, les données membres Id et Nom ne peuvent être modifiées autrement que par un appel de la fonction Saisie(). En effet, l'encapsulation est un mécanisme consistant à rassembler les données et les méthodes au sein d'une classe en cachant l'implémentation de l'objet: cacher l'information contenue dans un objet et ne proposer que des méthodes ou des fonctions de manipulation de cet objet. Ainsi les propriétés contenues dans l'objet seront assurées/validées par les méthodes de l'objet et ne seront plus de la responsabilité de l'utilisateur extérieur. Les fonctions membres doivent pouvoir servir d'interface pour manipuler les données membres. L'utilisateur extérieur ne pourra pas modifier directement l'information et risquer de mettre en péril les propriétés comportementales de l'objet. L'encapsulation permet donc de garantir l'intégrité des données contenues dans l'objet. On place l'étiquette public devant les fonctions membres dédiées à la manipulation des données membres. En effet, si l'utilisateur de la classe ne peut pas modifier les données membres directement, il est obligé d'utiliser l'interface (les fonctions membres) pour les modifier, ce qui peut permettre au créateur de la classe d'effectuer des contrôles... Le C++ implémente l'encapsulation en permettant de déclarer les membres d'une classe avec le mot réservé public, private ou protected. Ainsi, lorsqu'un membre est déclaré : public, il sera accessible depuis n'importe quelle classe ou fonction. private, il sera uniquement accessible d'une part, depuis les fonctions qui sont membres de la classe et, d'autre part, depuis les fonctions autorisées explicitement par la classe (par l'intermédiaire du mot réservé friend (voir plus loin) ). protected, il aura les mêmes restrictions que s'il était déclaré private, mais il sera en revanche accessible par les classes héritières (voir plus loin). Dans la classe Etudiant, les membres nommés Id et Nom sont privés, tandis que les fonctions membres nommées Saisie() et Affiche() sont publiques. Les expressions public: et private: peuvent apparaître un nombre quelconque de fois dans une classe. Les membres déclarés après private: (resp. public:) sont privés (resp. publics) jusqu'à la fin de la classe, ou jusqu'à la rencontre d'une expression public: (resp. private:).

17 Chap3 : Les Classes 14 class XY { private : private :... ; Dans l exemple suivant, seule la fonction ft() pourra être appelée à partir de n importe quelle fonction du programme. Par contre il n est possible d accéder aux champs x et y que par l intermédiaire de la fonction membre public ft(). Ainsi l accès aux différents champs de la classe est contrôlé. class point { private : int x, y; void gt( ); // fonction membre privée void ft( ) ; // fonction membre public // champs membres privés de la classe ; Le C++ n'impose pas l'encapsulation des membres dans leurs classes. On pourrait donc déclarer tous les membres publics, mais en perdant une partie des bénéfices apportés par la programmation orientée objet. Il est de bon usage de déclarer toutes les données privées, ou au moins protégées, et de rendre publiques les méthodes agissant sur ces données. Ceci permet de cacher les détails de l'implémentation de la classe. Si l'on rend publics tous les membres d'une classe, on obtient l'équivalent d'une structure. Ainsi, ces deux déclarations définissent le même type point : struct point { int x, y; void gt( ); void ft( ); ; class point { int x, y; void gt( ); void ft( ); ; Dans une classe, tout ce qui n est pas déclaré public est privé par défaut. Ainsi, ces deux déclarations sont équivalentes : class point { private : int x, y; void gt( ); void ft( ); ; class point { int x, y; void gt( ); void ft( ); ;

18 Chap3 : Les Classes Création d'objets En C++, il existe deux façons de créer des objets, c'est-à-dire d'instancier une classe : de façon statique de façon dynamique La création statique d'objets consiste à créer un objet en lui affectant un nom, de la même façon qu'avec une variable : Nom_de_la_classe Nom_de_l_objet; Etudiant Etud1 ; // Etudiant est une classe, Etud1 est une instance de la classe Etudiant. Ainsi, l'objet est accessible grâce à son nom... La création dynamique d'objet est une création d'objet par le programme lui-même en fonction de ses «besoins» en objets. La gestion dynamique des objets se fait de la même manière que la gestion dynamique de la mémoire pour des variables simple (int, float, ) ou structures. C est la manipulation, comme nous l avons vu en 1 ère année Bachelier, des pointeurs en utilisant les opérateurs spécifiques : new, delete, new[] et delete[]. L opérateur new permet d'allouer de la mémoire, alors que l opérateur delete la restitue. La syntaxe de new est très simple, il suffit de faire suivre le mot clé new du type de la variable à allouer, et l'opérateur renvoie directement un pointeur sur cette variable avec le bon type. Par exemple, l'allocation d'un objet Etudiant se fait comme suit : Etudiant *Etud; Etud = new Etudiant; // pointeur vers la classe Etudiant // création de l'objet «dynamique» grâce au mot clé new L accès aux "membre public" se fait de la manière suivante : Etud Saisie(); ou (*Etud).Saisie(); Etud Affiche(); Etud Nom ; La syntaxe de delete est plus simple, puisqu'il suffit de faire suivre le mot clé delete du pointeur sur la zone mémoire à libérer : delete Etud; Les opérateurs new[] et delete[] sont utilisés pour allouer et restituer la mémoire pour les types tableaux. L'emploi de l'opérateur new[] nécessite de donner la taille du tableau à allouer. Ainsi, on pourra créer un tableau de 500 objets de la manière suivante : Etudiant *Tableau=new Etudiant[500]; et détruire ce tableau de la manière suivante : delete[] Tableau; Tout objet créé dynamiquement, c'est-à-dire avec le mot-clé new devra impérativement être détruit à la fin de son utilisation grâce au mot clé delete. Dans le cas contraire, une partie de la mémoire (celle utilisée par les objets créés dynamiquement) ne sera pas libérée à la fin de l'exécution du programme...

19 Chap3 : Les Classes Affectation d objets On a déjà vu que l on peut affecter à une structure la valeur d'une autre structure de même type. Ainsi, avec les déclarations suivantes : struct point { int x, y; ; struct point A, B; Nous pouvons écrire sans problème : A = B ; Cette instruction recopie l'ensemble des valeurs des champs de B dans ceux de A. Elle joue le même rôle que : A.x = B.x ; A.y = B.y ; En C++, cette possibilité d affectation globale s'étend aux objets de même type. Elle correspond à une recopie des valeurs des membres données, que ceux-ci soient publics ou non. Ainsi, avec ces déclarations (notez qu'ici nous avons prévu, artificiellement, x privé et y public) : class point { int x ; int y ; ; point A, B ; L instruction : B = A ; provoquera la recopie des valeurs des membres x et y de A dans les membres correspondants de B. Contrairement à ce qui a été dit pour les structures, il n'est plus possible ici de remplacer cette instruction par : B.x = A.x ; B.y = A.y ; En effet, si la deuxième affectation est légale, puisque ici y est public, la première ne l'est pas, car x est privé. Notez bien que l'affectation B = A est toujours légale, quel que soit le statut (public ou privé) des membres données. On peut considérer qu'elle ne viole pas le principe d'encapsulation, dans la mesure où les données privées de B (c'est-à-dire les copies de celles de A) restent toujours inaccessibles de manière directe Déclaration d une fonction membre En ce qui concerne la définition des fonctions membres d'une classe, elle se fait de la même manière que celle des fonctions membres d'une structure (qu'il s'agisse de fonctions publiques ou privées). Il existe deux façons de définir ces fonctions membres, en définissant : le prototype et le corps de la fonction à l'intérieur de la classe en une opération ; le prototype de la fonction à l'intérieur de la classe et le corps de la fonction à l'extérieur.

20 Chap3 : Les Classes 17 La seconde solution est généralement celle la plus utilisée. Ainsi, puisque l'on définit la fonction membre à l'extérieur de sa classe, il est nécessaire de préciser à quelle classe cette dernière fait partie. On utilise pour cela l'opérateur de résolution de portée, noté ::. Il suffit ainsi de faire précéder le nom de la fonction par ::, suivi du nom de la classe pour lever toute ambiguïté (deux classes peuvent avoir des fonctions membres différentes portant le même nom...). Le programme 3.1 montre ce que devient le programme 1.1 lorsque l'on remplace la structure Etudiant par la classe Etudiant. Ce programme permet aussi d illustrer un exemple de définitions de fonctions à l intérieur et à l extérieur de la classe. La fonction Affiche() est définie à l intérieur de la classe Etudiant, tandis que la déclaration de la fonction Saisie() est à l intérieur et sa définition est à l extérieur de la classe. #include <iostream> using namespace std ; class Etudiant { int Id; string Nom; public: void Saisie() ; ; void Affiche(){ cout << "identifiant ="<< Id << endl; cout << "Son nom : "<< Nom << endl; // déclaration des membres privés // Définition de la fonction membre à l extérieur de la classe void Etudiant::Saisie() { cout << "donnez un identifiant"<< endl; cin >> Id; cout << "donnez un nom"<< endl; cin >> Nom; // Définir une fonction membre dans la classe void main(){ Etudiant Etud1, Etud2; Etud1.Saisie(); Etud1.Affiche(); // 2 objets de la classe Etudiant Etud2.Saisie(); Etud2.Affiche(); Programme 3.1. Dans le programme 2.1, Etud1 et Etud2 sont déclarés comme objets de la classe Etudiant. C est pourquoi ils possèdent leurs propres données membres Id et Nom, et la capacité d appeler les deux fonctions membres de la classe : Saisie() et Affiche(). Il faut noter qu une fonction comme Saisie()est appelée en préfixant son nom du nom de son propriétaire : Etud1.Saisie(). Une fonction membre peut être définie dans la classe (Affiche( ) ou à l extérieur (Saisie() ). Dans la plupart des cas, il est préférable de définir ces fonctions hors de la déclaration de la classe à l aide de l opérateur de résolution de portée (Etudiant::Saisie()). Ceci permet