ps-cpp

Master Math-Info - M1 Programmation scientique
Chapitre 1 Programmation objet en C++

Pr vost Guillaume - UFRST Le Havre e dapr` s le support de cours de Bertelle Cyrille e
0-0
Programmation objet en C++
Plan G n ral e e
1 Pr sentation du C++ e 2 Notion de r f rence ee 3 Fonctions : arguments et surcharge 4 Allocation dynamique 5 Constructeur dune classe vecteur 6 Constructeur dune classe matrice 7 H ritage e 8 G n ricit et template e e e
1- G. Pr vost @ Universit du Havre e e
1. Pr sentation de C++ e
1 Introduction 2 Incompatibilit s C et C++ e 3 Quelques sp cicit s e e 4 C++ langage orient objet e
1.1 Introduction
1982 par Bjarne Stroustrup (AT&T laboratory) ;

Objectif : greffer sur C les fonctionnalit s des langages e objets.
Introduction
Quattend-on dun programme ? ` Exactitude : aptitude dun programme a fournir un r sultat e donn dans des conditions sp ci es. e e e

La robustesse : le programme doit bien r agir lorsquon e s loigne des conditions normales dutilisation. e Lextensibilit : le programme doit pouvoir etre modi e e pour satisfaire aux evolutions des sp cications. e
La r utilisabilit : possibilit dutiliser des parties dun e e e programme pour traiter dautres probl` mes. e La portabilit : Un programme d velopp pour un e e e processeur et un syst` me dexploitation doit pouvoir etre e utilis sur un autre processeur et/ou un autre syst` me e e dexploitation. Lefcacit : Le code doit etre sufsamment rapide. e
Pr sentation de C++ e
Les solutions propos es : e La programmation structur e e Algorithmes + Structures de donn es = Programmes e dapr` s N. Wirth (Pascal). e

La programmation structur e + les types abstraits de e donn es. e La programmation orient e objet (POO) e
Pr sentation de C++ e
Quest-ce quun objet ? cest une association de : Donn es stock es dans des attributs ; e e Fonctions appel es m thodes qui agissent sur ces donn es. e e e
Les objets (en th orie) respectent le principe dencapsulation : e Attributs non directement accessibles ... acc` s gr ce a des e a ` m thodes pour consultation ou modication. e

` Lappel dune m thode correspond a un envoi de message e ` a lobjet. Ces m thodes jouent un r le dinterface. e o
Pr sentation du C++ e
Quest-ce quune classe ? G n ralisation de la notion de type. e e Description dun ensemble dobjets qui poss` dent une e structure de donn es identique et qui disposent des e m mes m thodes. e e Un objet est une instance de sa classe. ` Les donn es sont propres a chaque objet (en g n ral). e e e ` Une classe peut etre d nie a laide dune autre classe. e Elle h rite des propri t s et des aptitudes de la e ee premi` re. e
1.2 Incompatibilit s C et C++ e

D nition de fonctions ; e

Utilisation de const ; Convertions avec le pointeur g n rique void *. e e Pour le reste, sauf pr cision contraire, le C++ contient le C. e
D nition de fonctions e
En C, vous pouvez utiliser une fonction qui na pas fait lobjet dune d nition ou dun prototypage. La fonction e retourne alors un int. En C++, toute fonction doit etre d nie avec la pr cision e e du type de ses arguments et de sa valeur de retour.
Fonction sans argument :

