Programmation orientée objet Langage C++

Transcription

1 Programmation orientée objet Langage C++ ESTA, 2017 Mohammed Khachan 1 Objectif S initier à le programmation orientée objet Apprendre les bases du langage C++. Laisser de coté l approche procédurale. Apprendre à penser au sens objet. 2 1

2 Concept Apprentissage de la programmation orientée objet via le langage C++ TD/TP sur machine approfondir les concepts introduits dans le cours alternance TD et TP d'application Implémenter les exercices du TD 3 Plan Passage du C au C++ Gestion entrée sortie Tableaux statiques et dynamiques Allocation mémoire. Surcharge de fonctions Fonction: passage par valeur, par pointeur, par référence Approche orientée objet versus approche procédurale Notion de classe & encapsulation Données, méthodes Constructeur, destructeur Fonctions amies Surcharge des operateurs Patron de classe et de fonction (template) Héritage & Polymorphisme Tour d horizon de la librairie STL 4 2

3 Partie I Passage du C au C++ 5 Passage du C au C++ C est un langage de programmation procédurale : Programmes = Structures de données + Algorithmes. Le développement est axée sur les traitements (fonctions). Extension des fichiers : header (.h) source (.c) C++, développé à partir du C (début des années 80 par Bjarne Stroustrup). C++ Comprend la syntaxe du C ( C++ inclut le C ). C++ est un langage de programmation orienté objet: Objets = Données + Méthodes Le développement est axée sur les données (objets). Extension des fichiers : header (.h,.hpp) source (.cpp) ou (.hh,.cc) 6 3

4 Passage du C au C++ Programme C typedef struct point2d float x; float y; PT2D; void afficherpoint( PT2D pt ) printf( "%f, %f \n", pt.x, pt.y ); int main() PT2D pt=0.2f, 5.4f; afficherpoint( pt ); typedef struct point2d float x; float y; void afficherpoint(); PT2D; void PT2D::afficherPoint() cout << x << ", " << y << endl; int main() PT2D pt=0.2f, 5.4f; pt.afficherpoint(); 7 7 Structure en C++ struct PT2D float _x; float _y; Données membres void set(float x, float y); void afficher(); ; int main() PT2D pt=0.2f, 5.4f; pt.afficher(); pt._x= pt._y + 1; pt.afficher(); pt.set( 1.4f, 2.5f ); pt.afficher(); void PT2D::afficher() cout << "Pt( " << _x << ", " \ << _y << " ) " << endl; void PT2D::set( float x, float y ) _x = x; _y = y; Fonctions membres En C++, on peut omettre d utiliser struct dans la déclaration des variables, comme dans la déclaration de pt. On accède aux membres de la structure en utilisant l opérateur ". " (ou si pointeur). Les fonctions membres sont définies soit à l intérieur de la structure (déconseillée) ou bien à l extérieur. Dans ce cas, ces fonctions sont accessibles 8 par l'intermédiaire de l'opérateur "::". 8 4

5 Structure en C++ struct PT2D float _x; float _y; Données membres void set(float x, float y); void afficherpoint(); double calculernorme(); double distance(pt2d pt); ; void PT2D::set( float x, float y ) _x= x; _y= y; void PT2D::afficherPoint() cout << "Pt( " << _x << ", " \ << _y << " ) " << endl; int main() PT2D pt=0.2f, 5.4f; pt.afficherpoint(); pt.set( 1.4f, 2.5f ); pt.afficherpoint(); Fonctions membres double PT2D::calculerNorme( ) double res= sqrt( _x*_x + _y*_y ) ); return res; double PT2D::distance( PT2D pt ) float xx= _x pt._x, yy= _y pt._y; double res= sqrt( xx*xx + yy*yy ) ); return res; 9 9 Structure en C++ struct PT2D float _x; float _y; Données membres PT2D( float x, float y ); Constructeur void afficherpoint(); double calculernorme(); Fonctions membres double distance(pt2d pt); ; void PT2D::PT2D( float x, float y ) _x= x; _y= y; void PT2D::afficherPoint() cout << "Pt( " << _x << ", " \ << _y << " ) " << endl; int main() PT2D pt(0.2f, 5.4f); pt.afficherpoint(); pt.set( 1.4f, 2.5f ); pt.afficherpoint(); double PT2D::calculerNorme( ) double res= sqrt( _x*_x + _y*_y ) ); return res; double PT2D::distance( PT2D pt ) float xx= _x pt._x, yy= _y pt._y; double res= sqrt( xx*xx + yy*yy ) ); return res;