En C++ : float sansarg(); En C : float sansarg(void); Une fonction qui ne retourne rien en C++ : void sansretour(int x);
Utilisation de const
Port e : e En C et C++, const d signe un identicateur dont la e valeur ne peut pas changer. const appliqu a une variable locale, la port e est e` e limit e au bloc dans lequel sest effectu e la e e d claration. e const appliqu a une variable globale, C++ limite la e` port e au chier source. e
Expression constante (expression dont la valeur peut etre calcul e a la compilation) e `

En C++, le compilateur sait evaluer :

const int MAX = 100; double tab1[2*MAX+1], tab2[2*MAX+1][MAX];
En C, non ! ... en g n ral. On doit utiliser #define : e e

#define MAX 100 double tab1[2*MAX+1], tab2[2*MAX+1][MAX];
Le type void * : pointeur g n rique e e

En C, void * est compatible avec tout pointeur, dans les deux sens de convertion.
void* gen; int* adi; gen = adi; adi = gen;
En C++, seule la convertion dun pointeur quelconque vers void * est accept e sans op rateur de cast : e e
gen = adi; \\accepte e adi = gen; \\refuse e adi = (int*) gen; \\accepte e
1.3 Quelques sp cicit s - commentaires e e

La notation du C : commentaires entre /* et */ est toujours valide ;

A celle-ci sajoute, les commentaires de n de ligne qui d marrent par // et vont jusqu` la n de ligne. e a
void main() { int i=0; // i est une variable enti`re e ... }
1.3 Quelques sp cicit s - d claration e e e

En C, obligation de regrouper toutes les d clarations au e d but du programme. e En C++, ce nest plus obligatoire. Elles peuvent apparatre nimporte o` , avant d tre utilis e. u e e
void main() { int i; i=3; ... int q=3*i; ... for (int j=0; j<q; j++) ... }
1.3 Qques sp cicit s - entr es/sorties e e e

Gestion simpli e des fonctions dentr es/sortie gr ce a 2 e e a ` nouvelles fonctions : En saisie, cin Exemple :

cin >> x;
En afchage, cout Exemple :

cout << "coucou"; cout << "voici le nombre : " << x << endl;
Remarques : Les anciennes fonctions sont toujours utilisables ; Lop rateur de r f rence & nest pas n cessaire pour la e ee e saisie ; Un processus de v rication automatique de type permet e de saffranchir des multiples formats de type tr` s utilis s e e en C.
1.4 C++ Langage Orient Objet e

Nouvelles possibilit es non particuli` res a un LOO e e ` Nouvelle forme de commentaire ;

Libert dans lemplacement des d clarations ; e e Notion de r f rence ; ee Surcharge de fonction ; Allocation dynamique par les op rateurs new et delete ; e Fonction inline.
Nouvelles possibilit es offertes par lorientation objet : e Notion de classe ; M canisme dinstanciation (cr ation dobjet) ; e e Constructeur/ Destructeur ; Fonction amies ; Surcharge dop rateurs ; e Red finition de conversions ; e H ritage - h ritage multiple ; e e Notion de ot.
2. Notion de r f rence ee
1 D nition e 2 D claration et initialisation e 3 Transmission par r f rence ee
2.1 D nition e
R f rence : nouveau type qui permet de manipuler un ee alias sur une autre variable existante.

Toute action sur un alias est effectu e sur lentit a laquelle e e` lalias fait r f rence. ee Notion de r f rence proche de la notion de pointeur ee Une variable de type pointeur pointe sur une autre entit ; e ` Une variable de type r f rence fait r f rence a une ee ee autre entit . e R f rence = pointeur cach . ee e
2.2 D claration et manipulation e

D claration e Une r f rence seffectue toujours sur une entit dun type ee e donn . e

Une r f rence s crit : type & ; ee e Exemple : int & r f rence sur un int ; ee int* & r f rence sur un int*. ee
Cr ation, manipulation dune r f rence e ee

Une variable de type r f rence doit toujours etre initialis e ee e lors de sa d claration ; e Exemple :
//Declaration incorrecte int & nombre; //Declaration correcte int number; int & nombre = number;
Exemple d velopp : prog1.cc e e La trace dex cution : traceprog1 e

Adresse dune information associ e a une r f rence ; e ` ee

Exemple : Exemple d velopp : prog2.cc e e La trace dex cution : traceprog2 e

R f rences constantes ee Lorsque la r f rence est constante il nest pas possible de ee modier linformation par linterm diaire de la r f rence. e ee int nombre;
const int & number = nombre; //Interdit number++; //Autorise nombre++;
Une r f rence sur une constante doit etre constante. ee //Interdit

const int x int & ref_x //Autorise const int x const int & = 0; = x;
= 0; ref_x = x;
2.3 Transmission par r f rence ee

En C Les arguments et le retour dune fonction sont transmis par valeur.
Pour modifier un param` tre appelant on transmet la e valeur de son adresse. On manipule alors le pointeur au niveau de la fonction.
Exemple : prog3.cc La trace dex cution : traceprog3 e
En C++

Transmission par valeur ; Transmission par r f rence. Les modifications portent sur ee le param` tre dappel et non sur une copie. e Exemple : prog4.cc La trace dex cution : traceprog4 e

En C il est parfois n cessaire de transmettre un pointeur de e pointeur (structure dynamique de type arbre par ex.) ; En C++ on utilise une r f rence sur le pointeur. ee Exemple prog5.cc

R f rences constantes ee Passage par r f rence constante, cas de la fonction ee affiche() et print();

Le code : prog6.cc print() et affiche() fournissent le m me r sultat e e Dans le cas de print() on passe la valeur de S_tableau t ce qui n cessite une recopie de e nb_elt et de tab. Dans le cas daffiche() on transmet une r f rence ee constante de t. t ne peut pas etre modifi e. e
3. Fonctions : arguments et surcharge

1 Les modes de transmission 2 Les arguments par d faut dune fonction e 3 Fonctions renvoyant une r f rence ee 4 Surcharge de fonction
3.1 Les modes de transmission

Transmission par valeur ;

Transmission par r f rence. ee
3.2 Les arguments par d faut dune fonction e

Il est possible dattribuer des valeurs par d faut aux e arguments dune fonction ; On peut appeler une fonction sans correspondance exacte avec le nombre darguments ; Ce sont les valeurs par d faut qui sont transmises. e

Mise en uvre Les valeurs par d faut sont fix es dans la d claration e e e (prototype) de la fonction et non dans sa d nition (sauf si e elles sont conjointes) ;

Lorsquune d claration pr voit des valeurs par d faut, les e e e arguments concern s sont obligatoirement les derniers de e la liste.
Pour sp cier des arguments par d faut, il faut : e e le type de largument formel ; le nom de largument formel (optionnel) ; = Une expression ne contenant pas darguments formels. Exemples : prog7.cc traceprog7 prog8.cc prog9.cc

Argument par d faut et transmission par r f rence e ee Si on utilise une r f rence comme valeur par d faut, la ee e variable doit etre globale.

Exemple incorrect : prog10.cc Message derreur du compilateur : erreurprog10.txt Une version correcte : prog10bis.cc Avec des pointeurs il est possible dutiliser des variables locales (attention aux adresses folles) prog11.cc

Utilisation dune structure comme valeur par d faut e On peut utiliser soit une valeur ; soit une r f rence avec la restriction d j` cit e ; ee ea e Exemple : prog12.cc ; R sultat :traceprog12.txt. e

Expressions utilis es comme valeur par d faut e e Les arguments par d faut sont evalu s a lendroit de la e e ` d claration. e

Quel est le r sultat de ce programme ? : prog13.cc e Il afche 2. Quel est le r sultat de ce programme ? : prog13bis.cc e Il afche 3.

Pointeur sur une fonction comme param` tre par d faut e e Il est possible de passer des pointeurs sur des fonctions ; On peut donc d finir une fonction par d faut ; e e Exemple : prog14.cc ; R sultat : traceprog14.txt. e
3.3 Fonctions renvoyant une r f rence ee

Une fonction peut renvoyer une r f rence sur une variable, ee comme illustr sur lexemple suivant : e
const int L=3, C=2; int& place (int tab[L][C], int); void ecrire (int tab[L][C]); main() { int t[L][C]; for (int i=0; i<L; i++) for (int j=0; j<C; j++) t[i][j] = i + 2*j; ecrire (t); place (t,3) = 0; ecrire (t); }
int& place (int tab[L][C], int val) { for (int i=0; i<L; i++) for (int j=0; j<C; j++) if (tab[i][j] == val) return tab[i][j]; return tab[0][0]; } void ecrire (int tab[L][C]) { for (int i=0; i<L; i++) { for (int j=0; j<C; j++) cout << tab[i][j] << "/"; cout << endl; } }
R sultats afch s : e e
0/2 1/3 2/4 0/2 1/0 2/4
3.4 Surcharge de fonction

Plusieurs fonctions peuvent avoir le m me identicateur ; e

Le compilateur identie la fonction appel e grace aux e types des arguments ; Les types doivent etre discriminants ;
Exemple de surcharge : prog15.cc ; R sultat : traceprog15.txt. e
4. Allocation dynamique
1 Organisation de la m moire e 2 Lop rateur new e 3 Lop rateur delete e 4 Exemple developp e 5 Tableaux
4.1 Organisation de la m moire e

La m moire attach e a un programme qui sex cute e e ` e ` (processus) est divis e en plusieurs zones qui correspondent a e la nature des entit s qui y sont stock es. e e Une zone pour stocker le code.

Une zone de m moire statique dans laquelle on trouve les e variables statiques et les variables globales (dur e de vie = e celle du processus). ` La pile qui sert a stocker les variables automatiques.Dans cette zone les variables sont constamment cr ees et e d truites en fonction de la dur e de vie. e e
Le tas cest dans cette zone que lon r serve un e emplacement m moire. On connat cet emplacement par e son adresse et non par un identificateur. Lemplacement e e est r serv tant quil na pas et d sallou . On utilise new e e e et delete pour g rer cet emplacement. e

4.2 Lop rateur new e

new type o` type repr sente un type quelconque ; u e R sultat : pointeur de type type * sur la zone allou e ; e e ... ou pointeur nul en cas d chec ; e e On peut allouer de la place m moire pour n el ments e new type[n] n est une expression enti` re e quelconque ; On peut initialiser en m me temps que lallocation e int *ptr_int = new int(-56);

Le pointeur fourni pointe sur le
e el ment.
4.3 Lop rateur delete e

delete adresse d salloue la zone m moire allou e a e e e ` lemplacement adresse

Exemple
int *ptr = new int; //... delete ptr;
Pour d sallouer un tableau : e delete adresse Pour d sallouer un tableau dobjets : e delete [] adresse Exemple
int *tab = new int[10]; //... delete tab;
4.4 Exemple dutilisation de new et delete

Dans cet exemple on construit un tableau de chanes de caract` res ; e

Le tableau est allou dynamiquement ; e Les chanes egalement ; A la fin du programme on d salloue. e exemple : prog18.cc et sa trace traceprog18.txt.
` 4.5 Les tableaux a plusieurs dimensions

Un tableau de dimension n cest un tableau de dimension e 1 dont les el ments sont de dimension n - 1 ; Exemple pour un tableau de dimension 2 :
int ligne = 5; const int NB_COL = 3; int (* ptr)[NB_COL] = new int[ligne][NB_COL];
e Les el ments sont des tableaux dentiers, ptr est donc un pointeur sur un tableau de NB COL entiers ; Toutes les dimensions doivent etre connue sauf eventuellement la premi` re. e Pour lib rer la zone : delete [] ptr; e Exemple prog19.cc
` 4.5. Les tableaux a plusieurs dimensions

` Pour cr er un tableau de dimension 2 dont on donne a e lex cution les deux dimmensions. On peut proc der de la e e facon suivante :
nombre de colonnes info i,nt * int ...................
int **
int *
..........
Exemple : prog20.cc
5. Construction dune classe vecteur en C++

1 D nition dune classe e 2 Constructeurs/destructeurs 3 Surcharge dop rateurs e 4 Fonctions et classes amies 5 Surcharge des op rateurs de ux e 6 Utilisation de chiers
5.1 D nition dune classe e

Une classe permet de d nir un nouveau type de donn es et e e des primitives de traitement associ es. Elle contient des e membres de 2 natures diff rentes : e des attributs (donn es membres) e

des m thodes (fonctions membres) e
Visibilit des membres e

Les membres dune classe peuvent etre d clar s avec les e e qualicatifs suivants : private (valeur par d faut) : non accessibles en dehors de e la classe public : accessibles en dehors de la classe, ces membres constituent linterface de la classe. protected : concerne la notion dh ritage et les classes e d riv es (vues plus loin) e e
Exemple
Voici la premi` re version de notre chier vecteur.h, en-t te e e de la classe Vecteur :
#include <iostream.h> class Vecteur { int taille; float* valeur; public : void initialise (int, float); void ajoute (int, float); void affiche (); };
Voici maintenant le chier vecteur.cc qui contient limpl mentation des m thodes d nies dans le chier e e e den-t te (on notera la mani` re de d signer les m thodes e e e e rattach es aux classes) : e
void Vecteur::initialise (int a, float b) { taille = a; valeur = new float[taille]; for (int i=0; i < taille; i++) valeur[i] = b; } void Vecteur::affiche() { for (int i=0; i < taille; i++) cout << valeur[i] << ; cout << endl; }
void Vecteur::ajoute(int i, float a) { valeur[i] += a; } main() { Vecteur v; v.initialise (10, 3.0); v.affiche(); v.ajoute (3, 2.0); v.affiche(); }
Remarque : Dans la construction nale de la classe Vecteur, ces m thodes nexisteront pas ou seront trait es diff remment. e e e
Le pointeur this
Chaque classe poss` de implicitement (sans que lon ait e besoin de la d clarer) la donn e qui correspond au e e pointeur this qui pointe sur lobjet courant.

` Exemple : on ajoute la m thode suivante a la classe e vecteur :