6 Exemple : calcul aire Tétraèdre ( C ) #ifndef _AIRE_TETRAEDRE_ #define _AIRE_TETRAEDRE_ double calculerperimetretriangle( double, double, double ); double calculerairetriangle( double, double, double ); typedef struct point double x, y, z; PT3D; double distance( PT3D, PT3D ); double calculerperimetretriangle3d( PT3D, PT3D, PT3D ); double calculerairetriangle3d( PT3D, PT3D, PT3D ); double calculerairetetraedre( PT3D, PT3D, PT3D, PT3D ); airetetraedre.h Syntaxe en C #endif 11 Exemple : calcul aire Tétraèdre (C++) #ifndef _AIRE_TETRAEDRE_ #define _AIRE_TETRAEDRE_ struct PT3D float _x, _y, _z; PT3D( float x, float y, float z ); double distance( PT3D ); ; struct TRIANGLE PT3D _pt1, _pt2, _pt3; double calculerperimetretriangle3d( ); double calculerairetriangle3d( ); private : ; double calculerperimetretriangle(double, double, double); double calculerairetriangle(double, double, double); private indique que les fonctions membres (privées) ne peuvent pas être appelées que dans les fonctions membres de la structure (pas ailleurs). struct TETRAEDRE PT3D _pt1, _pt2, _pt3, _pt4; double calculerairetetraedre( ); ; #endif 12 6

7 Définition des fonctions membres double PT3D::distance( PT3D pt ) double xx= _x pt._x, yy= _y pt._y, zz= _z pt._z; return( sqrt( xx*xx + yy*yy + zz*zz ) ); double TRIANGLE::calculerPerimetreTriangle( double a, double b, double c ) return( a + b + c ); double TRIANGLE::calculerPerimetreTriangle3D( ) double dist1= _pt1.distance( _pt2); double dist2= _pt2.distance( _pt3); double dist3= _pt3.distance( _pt1); return( calculerperimetretriangle( dist1, dist2, dist3 ) ); double TETRAEDRE::calculerAireTetraedre( ) TRIANGLE tr1=_pt1, _pt2, _pt3, tr2=_pt1, _pt3, _pt4, tr3=_pt1, _pt4, _pt2, tr4=_pt2, _pt3, _pt4; double aire1= tr1.calculerairetriangle3d(); double aire2= tr2.calculerairetriangle3d(); double aire3= tr3.calculerairetriangle3d(); double aire4= tr4.calculerairetriangle3d(); return( aire1 + aire2 + aire3 + aire4 ); 13 Les commentaires En C les commentaires sont entre /* et */ En C++ on peut utiliser les commentaire entre /* et */ on peut aussi utiliser les commentaires de fin de ligne qui démarrent par // et vont jusqu'a la fin de ligne. Exemple : // int nbpres= 0; // variable pour stocker le nombre de personne. // La fin de ligne entraine la fin du commentaire 14 7

8 Gestion des entrées sorties Programme C #include <stdio.h> printf("hello world \n"); int i; float f; char c; char* s; #include <iostream> cout << "Hello world" << endl; int i; float f; char c; char* s; printf( i= %d \n, i); printf( c= %c \n, c); printf( s= %s \n, s); printf( %5.2f \n, f); printf( %f %s \n, f, s); cout << i= << i << endl; cout << c= << c << endl; cout << s= << s << endl; cout << setw(5) << setprecision(2) << f << endl; cout << f << s << endl; scanf( %d, &i); scanf( %f, &f); scanf( %c %s, &c, &s); scanf( %s, &s) cin >> i; //Pas d adresse cin >> f; cin >> c >> s; cin >> s; #include <iomanip> 15 Gestion des entrées sorties en C++ <iostream> bibliothèque de gestion des entrées sorties. Les flux prédéfinis sont: cout associé à la sortie standard (stdout dans le langage C), cin associé à l'entrée standard (stdin dans le langage C). cerr associé à la sortie erreur standard (stderr dans le langage C). Deux opérateurs pour les flots : l'opérateur d'insertion << (écriture), utilisé pour cout, cerr. l'opérateur d'extraction >> (lecture), utilisé pour cin. Ces operateurs sont surchargés de manière appropriée pour prendre en compte les types élémentaires : Int, short, long, double, double, bool, char, char*, string Le bon format (bonne opération) est choisi en fonction du type des arguments. 16 8