int Vecteur::est_egal(Vecteur p) { return (this == &p);}
Attention : Cette m thode ne teste pas si lobjet P a les m mes e e composantes que lobjet courant !

Cette m thode v rie que ces deux objets ont la m me e e e adresse.
Membres static
Un membre peut etre d clar static. e e ` Il est alors commun a tous les objets de la classe. Si un objet le modie, il le sera donc pour tous les autres objets de la classe.
Exemple : dans la classe Vecteur, on ajoute un membre

static int nb_objet;
qui va compter le nombre dobjets instanci s de la classe : e On linitialise en dehors de la d claration de classe par e

int Vecteur::nb_objet=0;
Remarque : on pr xe lattribut par le nom de la classe et e pas par le nom dun objet instanci . Par d faut une e e variable static est initialis e a 0. e ` On lincr mente dans la proc dure initialise par e e linstruction
Vecteur::nb_objet++;
5.2 Constructeurs/destructeurs
A linstanciation dun objet, une fonction membre appel e e constructeur est invoqu e automatiquement. e Lorsque lobjet nexiste plus, une fonction membre appel e destructeur est invoqu e automatiquement. e e On peut red nir soi-m me un ou des constructeurs ou e e destructeurs. Un constructeur (resp. destructeur) est donc une focntion membre public qui porte obligatoirement le nom de la classe.
Constructeurs - exemple 1
Dans la classe Vecteur, la fonction initialise peut etre avantageusement remplac e par un constructeur : e
class Vecteur { int taille; float* valeur; public: Vecteur(int, float); void ajoute(int, float); void affiche(); }
Vecteur::Vecteur(int a, float b) { taille = a; valeur ) new float [taille]; for (int i=0; i<taille; i++) valeur[i]=b; } ... main() { Vecteur v(10, 3.0); v.affiche(); }
Constructeurs - affectation automatique

Dans la d ntion dun constructeur, on peut faire suivre e len-t te par des affectations dattributs comme ci-dessous : e
Vecteur::Vecteur(int a, float b):taille(a) { ...}
Remarque : il peut y avoir plusieurs affectations successives, s par es par des virgules. e e
Constructeurs surcharg s e constructeur sans param` tre e

Il est courant de d nir plusieurs constructeurs avec des e param` tres diff rents (en nombre ou en type) : il sagit de e e surcharge.

` Par exemple, on pourrait ajouter a la classe Vecteur un constructeur sans param` tre. Linstantiation invoquera la e classe sans mettre de paranth` se. e
Vecteur::Vecteur() { taille=0; valeur = new float; } main() { Vecteur p; ...}
Destructeur
Dans la classe Vecteur, on va d nir un destructeur qui e lib` re la zone m moire allou e par le constructeur. Il sexecute e e e ` ` e a la n du programme ou dun bloc ou des objets locaux ont et d nis. e
class Vecteur { int taille; float* valeur; public : Vecteur (int, float); Vecteur(); } Vecteur::Vecteur() { delete valeur; }
Constructeur de copie
Dans les cas suivants : linitialisation dun objet par un autre,

la transmission dun objet en tant que param` tre dune e fonction,
on appelle implicitement une m thode pr d nie qui est en fait e e e un constructeur de copie.
Exemple dinvocations implicites de ce constructeur :

void f(Vecteur q) { ...} main() { Vecteur p1, p2(p1), p3=p1; ... f(p1); }
p2 et p3 sont des recopies de p1 ;

` q, le vecteur local a lex cution de la fonction f, est une e recopie de p1.
On peut cr er soi-m me son propre constructeur de copie. e e Cest n cessaire lorsque lobjet contient des pointeurs et e des structures dynamiques. Par exemple, pour la classe vecteur, le constructeur de recopie va uniquement recopier ladresse du tableau point e par le vecteur (voir gure).
Objet initial float* valeur;
Objet recopi par dfaut float* valeur;
En raison du destructeur ecrit pr c demment, on peut e e rencontrer le probl` me suivant : e Si la copie concerne une transmission de param` tre, e