9 Gestion des entrées sorties en C++ std: espace de noms contenant les différentes fonctions d entrées sorties. #include <iostream> int main() int n= 0; double p= 0.; std::cout << "Entrer n et p:\n"; std::cin >> n >> p; n += 3; std::cout << n << (p*p) << std::endl; endl est équivalent à \n en C. #include <iostream> using namespace std; int main() int n= 0; double p= 0.; cout << "Entrer n et p:\n"; cin >> n >> p; n += 3; cout << n << (p*p) << endl; 17 cin Saisie & Validation des entrées Les opérations d entrées-sorties ne doivent s effectuer que sur de bon flux. cin.good() : retourne true (1) si la valeur saisie est valide (elle est de même type que la variable de stockage). Sinon, elle retourne false (0); cin.clear(): rétablit le bon état du flux et permet l exécution des entrées sorties sur ce flux (remet le flux a l etat good). cin.ignore(nb): saute nb caractères. cin.ignore( ) saute un caractère. cin.gcount( ): signale le nombre de caractères lus lors de la dernière opération d entrée. cin.getline( char*, taille ): lit taille-1 caractères ou se termine à la rencontre du délimiteur qui n est pas inséré dans la chaine (il reste dans le flux et sera le prochain caractère lu). Le caractère null est inséré pour terminer la chaine de caractères. 18 9

10 Exemple de validation des entrées int main() int x; cout << " Saisir un entier : "; cin >> x; cout << "x vaut : " << x << " et cin.good() vaut : " << cin.good() << endl; cout << " On attend un entier, mais on entre un caractère ou chaine de caractère: "; cin >> x; cout << "x vaut : " << x << " et cin.good() vaut : " << cin.good() << endl; do char chaine[100]; cin.clear(); cin.getline( chaine, 100 ); cout << " Saisir un entier : "; cin >> x; while(! cin.good() ); 19 cout Formatage des sorties <iomanip> pour effectuer des entrées sorties formatées. setw, fill, setfill(), precision, setprecision Contrôle de la largeur des champs : setw(n) : manipulateur de flux pour ajuster la largeur du champ à saisir ou à afficher. n: nombre de caractère de sortie. Contrôle de remplissage: fill( * ): fonction spécifiant le caractère de remplissage. setfill( * ): manipulateur de flux, spécifiant le caractère de remplissage. Contrôle de la précision des nombres a virgule flottante : setprecision(n) : manipulateur de flux. n représente le nombre de chiffre après la virgule. precision(n) : fonction associée au flux de sorties (cout). n représente le nombre de chiffre après la virgule. Pour que ca marche, ajoutez en premier : cout.setf( ios::fixed ); ou cout.setf( ios::fixed ios::showpoint ); 20 10

11 Exemple #include <iostream> #include <iomanip> using namespace std; int main( ) int n= 123; cout << setw(6) << n << endl; cout << setw(2) << n <<endl; cout << setfill('*') << setw(6) << n <<endl; double pi= ; cout.setf( ios::fixed ); cout << setprecision(3); // équivalent à cout.precsion(3); cout << setw(10) << pi << endl; cout << setfill('0') << setw(6) << pi<< endl; return( 0 ); 21 Emplacement des déclarations En C, obligation de regrouper toutes les déclarations au début des blocks. En C++, les déclarations apparaissent n'importe où, avant d être utilisées. int main() int a= 10, i= 0, som= 0; printf( saisir a: \n ); scanf( %d, &a ); for( i=0; i< a; i++) som += i; printf( som= %d \n, som ); int main() int a= 10; cout << saisir a: << endl; cin >> a; int som= 0; for(int i=0; i< a; i++) som += i; cout << som= << som<< endl; 22 11