` a lappel de la fonction, un vecteur local est cr e, e son attribut valeur pointe sur la m me adresse que e lobjet initial. A la sortie de la fonction, le destructeur de ce vecteur local est invoqu e et provoque la d sallocation de la zone m moire point e e e e par valeur ` et donc celle qui correspond aussi a lobjet initial !
Il est n cessaire d crire soi-m me son constructeur de copie e e e qui fera une nouvelle allocation pour le vecteur recopi . On e doit alors recopier les valeurs point es dans le nouvel e emplacement (voir gure).
Objet initial float* valeur; 1.0 7.0 3.0
Objet recopi 1.0 7.0 3.0 float* valeur;
Un constructeur de recopie devra obligatoirement etre d ni e par le prototype suivant : Vecteur (Vecteur &) ou encore Vecteur (const Vecteur &) car il ny a pas lieu de modier le param` tre transmis. e
#include <iostream.h> class Vecteur { int taille; float* valeur; public : Vecteur(int n=0) //constructeur ... //sous sa forme finale { valeur = new float [taille=n];}
Vecteur (const Vecteur & v) // const. par recopie { valeur = new float [taille=v.taille]; for (int i=0; i<taille; i++) valeur [i] = v.valeur[i]; } Vecteur() { delete valeur;} };
Remarque : Le corps des fonctions est directement ecrit dans la d claration de la classe. Il sagit de fonctions inline. e
5.3 Surcharge dop rateurs e

Les op rateurs classiques (+,-,/,*) peuvent etre surcharg s e e ` pour sappliquer a des objets dune classe donn e. e Dans la classe Vecteur, on va d nir lop rateur daddition e e qui permettra d crire une expression de la forme v1 + e v2, o` v1 et v2 sont des vecteurs. u

` Pour r aliser cela, on ajoute une m thode a la classe e e vecteur qui sappelle operator+.v1 + v2 doit donc etre interpr t sous la forme v1.operator+(v2). ee
class Vecteur { ... Vecteur operator+ (const Vecteur &); ... } Vecteur Vecteur::operator+ (const Vecteur &v) // on suppose que la taille de v est // identique au vecteur courant { Vecteur result(taille); for (int i=0; i<taille; i++) result.valeur[i]=valeur[i]+v.valeur[i]; return result; }
Remarques : 1. Les param` tres sont transmis par r f rence (constante) e ee pour eviter les recopies des tableaux. 2. Attention de ne pas renvoyer une r f rence de vecteur : ee Vecteur & Vecteur::operator+ (const Vecteur &v) car on renvoie ici ladresse du vecteur local result qui est d sallou en n dex cution ! e e e
3. On peut aussi d nir lop rateur + en dehors de la classe e e Vecteur, pour une m me utilisation e
Vecteur operator+ (const Vecteur &v1, const Vecteur &v2) // on suppose que les tailles de v1 et // de v2 identiques { Vecteur result(v1.taille); for (int i=0; i<v1.taille; i++) result.valeur[i]=v1.valeur[i]+v2.valeur[i]; return result; }
On suppose ici que les attributs des vecteurs sont publiques, sinon on utilise des op rateurs dacc` s, comme e e d crit plus loin. e
Surcharge de lop rateur daffectation = e

Par d faut, on peut faire des affectations entre 2 objets (de e m me nature). Un op rateur daffectation implicite est e e construit pour chaque classe.

Comme pour le constructeur de recopie existant par d faut, e lop rateur daffectation peut poser des probl` mes avec les e e structures dynamiques.
Dans la classe Vecteur, si on ecrit
Vecteur a(5); Vecteur b; b=a;
Alors les attributs valeur de b et a pointent sur la m me e zone m moire. Une supression de b va d sallouer le e e tableau g r aussi par a ! ee
On red nit lop rateur daffectation comme ci-apr` s : e e e

class Vecteur { ... Vecteur & operator= (const Vecteur &); ... } Vecteur & Vecteur::operator= (const Vecteur & v) { if (this != &v) { if (taille != v.taille) { delete valeur; valeur = new float [taille=v.taille]; } memcpy (valeur, v.valeur, taille*sizeof(float)); } return *this; }
Remarque : 1. La transmission de largument doit se faire par r f rence ee car on a besoin de ladresse dans le test (this != &v) qui evite que lon affecte un objet sur lui-m me et eviter e notamment de faire delete valeu; qui efface tout ! 2. Le qualicatif const devant le param` tre permet e daffecter aussi des vecteurs constants (sinon cest impossible). 3. Lop rateur daffectation renvoie une adresse pour e permettre des affectations multiples : v1 = v2 = v3;
Forme canonique dune classe

On vient de voir que lutilisation efcace de structures ` dynamiques, impliquant des d sallocations a la destruction des e objets, n cessite une grande prudence et une discipline e simpose : on parle de forme canonique qui est bas e sur une e d nition syst matique des 4 m thodes : e e e Un constructeur de base

Un destructeur Un constructeur de copie Un op rateur daffectation e
class T { ... public : T(...); //constructeur T(const T &); // constructeur de copie T(); // destructeur T & operator= (const T&); // op. affectation };
Surcharge des op rateurs dacc` s e e

Dans la classe Vecteur, on va d nir un op rateur e e ` ee permettant dacc der a l l ment de rang i de lattribut e valeur.

On utilise la surcharge de lop rateur [], ainsi a[i] va e d signer l l ment voulu pour a un objet de la classe. e ee
class Vecteur { ... float & operator[] (int); ... } float & Vecteur::operator[](int i) { return valeur[i]; }
Remarques : 1. La m thode renvoie une r f rence. On peut lutiliser dans e ee le membre gauche dune affectation :
Vecteur a; a[6]=3.2;
2. Si on veut utiliser cette fonction sur un objet constant, il ` faut ajouter const a droite de len-t te. Dans ce cas, il e ny a pas lieu de faire daffectation sur une composante de lobjet ! et la focntion na pas besoin de renvoyer une r f rence. On a int r t a red nir une deuxi` me focntion ee ee ` e e dacc` s pour les objets constants : e
class Vecteur { ... float operator[](int) const; ... } float Vecteur::operator[](int i) const { return valeur[i]; }
` 3. On peut a lidentique utiliser lop rateur (). e 4. On peut utiliser lop rateur dacc` s dans la d nition des e e e autres m thodes de la classe. Par exemple, lop rateur + e e peut se r ecrire : e
Vecteur Vecteur::operator+ (const Vecteur &v) { Vecteur result(taille); for (int i=0; i<taille; i++) result[i]=valeur[i]+v[i]; return result; }
5.4 Fonctions et classes amies

Une fonction est amie dune classe si elle peut acc der e ` directement a toutes les donn es priv es de cette classe. e e

Une classe est amie dune autre classe si toutes ses fonctions lui sont amies. La d claration damiti doit se faire dans la classe qui e e autorise les acc` s a ses donn es priv es. e ` e e
Exemple
class A { friend void fonction_b (); friend class C; ... }
La fonction fonction b peut acc der aux donn es e e priv es de A. e

Toutes les fonctions de la classe C peuvent acc der aux e donn es priv s de A. e e
` Attention : la notion damiti est contraire a la notion e dencapsulation. Elle doit etre utiliser de mani` re pertinente et e avec parsimonie.
Exemple de focntion amie : multiplication scalaire/vecteur

On veut ecrire une fonction qui effectue le produit

Le membre de gauche etant dun type simple, on pourrait la d nir ainsi e

Vecteur operator* (float alpha, const Vecteur &v) { Vecteur result(v.taille); for (int i=0; i<v.taille; i++) result[i] = alpha * v.valeur[i]; return result; }
Telle quelle est ecrite, cette fonction acc` de aux donn es e e priv es du vecteur v. Elle doit etre d clar e amie de la classe e e e vecteur comme indiqu ci-apr` s : e e
class Vecteur { ... public : ... friend Vecteur operator* (float, const Vecteur &); ... }
Bien attendu, on peut se dispenser ici de cette d claration e damiti , d nir et utiliser proprement des op rateurs dacc` s. e e e e
5.5 Surcharge des op rateurs de ux e

cin (resp. cout) est un objet appel ot ou ux dentr e e e pr d ni. Il est de la classe istream (resp. ostream) e e qui contient tous les ots dentr e (resp. de sortie). e

Lorsque lon ecrit

cin >> quelque_chose;
` cela correspond a
operator>> (cin, quelque_chose);
Pour surcharger >>, il faut d crire la fonction hors-classe e suivante :

istream & operator >> (istream &in, nom_classe & objet);
Cette fonction, une fois d nie, permettra de saisir des e objets de type tt nom classe, avec linstruction :
in >> ...
Par ailleurs, ce ot dentr e peut etre soit un ot pr d ni e e e (par exemple, cin), soit un chier. Il est alors possible de tester ce ot dentr e (dans lexemple on regarde si il e ` correspond a cin):
if (&in==&cin) ...;
La fonction de surcharge de lop rateur >> se terminera e nalement par

return in;
On proc` de de la m me mani` re pour surcharger e e e lop rateur de sortie <<. e
Exemple : surcharge du ux dentr e dans la e classe Vecteur