12 Type bool En C, il n'y a pas de type booléen. On utilise int. en C++, une variable du type bool peut prendre les valeurs : 0 ou false. 1 ou true. #include <iostream> using namespace std; int main() bool valide= false; cout << valide << endl; // affiche: 0 valide = true; cout << valide << endl; // affiche: 1 23 #define & const & inline Programme C #define PI #define taille 10 But: Substitution de texte Erreurs commises: #define taille = 10; //Erreur Pas de = ni de ; dans #define // Définition de macros #define Carre(a) a*a Carre(5) donne 25 // Problème du #define Carre(3+2) donne 11 (3+2*3+2) // Correction #define Carre(a) (a)*(a) const double PI= ; const int taille= 10; La valeur d'une constante ne peut pas être modifiée ( taille= 15; // Erreur ). Utiliser const au lieu du #define // Utiliser inline au lieu des macros #define inline Carre( int a ) return a*a; Une fonction inline est expansée à son point d appel. Elle et moins couteuse en temps. A définir au moment de sa déclaration dans le.h

13 Pointeurs (Rappel) int i = 21; int *ptr= NULL; ptr = &i; Variable Contenu memoire Adresse memoire Variable i Contenu 21 memoire Adresse memoire Variable iptr Contenu 21 NULL memoire Adresse memoire iptr ptr *ptr = *ptr + 1; // équivalent a i= i+1; (*ptr)++; // équivalent a i++; 25 Pointeurs (à savoir) const int j=15; int* ptr1= &j; // incorrect, ptr1 ne peut pas pointer sur une variable constante. const int* ptr2= &j; // ptr2 pointe sur une variable constante, ptr2 n est pas constant *ptr2=17; int k= 20, a= 25; ptr2= &k; // incorrect, la valeur pointée par ptr2 est une constante. // OK, ptr2 n est pas constant int* const ptr3 = &k; // OK, ptr3 est une constante mais pas la variable pointée k. ptr3 = &a; // Incorrect, l adresse de ptr3 est constante. *ptr3 = 11; // OK, et par la même occasion k vaut 11 const int* const ptr4 = &j; // ptr4 est constant et pointe sur une valeur constante *ptr4 = 30; // Incorrect, on modifie la valeur de j qui est constante ptr4 = &a; // Incorrect, on modifie l'adresse pointée par ptr4 qui est constante 26 13

14 Conversion de type Programme C void* type* type* void* void* type* type* void* // impossible int i= 5; int* p= &i; void* v= NULL; v = p; // OK p = v; // OK Cast p = (int*) v; int k= 5; int* p = &k; void* v= NULL; v = p; // OK p = v; // Incorrect Cast p = static_cast< int* >(v); static_cast peut effectuer les opérations de conversion standard de void* vers un int* par exemple. Cet opérateur ne permet pas le forçage de types const vers non const ainsi que le forçage de types sans relation. const_cast permet uniquement la conversion de types const vers non const. const int k = 5; int *p = static_cast <int *> (&k); // Incorrect int *p = const_cast <int *> (&k); // Correct 27 Tableau statique et dynamique Programme C Tableau statique int tab[10]; PT2D tabpt[15]; Tableau dynamique Allocation : int* pti= (int*)malloc(sizeof(int)); int* tab= (int*)malloc(10*sizeof(int)); PT2D* tabpt= (PT2D*)malloc(15*sizeof(PT2D)); Desallocation free(pti); pti = NULL; free(tab); tab = NULL; free(tabpt); tabpt= NULL; Tableau statique int tab[10]; PT2D tabpt[15]; Tableau dynamique Allocation : int* pti = new int; // ou int* pti = new int(-2); int* tab = new int[10]; PT2D* tabpt= new PT2D[15]; Desallocation delete pti; pti = NULL; delete [] tab; tab = NULL; delete [] tabpt; tabpt= NULL; 28 14

15 Tableau statique Programme C #define taille 10 int tab[taille]; typedef struct point2d double x, y; PT2D; PT2D tabpt[taille]; Le C refuse d utiliser une borne avec const. int i= 0; for( i= 0; i < taille; ++i ) (tabpt+i)->x = 2*i; tabpt[i].y = i; // *(tabpt+i) est equivalent a tab[i]. const int taille= 10; int tab[taille]; struct PT2D double x, y; ; PT2D tabpt[taille]; for( int i= 0; i < taille; ++i ) (tabpt+i)->x = 2*i; tabpt[i].y = i; 29 Allocation dynamique (malloc & new) Programme C int *q = (int *) malloc( sizeof(int) ); *q = 4; Desallocation free(q); q = NULL; int taille =20; int* tab=(int*)malloc(taille*sizeof(int)); for(int i=0; i< taille; i++) tab[i]=i;. free( tab ); tab= NULL; int *q = new int; *q = 4; //Autre méthode: int *q = new int(4); Desallocation delete q; q = NULL; int taille =20; int* tab= new int [taille]; for(int i=0; i< taille; i++) tab[i]=i;. delete [ ] tab; tab= NULL; 30 15

16 Tableau dynamique a 2 dimension Programme C int nbl =20, nbc= 15; int** tab=(int**)malloc(nbl*sizeof(int*)); for ( int i=0; i< nbl; i++ ) int j= 0; tab[i]= (int*)malloc(nbc*sizeof(int)); for( j=0; j< nbc; j++ ) tab[ i ][ j ]= i+j; Desallocation for( int i=0; i < nbl; i++ ) free( tab[ i ] ) ; tab[ i ]= NULL; free( tab ); tab= NULL; int nbl =20, nbc= 15; int** tab= new int* [nbl]; for ( int i=0; i< nbl; i++ ) tab[i]= new int [nbc]; for( int j=0; j< nbc; j++ ) tab[ i ][ j ]= i+j; Desallocation for( int i=0; < nbl; i++ ) delete [ ] tab[ i ] ; tab[ i ]= NULL; delete [ ] tab; tab= NULL; 31 Chaine de caractère Une chaîne de caractères est considérée comme un tableau de caractères dont le dernier élément est le caractère \0. Un tableau de chaîne de caractères peut être initialisé de la manière suivante: char msg[ ] = "Bonjour"; char msg[ ] = 'B', 'o', 'n', 'j', 'o', 'u', 'r', '\0'; char msg[15] = "Bonjour"; En dehors de la déclaration, il est impossible d affecter une chaîne de caractères à un tableau : il faut passer par des fonctions appropriées comme strcpy ou par remplissage du tableau caractère par caractère. char msg[15] ; msg = "Bonjour" ; // INCORRECT Attention aux affectations sans aucun sens : char tab1[10], tab2[10]; tab1 = tab2 ; // expression incorrecte tab1 et tab2 sont des constantes de type pointeur sur un caractère. On va voir un nouveau type string (en C++) qui gère mieux (plus simplement) les chaines de caractère

17 Les fonctions Paramètres par défaut Surcharge des fonctions Transmission de paramètres par référence Patron de fonctions 33 Paramètres par défaut Intérêt : attribuer des valeurs par défaut aux arguments d une fonction. Exemple: int min(int a, int b= 5); Ces paramètres doivent être placés en dernier sur la liste des arguments. A l appel s il manque des arguments, le C++ utilise les paramètres par défaut. int k= 10; int res= min( k ); // équivalent à l appel res= min(k, 5); int u= 12; res= min( k, u ); L attribution des valeurs par défaut se fait au niveau des déclarations (.h) et non pas au niveau des définitions (.cpp)

18 Surcharge des fonctions Attribuer le même nom à plusieurs fonctions L ambiguité est levé par la syntaxe : Nombre de paramètres Type des paramètres La surcharge n est pas possible en C. Exemple: int min(int a, int b, int c); int min(int a, int b); double min(double a, double b, double c); double min(double a, double b); 35 Surcharge des fonctions exemple : calcul aire Tétraèdre (rappel) #ifndef _AIRE_TETRAEDRE_ #define _AIRE_TETRAEDRE_ struct PT3D float _x, _y, _z; PT3D( float x, float y, float z ); double distance( PT3D ); ; struct TRIANGLE PT3D _pt1, _pt2, _pt3; double calculerperimetretriangle3d( ); double calculerairetriangle3d( ); private : double calculerperimetretriangle(double, double, double); double calculerairetriangle(double, double, double); private indique que les fonctions membres (privées) ne peuvent être appelées que dans les fonctions membres de la structure (pas ailleurs). struct TETRAEDRE PT3D _pt1, _pt2, _pt3, _pt4; double calculerairetetraedre( ); #endif 36 18

19 Surcharge des fonctions exemple : calcul aire Tétraèdre #ifndef _AIRE_TETRAEDRE_ #define _AIRE_TETRAEDRE_ struct PT3D float _x, _y, _z; PT3D( float x= 0, float y= 0, float z= 0 ); double distance( PT3D ); ; struct TRIANGLE PT3D _pt1, _pt2, _pt3; double calculerperimetre( ); double calculeraire( ); private : double calculerperimetre(double, double, double); double calculeraire(double, double, double); private indique que les fonctions membres (privées) ne peuvent être appelées que dans les fonctions membres de la structure (pas ailleurs). struct TETRAEDRE PT3D _pt1, _pt2, _pt3, _pt4; double calculeraire( ); #endif 37 19