Dans la version qui suit, la saisie est directe si on utilise un chier et interactive par lentr e standard (clavier) e
istream & operator >> (istream & is, Vecteur &v) { int ntaille; if (&is == &cin) cout << "taille du vecteur ? "; is >> ntaille; Vecteur nv(ntaille); if (&is == &cin) cout << "coefficients ? " << endl; for (int i=0; i < ntaille; i++) is >> nv[i]; v = nv; return is; }
5.6 Utilisation de chiers

e On se contente ici de donner un exemple el mentaire utilisant ` les ux dentr e et de sortie (op rateur << a ecrire ...) sur la e e classe Vecteur :
#include <fstream.h> #include "Vecteur.h" main() { Vecteur x1, x2; ifstream in; ofstream out; in.open("input.dat"); out.open("output.dat"); in >> x1; in >> x2; Vecteur x3 = 2*x1+x2; out << "calcul de 2*x1+x2 :" << endl << x3; in.close(); out.close(); }
chier input.dat :
4 2 4 1 3 2 4 3 1 5
chier output.dat
calcul de 2*x1+x2 : taille du vecteur : 4 coefficient du vecteur : 5 8 11 7
6. Construction dune classe matrice

On construit une classe Matrice danns laquelle les donn es e priv es sont : e le nombre de lignes;

le nombre de colonnes; les coefcients sont g r s par un tableau de Vecteur ee (pointeur de Vecteur)
6.1 classe Matrice : forme canonique

On ecrit les m thodes qui lui conf` rent une forme e e canonique Constructeur de base

Destructeur Constructeur de copie Op rateur daffectation e
#ifndef MATRICE #define MATRICE #include "Vecteur.h" class Matrice { int nligne; int ncolonne; Vecteur * coefligne; public : Matrice (int=0, int=0); Matrice (const Matrice &); Matrice(); Matrice & operator= (const Matrice &); }
6.2 classe Matrice : op rateurs dacc` s e e surcharges des ux dE/S

On construit un op rateur dacc` s [] qui renvoie une ligne e e de la matrice de type Vecteur.

On construit des surcharges des op rateurs dentr e/sorties e e
6.3 classe Matrice : op rateur de conversion e

Un constructeur qui na qquun seul argument de type T sp cie une conversion dune variable de type T vers un e objet de la classe du constructeur. Ce constructeur est appel automatiquement chaque fois e quun objet de type T sera rencontr l` o` il faut un objet e a u de la classe du constructeur. Dans la classe Matrice, on ecrit un constructeur qui convertit un Vecteur de taille n en une Matrice de n lignes et 1 colonne.
class Matrice { ... Matrice (const Vecteur &); ... } Matrice::Matrice (const Vecteur & v): nligne(v.taille),ncolonne(1) { coefligne = new Vecteur [nligne](ncolonne); for (int i=0; i<nligne; i++) coefligne[i][0] = v[i]; } main() { Vecteur v(10); cin >> v; Matrice m=v; cout << m; }
7. H ritage e
Concept fondamental de la POO

Une classe dite d riv e peut h riter dune classe (ou e e e plusieurs) : elle a donc implicitement les propri t s de ee celle-ci en plus de propri t s caract ristiques propres. ee e Exemple : classe point color e qui h rite dune classe e e point.
class Point { int x; int y; public : Point(int, int); void deplace(int, int); void affiche (); }; class Pointcol : public Point { char couleur; public : void colore (char cl) {couleur = cl;} };
Ici, Pointcol h rite de mani` re publique de Point. e e Donc les membres de Pointcol ont acc` s aux membres e publics de Point mais pas aux membres priv s e

Exemple :
void Pointcol::affichecol() { affiche();; //appel affiche de la classe m`re e cout << "couleur : " << couleur << endl; }
On peut aussi red nir la fonction affiche. Il faut alors e distinguer les deux m thodes du m me nom : celle de la e e classe m` re et celle de la classe d riv e. e e e

void Pointcol::affiche() { Point::affiche();; //appel affiche de Point cout << "couleur : " << couleur << endl; }
7.1 Constructeurs et destructeurs

class Base { ... public : Base(...); Base(); ... } Class Derive : public Base { ... public : Derivee(...); Derive(); ... }
La cr ation dun objet Derive n cessite dabord la e e cr ation dun objet Base. Le constructeur de Base est e appel implicitement avant toute autre instruction au tout e d but de l xecution du constructeur de Derive. e e
On a le processus inverse pour le destructeur. Celui de la classe m` re est appel implicitement a la n de lex cution e e e ` de celui de la classe d riv e. e e

Constructeurs avec arguments

class Point { ... public : Point(int, int); ... } Class Pointcol:public Point { ... public : Pointcol(int, int, char); ... }
La description pr c dente est incompl` te comme expliqu e e e e ci-apr` s. e A la construction dun objet Pointcol, son constructeur est appel et ce dernier appelle alors imm diatement celui e e de Point qui attend 2 arguments.
Pour transmettre les arguments entre le constructeur de la classe d riv e et celui de la classe m` re, on d crit cette e e e e transmissions dans len-t te de Pointcal de la mani` re e e suivante :
Pointcol(int a, int b, char cl) : Point(a, b)
7.2 Contr le des acc` s o e

La Notion de protection permet de rendre accessibles pour une classe d riv e (et seulement dans ce cas) certains membres e e dune classe de base.
class Point { protected : int x, y; public : Point( ...); ... }
class Pointcol : public Point { char couleur; public : void affiche() { cout << "position " << x << " et " << y << endl; cout << "couleur " << couleur << endl; } }
affiche peut acc der aux champs prot g s de Point. e e e

Ces m mes champs restent priv s pour les utilisateurs de e e la classe Point.
Amiti s et h ritage e e Les fonctions amies dune classe d riv es ont les m mes e e e autorisation dacc` s que les fonctions membres de cette e classe (notamment pour lacc` s aux membres prot g s). e e e Les d clarations damiti ne sh ritent pas. e e e
Les diff rents types de d rivations e e D rivation publique e

On a utilis jusqualors des d rivations publiques indiqu es e e e dans len-t te des classes d riv es. e e e
class Pointcol : public Point { ...}
Voici les propri t s de ce type de d rivation : ee e Les membres publics de la classe de base sont accessibles partout.

Les membres prot g s de la classe de base sont accessibles e e aux fonctions membres et aux fonctions amies de la classe d riv e, mais pas aux utilisateurs de la classe d riv e. e e e e Les membres priv s de la classe de base sont inaccessibles e en dehors de cette classe de base.
Les diff rents types de d rivations e e D rivation priv e e e

On la signie dans len-t te des classes d riv es. e e e
class Pointcol : private Point { ...}
` Elle interdit a un utilisateur dune classe d riv e lacc` s e e e aux membres publics de sa classe de base. Par contre, le concepteur de la classe d riv e peut utiliser les membres e e publics de la classe de base (comme un utilisateur ordinaire de la classe de base).

Par exemple, si Pointcol h rite de mani` re priv e, un e e e objet de type Pointcol ne pourra pas appeler deplace() qui est un membre public de Point.
Les diff rents types de d rivations e e D rivation prot g e e e e

Introduit plus tardivement dans les sp cications du C++, on la e signie dans len-t te des classes d riv es. e e e
class Pointcol : protected Point { ...}
Elle permet que les membres publics de la classe de base soient consid r s comme prot g s pour les d rivations ee e e e suivantes.
7.3 Constructeur par recopie

Soit une classe B qui h rite dune classe A e Si B na pas de constructeur de copie,

le constructeur de copie par d faut sera appel , e e pour la partie h rit e de A, le constructeur de copie de e e A sera appel sil existe (sinon cest encore le e constructeur de copie par d faut) e
Si B poss` de un constructeur de copie, e celui-ci sera appel ... mais pas celui de A. e Donc le constructeur de copie dune classe d riv e doit e e prendre en charge la totalit de la copie de lobjet et e notamment sa partie h rit e. Mais ... e e ... on peut utiliser un constructeur de A dans le ` constructeur de copie de B et lui transmettre lobjet a copier x lui-m me. Alors x est converti au type A avec e appel du constructeur de copie.
B(B &x) : A(x) //on provoque lappel //du constructeur de copie de A { //copie de la partie de x spcifique ` B} e a
7.4 Op rateur daffectation e

Soit une classe B qui h rite dune classe A e Si B na pas de d nition de = e

` laffectation se fait membre a membre, la partie h rit e est g r e par laffectation e e ee eventuellement red nie dans A. e Si B a une d nition de = e Seule laffectation de B est appel e et pas celle de A. e Lop rateur = de B doit g rer tous les membres m me e e e ceux h rit s e e
8. G n ricit et template e e e
` e La g n ricit consiste a d nir des fonctions et des classes o` e e e u les types sont param trables. e Plan 1. Fonctions g n riques e e 2. Patron de classe 3. Sp cialisation dun patron de classe e

Langue

Bienvenue sur Scribd !

ps-cpp

Transféré par

Informations du document

Date du transfert

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

Formats disponibles

ps-cpp

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Titres liés

Master Math-Info - M1 Programmation scientique

Chapitre 1 Programmation objet en C++

Programmation objet en C++

Programmation objet en C++

2- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

Objectif : greffer sur C les fonctionnalit s des langages e objets.

3- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

4- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

5- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

6- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

7- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

8- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

Programmation objet en C++

1.2 Incompatibilit s C et C++ e

10- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

11- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

Fonction sans argument :

12- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

13- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

Expression constante (expression dont la valeur peut etre calcul e a la compilation) e `

En C++, le compilateur sait evaluer :

En C, non ! ... en g n ral. On doit utiliser #define : e e

14- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

Le type void * : pointeur g n rique e e

15- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

1.3 Quelques sp cicit s - commentaires e e

16- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

1.3 Quelques sp cicit s - d claration e e e

17- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

1.3 Qques sp cicit s - entr es/sorties e e e

En afchage, cout Exemple :

18- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

19- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

1.4 C++ Langage Orient Objet e

20- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

21- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

22- G. Pr vost @ Universit du Havre e e

Programmation objet en C++

23- G. Pr vost @ Universit du Havre e e