Cours de programmation C++

Transcription

1 Cours de programmation C++ E. Remy IUT de Provence site d Arles 1

2 Historique Langage C Programmation structurée B. Kernighan & D. Ritchie 1973 ANSI/ISO 1989 (et 1999) Langage C++ Programmation orientée objet B. Stroustrup ~1980 ANSI/ISO 1998 Le C++ est un des principaux langages de développement actuellement en entreprise. Ce sera le langage de la majorité de vos TP à l'iut. 2

3 Apprendre les bases de C/C++ Je vous suggère fortement le livre (cours et exercices corrigés) «Programmer en C++» de John R. Hubbard, série Schaum's, EdiScience. Ce livre est disponible au prêt en deux exemplaires à la médiathèque de l'iut. 3

4 Spécificités du langage C++ Compatibilité avec le langage C (aussi bien pour les fichiers sources que pour les fichiers objets) Ajout de techniques de programmation avancées Compilateur plus pointilleux que C Programmation orientée objet : langage à classes Meilleure gestion des erreurs : les exceptions Programmation générique : patrons (templates) Standard Template Library (STL) La syntaxe générale de JAVAJ est directement inspirée de celle de C++ (qui elle-même reprend en totalité celle du C). 4

5 Fichier Ex1.cpp Premier programme #include <iostream> using namespace std; int main() { cout << "Hello world!" << endl; return 0; } g++ -Wall -c Ex1.cpp g++ -Wall -o Ex1.exe Ex1.o <- Compilation <- Edition de liens Warnings : all output : Ex1.exe Liste des fichiers objets... 5

6 La nouvelle syntaxe du C++ Ceux parmi vous qui connaîtraient déjà le C++ sont priés de remarquer que nous utiliserons dans ce cours la nouvelle syntaxe issue du standard de Apprenez à connaître les différences de syntaxe entre le C+ + normalisé et non normalisé car vous serez forcement amenés à utiliser les deux. Ne mélangez jamais les deux styles dans un même projet! 6

7 Les étapes de la compilation Le préprocesseur L'inclusion de fichiers (.h( et parfois autres) Substitutions lexicales : les macros La compilation Vérification de la syntaxe Traduction dans le langage d'assemblage de la machine cible L'assemblage Traduction finale en code machine Production d'un fichier objet (.o( ou.obj) L'édition de liens Unification des symboles internes Étude et vérification des symboles externes (.so( ou.dll) Production de l'exécutable 7

8 Les types de base bool (ex : true, false) char, unsigned char, wchar_t (ex : 'a', '%', '\n') short, unsigned short (ex : ) int, unsigned int (ex : 33000) long, unsigned long float, double, long double (ex : e+15) 8

9 Opérateurs et priorités Priorité + - :: (opérateur de résolution de portée). -> [] ()(appel (appel de fonction) ()(parenthèses) (parenthèses) sizeof() ~! (unaire) & (prise d'adresse) * (indirection) new delete delete[] ()(conversion (conversion de types, cast) * / % (multiplication, division, modulo) + - (addition et soustraction) << >> (décalages et envoi sur flots) < <= > >= (comparaisons) ==!= (comparaisons) & (ET bit à bit) ^ (OU-Exclusif bit à bit) (OU-Inclusif bit à bit) && (ET logique) (OU logique) (? : ) (expression conditionnelle ou opérateur ternaire) = *= /= %= += -= <<= >>= &= = ~=, (mise en séquence d'expressions) 9

10 Structures syntaxiques Un bloc { } permet de rassembler plusieurs instructions afin que le bloc «compte pour une seule instruction.» Remarque : Donc ne pas mettre des accolades sans raison autour d une unique instruction Commentaires identiques à JAVAJ : /* */ ou //.. Les structures de contrôle sont identiques à celles du C (et de JAVA) ) : for, while, if, switch, break, continue,, etc 10

11 Condition : if De la forme :... if( expression_condition ) { }...// effectué si expression_condition est vraie else // évidement le groupe else est facultatif { } // effectué sinon 11

12 De la forme : Choix multiple : switch switch( expression ) { } case expr_const1: : // si expression== ==expr_const1... break; // pour sortir du switch! case expr_const2: : // si expression== ==expr_const2... break; // pour sortir du switch! // eventuellement encore d'autres cases... default: // si expression est différente de tous... // les cas précédant Le break est facultatif! 12

13 Tant que... et Faire... tant que De la forme : while( expression_condition ) { }...// effectué tant qu'expression_condition est vraie De la forme : do { }...// effectué au moins une fois, puis encore tant // qu'expression_condition reste vraie while( expression_condition ); 13

14 De la forme : Boucle for for( initialisation(s) ; test ; incrémentation(s) ) { }...// effectué tant que test est vrai Possible de mettre plusieurs expressions. Par exemple : for( i=0,c='a' ; i<26 ; i=i+1,c=c+1 ) { } // i et c évoluent en parallèle respectivement de // 0 à 25 et de 'a' à 'z'! Attention : pas de «;» après le for sinon on répète l'instruction vide (qui ne fait rien)! 14

15 Entrée/Sortie Trois flots standards existent : cin (entrée standard) cout (sortie standard) cerr (sortie d erreur standard) Exemple : int n; cout << "Donnez" un entier, svp" << endl; cin >> n; cout << "Vous avez tape n=" << n << endl; cerr << "Arg! Panique!!!" <<endl; 15

16 Formatage des sorties Définis dans #include <iomanip> Formatages de sorties endl : insère une fin de ligne. setw(x) : la prochaine sortie sera sur une largeur de x caractères quitte à rajouter des espaces pour compléter. setfill(c) : utilisera c comme caractère de remplissage. left : la prochaine sortie sera cadrée à gauche (défaut). right : la prochaine sortie sera cadrée à droite. uppercase : prochaine sortie en majuscule. lowercase : prochaine sortie en minuscule. fixed : prochaine sortie en virgule fixe, ex. : scientific : prochaine sortie en notation ingénieur, ex. : 1.2e-4. flush : vide le tampon de sortie,, en assurant que toutes les opérations précédentes sont effectuées. 16

17 Les constantes Façon C : Définitions pour le préprocesseur. C est une substitution syntaxique pure (une sorte de copier/coller). En conséquence, il n y a aucun typage de la constante. Ex : #define PI (3.1415) Façon C++ : Ex : const double pi = ; La valeur est typée, ce qui permet des contrôles lors de la compilation. Mais ce n est pas pour autant une «pseudo- variable» : par exemple, elle n a pas forcément d emplacement en mémoire. 17

18 L-values Une Left-value (valeur gauche) est un élément de syntaxe C++ pouvant être écrit à gauche d un «=» d affectation. Exemple : une variable, une case de tableau mais bien d autres choses encore grâce à l énorme pouvoir d expression du C++. Une left-value se caractérise par : Un type précis (et donc une taille en mémoire) Une valeur mais... Surtout un emplacement de stockage en mémoire. 18

19 R-values Une Right-value (valeur droite) est un élément de syntaxe C++ pouvant être écrit à droite d un «=» d affectation. Exemple : une valeur, une constante, une variable, une expression, etc Une right-value se caractérise par : Un type précis (que vous devez savoir identifier) ; Une valeur. Une right-value n a pas forcement de zone de stockage en mémoire. Une affectation est encore une right-value ce qui donne le droit d écrire : i=j=10;! C est équivalent à i=(j=10); c'est-à-dire j=10; i=j;. Il existe des dizaines de façons de produire des right- et left- values Vous les découvrirez progressivement. 19

20 Opérateurs de post- et pré- incrémentation Vous croyez certainement connaître l instruction i++ mais savez vous qu' i++ est une right-value? On peut donc légalement écrire en C++ : int i=10; int j=i++; // équivalent à int j=i; i=i+1; C est une post-incrémentation : on augmente i après en avoir pris la valeur. Il existe aussi la pré-incrémentation : int i=10; int j=++i; // équivalent à i=i+1; int j=i; On augmente i avant d en prendre la valeur. Il existe aussi sur le même principe la pré- et la post-décrémentation : --i et i--. 20

21 Opérateur ternaire Ressemble au if( ) { } else { } mais joue un rôle de right-value et pas seulement d instruction. Syntaxe : (A?B:C) prend la valeur de l expression B si l expression A est vraie, et la valeur de l expression C sinon. Exemples : bool b= ; cout <<"b= b="<<(b? "true" : "false" )<<endl; // remplace l expression soit // par "true" soit par "false" string parite = (i%2==0? "pair" : "impair" impair" " ); // remplace l expression soit // par "pair" soit par "impair" int j = (i++==10? 2*i : 2*i-10 ); // si i++==10 alors j=2*i sinon j=2*i-10 21

22 La séquence de valeurs Elle constitue une série de right-values comptant pour une seule right-value : la dernière de la liste. Exemple : int i= 10,15,20; // i vaut 20. int j= i++,i; // i augmente et vaut 21, et j vaut 21! int k=++j,2; // j augmente et vaut 22, et k vaut 2. La séquence est rarement utilisée dans les cas ci-dessus! Elle est utilisée pour effectuer plusieurs opérations «en une seule fois» ; exemple classique (et lui très courant) : int i; double x; for(i=0, x=0.0 ; i<=10 ; i++, x+=1./10) { } // boucle sur i et x en parallèle! 22

23 Fonctions (1/2) Surcharge : Possibilité d avoir plusieurs fonctions ayant le même nom mais des signatures différentes : int plus1(int i) { return i+1; } double plus1(double i) { return i+1; } La signature d une fonction est le nombre et le type de chacun de ses arguments. Le prototype d une fonction est le nombre et le type de ses arguments (signature) et aussi de sa valeur de retour. Possibilité d avoir des valeurs par défaut pour les paramètres, qui peuvent alors être sous-entendus au moment de l appel. int mult(int a=2,int b=3) { return a*b; } mult(3,4) 12 mult(3) mult(3,3) 9 mult() mult(2,3) 6 23

24 Fonctions (2/2) On distingue la déclaration et la définition d une fonction (souvent dans deux fichiers différents). La déclaration affirme l existence de la fonction (son nom et son prototype). La déclaration int main() de f() permet d appeler f(). La définition de f() précise ce que f() fait, et permet au compilateur de la fabriquer réellement. mult.h : int mult(int a=2,int b=3); mult.cpp : #include <iostream> using namespace std; #include "mult.h" int mult(int a,int b) { return a*b; } main.cpp : #include <iostream> using namespace std; #include "mult.h" // suite à droite... int main() { cout << mult(1) << endl; return 0; } L'ordre d'inclusion est important : les <x> puis le using puis vos "x"! 24

25 Les références Déclarer une référence j sur une variable i permet de créer un nouveau nom j qui devient synonyme de i. La déclaration d une référence se fait en précisant le type de l objet référencé, puis le symbole &, et le nom de la variable référence qu on crée. Exemple : int i=10; // i est un entier valant 10 int & j = i; // j est une référence sur un entier, // cet entier est i. // A partir d ici j est synonyme de i, ainsi j=j+1; // est équivalent à i=i+1! Attention le = dans la déclaration de la référence n est pas réellement une affectation puisqu on ne copie pas la valeur de i. En fait, on affirme plutôt le lien entre i et j. En conséquence, int & k = 44; // est donc parfaitement illégal 25

26 Les pointeurs (1/3) : déclaration Un pointeur est une amélioration de la notion d adresse en mémoire (vue en cours d architecture des ordinateurs). Un pointeur c est l adresse en mémoire d un objet ainsi que le type exact de l objet qui se trouve à cette adresse. L idée est que si pi est un «pointeur sur un entier», alors connaître pi permet de trouver cet entier dans la mémoire (opération d indirection) et de le manipuler (addition, etc) puisqu on sait que c est un entier (et pas un réel, une chaîne de caractère ou tout autre objet ). int *pi; // pi est un pointeur sur un entier qui se // trouve ailleurs dans la mémoire. 26

27 Les pointeurs (2/3) : prise d adresse Supposons qu une variable entière i existe dans le programme, comment obtenir l adresse en mémoire de i? On utilise l opérateur & (opérateur de prise d adresse,, à ne pas confondre avec le & de la déclaration de référence!), ainsi &i signifie «adresse de i qui est entier». Puisque i est un entier, alors &i est une R-value du type «pointeur sur un entier». Cette opération permet d initialiser une variable pointeur : int i=10; int *pi=&i; // i est une variable entière contenant la // valeur 10 // pi est un pointeur sur un entier, et dont la // valeur est l adresse de i. Attention, il est illégal de prendre l'adresse d'autre chose qu'une L-Value (sinon pas de zone de stockage)! int *pi2=&44; // est illégal! int **ppi= &(&i); // est illégal! 27

28 Les pointeurs (3/3) : indirection A partir d un pointeur sur un entier contenant bien l adresse d un entier, comment manipuler cet entier? Il faut utiliser l opérateur * (opérateur( d indirection,, à ne pas confondre avec la multiplication) : int i=10; int *pi=&i; (*pi) = (*pi) + 1; // est équivalent à i = i+1 et donc // ici i vaut 11! Attention : même si les parenthèses ne sont pas obligatoires, elles sont souvent importantes car elles vous assureront de l'ordre de résolution des opérations (à moins bien sur que vous ne connaissiez sur le bout des doigts votre tableau de priorité des opérateurs, et que vous soyez certain de votre fait...). 28

29 Exercices Énoncer le type précis et quand c est possible les valeurs des variables suivantes : double a = 10.3; double *b = &a; double& c = a; double& d = *b; Les opérations suivantes sont elles légales ou non? Pourquoi? Et que signifient-elles? double **e=&b; (*(*e))++; d=3.14; b=0.69; *(b+1)=3.14; Contrôle de connaissance à la prochaine séance. 29

30 Passage de paramètre par valeur C est le passage simple : on crée une copie du paramètre qui existe tant qu on est dans la fonction : void incr(int i) { i++; cout<<"i="<<i<<endl; } int main() { int a=10; incr(a); cout<<"a="<<a<<endl; return 0; } Produit à l écran : i=11 a=10 Au moment de l appel de incr, la valeur de a est recopiée dans une nouvelle variable, nommée i, du même type int. Comme i disparaît à la fin de incr, comme n importe quelle autre variable locale, toute action faite sur i n affecte aucunement a. 30

31 Passage de paramètre par adresse On copie l adresse de l objet à utiliser. Cette adresse peut être utilisée pour modifier l objet grâce à l'indirection «*». void incr(int *pi) { (*pi)++; cout<<"(*pi)="<<(*pi)<<endl; } int main() { int a=10; incr(&a); cout<<"a="<<a<<endl; return 0; } Produit à l écran : (*pi)=11 a=11 On donne l adresse de a à la fonction incr qui peut ainsi retrouver la variable a dans la mémoire, et ensuite la modifier. 31

32 Passage de paramètre par référence On donne un nouveau nom à un objet déjà existant. Ce nouveau nom disparaît lorsque la fonction se termine. void incr(int& ra) { ra++; cout<<"ra="<<ra<<endl; } int main() { int a=10; incr(a); cout<<"a="<<a<<endl; return 0; } Produit à l écran : ra=11 a=11 Au moment de l appel à incr, le nom ra se rajoute et désigne dans incr la même variable que celle qui s appelle a dans main. 32

33 Astuce : Passage de paramètre par référence à un objet constant Si le paramètre ne doit pas être modifié et que le coût d une recopie pour un passage par valeur est trop important, on choisit un passage par référence sur un objet constant : void truc(const gros_objet& rgo) { = rgo ; // cela sera légal rgo = ; // mais cela sera interdit! } Il devient alors impossible de changer rgo mais on peut le consulter librement dans la fonction. 33

34 Portée (1/2) La portée d une variable : c est la zone du programme où elle est connue, et peut être utilisée. int i; void f(int a) { int j; } 34

35 Portée (2/2) Si des variables ont le même nom, les plus «profondes» sont cachées par celles les plus proches. Ainsi : int i=1; void f() { cout <<i<<endl; int i=2; cout <<i<<endl; if(true) { int i=3; } cout <<i<<endl; } int main() { cout <<i<<endl; f(); cout <<i<<endl; } 35

36 Tableaux : déclaration Comme en C et JAVA : int tab[10]; // 10 éléments entiers float tab2[]={1.2,3.14,2.0}; // 3 éléments initialisés char tab3[5]={ a, b, c }; // 5 éléments, 3 initialisés int tab4[2][4][6]; // tableau à 3 dimensions de 48(=2x4x6) Contrairement à JAVA pas de vérification des indices de tableaux à l exécution : ATTENTION! Important : Le nom du tableau est synonyme de l adresse du premier de ses éléments, c est-à-dire tab est synonyme de &tab[0].. C est donc un pointeur sur le type de chacune des cases du tableau. Les tableaux multidimensionnels sont des «tableaux de tableaux», et leur usage délicat (au niveau DUT) est à mon avis à éviter 36

37 Tableaux : en paramètre Passer un tableau à une fonction int somme(int a[], int n) { } int som=0; for(int i=0;i<n;i++) som += a[i]; return som; int main() { } int t[]={11,33,55,77}; cout <<somme(t,4)<<end; return 0; Pour les tableaux multidimensionnels, il faut préciser toutes les dimensions sauf la première : int chose(int a[][4][6], int n) 37

38 Allocation statique vs. dynamique L allocation standard des variables, dite allocation statique,, donne des variables créées sur la pile (stack), et ayant une durée de vie fixée par la portée. L allocation manuelle de mémoire pour de nouvelles variables, dite allocation dynamique,, permet de créer (avec l opérateur new) ) et de détruire (opérateur delete) ) les variables à volonté : l objet existe à partir du new et jusqu à une destruction explicite par delete.. De plus, la zone mémoire d allocation de telles variables, appelée le tas (heap), est différente, et permet généralement de stocker des données volumineuses contrairement à la pile. Attention c est une erreur d oublier de faire avant la fin du programme un delete pour chaque objet alloué dynamiquement avec new : vous devez détruire les objets vous-même à partir du moment où ils ne sont plus utiles. 38

39 Allocation d objets simples Alloc. statique { int i; // création de i i=10; // utilisation } // destruction de i Alloc. dynamique { int *pi; // création de pi pi = new int; //création de «i» (*pi)=10; // utilisation de «i» delete pi; // destruction de «i» } // destruction de pi Allocation : opérateur new type Libération : opérateur delete var 39

40 Allocation de tableaux Alloc. statique Alloc. dynamique { { int *t; // création de t int t[10]; // création t[1]=10; // utilisation t = new int[10]; // création t[1]=10; // utilisation delete [] t; // destruction } // destruction } // destruction Allocation : opérateur new type[taille taille] Libération : opérateur delete [] var 40

41 Les Classes : concept Les classes sont les éléments de base de la programmation objet en C++. Concept similaire à celui de JAVAJ : Dans une classe on réunit : Des données les données membres Des fonctions les fonctions membres,, ou les méthodes de la classe. Une class A apporte un nouveau type A ajouté aux types (pré)définis de base par C++. 41

42 Les classes : exemple de déclaration ratio.h : class Ratio { private: int num, den; // numérateur et dénominateur public: void affecter(int,int); double valeur_reelle(); void ecrire(); void inverser(); }; Rappel : la déclaration permet de connaître les types des choses constituant la classe, et ainsi de l utiliser. 42

43 Droits d accès aux membres Ils concernent aussi bien les fonctions membres que les données membres. Considérons une classe A : Accès public : on peut utiliser le membre de n importe où dans le programme. Accès private : seule une fonction membre de la même classe A peut utiliser ce membre ; il est invisible de l extérieur de A. Accès protected : ce membre peut être utilisé par une fonction de cette même classe A, et pas ailleurs dans le programme (ressemble donc à private), mais il peut en plus être utilisé par une classe B qui hérite de A. 43

44 ratio.cpp : Les classes : implémentation des fonctions membres #include "ratio.h" // <- permet de connaître la // déclaration de la classe // dans ratio.cpp void Ratio::affecter(int numerateur,int denominateur) { num=numerateur; den=denominateur; } double Ratio::valeur_reelle() { return ((double) num ) / den; } void Ratio::inverser() { int tmp=num; num=den; den=tmp; } void Ratio::ecrire() { cout << num << / << den ; } Rappel : la définition permet de fabriquer les choses constituant la classe. 44

45 Où placer les définitions des fonctions membres d une classe A? Le plus souvent, on les place dans le fichier «A.cpp», comme on vient de le voir. On utilise pour cela le «spécificateur de portée» :: afin de dire de quelle classe la fonction est membre. Plus rarement, et dans le cas de fonctions courtes, directement dans le «A.h», et sans le ::, un peu comme en JAVAJ AVA. Pourquoi cette «habitude»? On a plutôt intérêt à garder le fichier «A.h» le plus petit possible afin de rendre rapide sa compilation (lors de son inclusion dans les fichiers «.cpp»). De plus, une fois que le fichier «A.cpp» a été compilé en un «A.o», il n est pas nécessaire de le recompiler tant qu on ne modifie pas «A.cpp» ; on gagne ainsi du temps. Permet aussi de ne rendre publique que le «.h» tout en conservant un certain degré de secret dans un «.o» compilé livré au client. 45

46 Les classes : instances Une variable r créée avec ce type Ratio est appelée instance de la classe : main.cpp : #include "ratio.h" // <- permet de connaître main() // la déclaration de la classe { // dans main.cpp Ratio r; r.affecter(3,4); cout <<"r r = "; r.ecrire(); cout <<" = "<<r.valeur_reelle()<<endl valeur_reelle()<<endl; } Produit à l écran: r = 3/4 =

47 ratio.cpp : #include <iostream> using namespace std; #include "ratio.h" Compilation de programmes modulaires ratio.h : class Ratio { private: int num, den; public: void affecter(int,int); double valeur_reelle(); void ecrire(); void inverser(); }; #include <iostream> using namespace std; #include "ratio.h" main.cpp : void Ratio::affecter(int _num,int _den) { num=_num; den=_den; } double Ratio::valeur_reelle() { return ((double) num ) / den; } void Ratio::inverser() { int tmp=num; num=den; den=tmp; } void Ratio::ecrire() { cout << num << '/' << den ; } main() { Ratio r; r.affecter(3,4); cout <<"r r = "; r.ecrire(); cout <<" = "<<r.valeur_reelle()<<endl valeur_reelle()<<endl; } g++ -Wall -c ratio.cpp g++ -Wall c main.cpp g++ -Wall -o exemple.exe main.o ratio.o Produit ratio.o Produit main.o Produit exemple.exe 47

48 Les classes : déclaration de constructeurs En plus d utiliser affecter(),, on peut écrire un (voire plusieurs) constructeur(s) pour la classe. Un constructeur est chargé de créer une instance de la classe. ratio.h : class Ratio { private: int num, den; public: Ratio(int n,int d); Ratio(int n); }; Un constructeur porte toujours le même nom que la classe. Il peut avoir des paramètres, et éventuellement des valeurs par défaut. Il n a jamais de type de retour. La déclaration a lieu dans le «.h». 48

49 Les classes : définition de constructeurs Les définitions se font dans le «.cpp» comme pour les autres fonctions membres. ratio.cpp : Ratio(int n=0,int d=1); #include "ratio.h" Ratio::Ratio(int n,int d) { num = n; den = d; } Ratio::Ratio(int n) { num = n; den = 1; } Ou encore mieux, avec un seul constructeur profitant du mécanisme de valeur par défaut dans le fichier «.h» : ratio.cpp : ratio.h : #include "ratio.h" Ratio::Ratio(int n,int d) d { num = n; den = d; } 49

50 Les classes : instanciation 2 (le retour) On peut désormais utiliser nos constructeur et écrire plus simplement : main.cpp : Ratio r1(1,3); // r1 = 1/3 Ratio r2(4); // r2 = 4/1 = 4 Ratio r3; // r3 = 0/1 = 0 50

51 Les classes : liste d initialisation des données membres Un meilleur moyen d affecter des valeurs lors de la construction aux données membres de la classe est la liste d initialisation : ratio.cpp : #include "ratio.h" Ratio::Ratio(int n,int d) : num(n),den(d) // liste d initialisation {} Les constructeurs de num et den sont appelés au moment de la construction de Ratio,, avant le constructeur de Ratio.. Les listes d initialisation permettent d utiliser le constructeur de chaque donnée membre, et ainsi d éviter une affectation après coup. Important : l ordre d initialisation des membres doit correspondre à celui de leurs déclarations dans le fichier «.h». 51

52 Les classes : deux constructeurs particuliers Deux constructeurs sont toujours nécessaires dans toute nouvelle classe : Le constructeur par défaut Le constructeur de copie Ils sont tellement importants que si vous ne les écrivez pas, le compilateur tentera de le faire à votre place mais à moins de savoir exactement ce que vous faites il vaut mieux les écrire soi-même. 52

53 Les classes : le constructeur par défaut Par définition, le constructeur par défaut dune class Ratio est : Ratio::Ratio(); // Avec aucun paramètre! Rôle : il crée une instance non initialisée quand aucun autre constructeur fourni n est applicable : Ratio r1; Ratio tab_ratio[10]; A vous de choisir en fonction du besoin, si vous devez initialiser ou non certaines des données membres ou allouer de la mémoire, etc. En utilisant des valeurs par défaut pour tous les paramètres d'un constructeurs, on réalise en même temps le constructeur par défaut. JE VOUS OBLIGE A ECRIRE TOUJOURS CE CONSTRUCTEUR, ET JE VOUS INTERDIT DE COMPTER SUR CELUI FAIT AUTOMATIQUEMENT PAR LE COMPILATEUR : IL EST EN EFFET SOUVENT FAUX (TROP SIMPLISTE)... C EST DONC POUR VOUS EVITER DES FAUTES QUE JE RAJOUTE CETTE CONTRAINTE. 53

54 Les classes : le constructeur de copie Son rôle : fabriquer une nouvelle instance de la class Ratio qui est une copie identique trait pour trait à l'instance original qu'on lui donne en paramètre. Cette copie doit également être indépendante de l'original original. Constructeur déclenché par un passage de paramètre par valeur d'un Ratio : void f(ratio r) {...} // Crée une copie locale à f() Ratio r1(3,4); f(r1); ou par une copie explicite de la forme : Ratio r1(3,4); Ratio r2(r1); // r2 copie de r1 vaut 3/4 Le constructeur de copie pour une classe Ratio est de la forme : Ratio::Ratio(const Ratio& original)// reçoit une référence constante : num(original.num),den(original.den) // liste d'initialisation { } LA ENCORE, JE VOUS OBLIGE A ECRIRE SYSTEMATIQUEMENT CE CONSTRUCTEUR. EN EFFET, LE CONSTRUCTEUR DE COPIE EST UTILISE (ENTRE AUTRES) LORS DU PASSAGE DE PARAMETRE DE TYPE Ratio PAR VALEUR, DONC PRESQU AU MOINDRE APPEL DE FONCTION! 54

55 Constructeur de copie et destructeur : un exemple complet (1/3) La classe VecteurN a pour but de stocker un ensemble de n coordonnées réelles où n est un entier (strictement positif) qu'on précise au moment de l'exécution du programme. La classe VecteurN a besoin d'un tableau de coordonnées dont on ne connaît pas la taille au moment de la compilation car cela va dépendre de la dimension choisie par l'utilisateur. On est donc obligé de faire de l'allocation dynamique (c'est-à-dire utiliser new). class VecteurN { private: unsigned int nbcoord; double *coord; // tableau des coordonnées VecteurN(); // astuce!... public: VecteurN(unsigned int taille); VecteurN(const VecteurN& original); ~VecteurN(); }; Exceptionnellement, on mettra le constructeur par défaut (celui sans paramètre) en privé car on ne veut pas qu'on puisse créer un vecteur sans préciser sa dimension! 55

56 Constructeur de copie et destructeur : un exemple complet (2/3) #include "VecteurN.h" void saisie(vecteurn & va) // par référence : pas de copie! {... // va et v1 sont synonymes ici } // destruction du nom va void affiche(vecteurn vb) // passage par valeur : crée copie {... // grâce au constructeur de copie! } // destruction de la copie vb int main() { unsigned int taille; cin>>taille; // choix de l'utilisateur VecteurN v1(taille); // n=taille coordonnées saisie(v1); // pas de copie : v1 et va sont la même chose! affiche(v1); // vb est créée comme copie de v1 return 0; } // Destruction de v1 56

57 Constructeur de copie et destructeur : un exemple complet (3/3) VecteurN::VecteurN() { cerr<<"n'utilisez pas ce constructeur!"<<endl; exit(1);} VecteurN::VecteurN(unsigned int taille) : nbcoord(taille),coord(0) { coord = new double[nbcoord]; } // allocation du tableau VecteurN::VecteurN(const VecteurN& original) : nbcoord(original.nbcoord),coord(0) { coord = new double[nbcoord]; // allocation du tableau for(unsigned int i=0;i<nbcoord;i++) // puis coord[i]=original.coord[i]; // copie } VecteurN::~VecteurN() { delete [] coord; } // destruction du tableau 57

58 Les classes : destructeur Le destructeur est la méthode membre appelée lorsqu une instance de classe cesse d exister en mémoire. Son rôle est de libérer toutes les ressources qui ont été acquises lors de la construction (typiquement libérer la mémoire allouée dynamiquement pour la classe dans le constructeur). class Ratio { ~Ratio(); }; Même nom que la classe, précédé de «~» Aucun paramètre Et donc pas de surcharge possible Pas de valeur de retour 58

59 Les classes : fonctions d accès aux membres privés (1/2) Interdire la modification directe de num et den depuis l extérieur de la classe tout en autorisant leurs lecture? Solution : limiter l accès en donnant une fonction publique de lecture d un membre privé : ratio.h : class Ratio { private: int num,den; public: int numerateur() { return num; } int denominateur() { return den; } }; 59

60 Les classes : fonctions d accès aux membres privés (2/2) Comment éviter de modifier la classe par erreur durant le déroulement de la fonction d accès? Solution : considérer l instance de classe comme constante vis-à-vis de la fonction : ratio.h : class Ratio { private: int num,den; public: int numerateur() const; int denominateur() const; }; ratio.cpp : #include "ratio.h" int Ratio::numerateur() const { return num; } int Ratio::denominateur() const { return den; } 60

61 Pointeurs sur des fonctions (1/5) Permet de donner une fonction f1 en paramètre d une autre fonction f2 afin que f2 puisse appeler f1. Exemple : calcul approché de l intégrale de f(x) entre a et b double Integ(type_de_f type_de_f f,double a,double b) { méthode des rectangles utilisant f } Idée : les fonctions ont une adresse en mémoire, comme tous les autres objets C++, et elles ont aussi un type qui est constitué du nombre et du type de ses paramètres ainsi que du type de sa valeur de retour (le prototype). Ä Pointeur sur une fonction! 61

62 Déclarer un pointeur sur une fonction (2/5) Déclaration d une fonction : double f(double x); // Il existe une fonction f qui prend // un double et renvoie un double. Définition d un pointeur sur une fonction : double (*pf)(double x); // Il existe un pointeur pf sur une // fonction qui prend un double et renvoie un double. Remarques : pf est donc une variable et pas une fonction! l adresse d une fonction était déjà utilisée avec call en cours d Architecture des Ordinateurs. 62

63 Utilisation d un pointeur sur une fonction (3/5) Si pf contient un pointeur correctement initialisé vers une fonction existante, on peut appeler la fonction : double y = (*pf) (15.3); // appeler la fonction pointée par pf en lui passant en paramètre la valeur 15.3, et en stockant son résultat dans y. 63

64 Initialisation d un pointeur sur une fonction (4/5) Le nom d une fonction C++ est synonyme de son adresse, exactement comme pour les tableaux, donc ne pas utiliser l opérateur de prise d adresse &! Exemple : double carre(double x) { return x*x; } double (*pf)(double x); // déclaration de pf pf = carre; // affectation cout<<(*pf)(3); // utilisation : affiche 9. Attention : Il est impératif que les types correspondent! 64

65 Pointeur sur une fonction (5/5) : exemple double carre(double x) { return x*x; } void echant(double a,double b, int n, double (*pf)(double x) ) { for(int i=0;i<n;i++) { double x = a+(b-a)*i/(n-1); cout<<"f("<<x<<")="<<(*pf)(x)<<endl; } } echant(1,3,3,carre); echant(0,3.1415,10,sin); // fonction prédéfinie 65

66 Chaînes de caractères C (1/2) Rappel : le type caractère «char» permet le stockage d une valeur numérique entre 0 et 255 (un octet) représentant le code ASCII d une lettre. Une suite de caractères contigus en mémoire terminée par un caractère nul '\0' forme une chaîne de caractères donc un tableau de char. Deux possibilités pour manipuler une chaîne : Soit elle n existe pas encore, et on doit réserver de la mémoire pour elle : char str1[50]; // allocation statique char *str2=new char[50]; // alloc. dynamique Soit elle existe déjà et on peut la manipuler en connaissant uniquement son adresse : char *str3; // pointeur sur le premier char de la chaîne 66

67 Chaînes de caractères C (2/2) Lecture et écriture simplement avec >> et << : char str[ ]; cin>>str; // lit une suite de lettres jusqu à un // espace, et les place dans les cases // de str[], puis rajoute un '\0' final. cout<<str; // affiche le contenu de str[] à l écran // et s arrête grâce au '\0'. Remarque : impossible de savoir à l avance combien la personne va taper de lettres d où risque d erreur grave à cause de ceci. CEPENDANT, quand on sait : Bien penser à définir suffisamment de place pour la suite de lettres PLUS le zéro terminal. char str1[4]="pipo"; // incorrect : 4 cases char str2[5]="pipo"; // correct : 4+1 cases char str3[]="pipo"; // le plus simple! 67

68 Quelques fonctions prédéfinies utiles pour les chaînes C Rajouter #include <cstring> dans l en-tête du fichier string length : int strlen(char *s) Nombre de lettres de s, sans compter le '\0' final. string copy : char* strcpy(char *dest,char *source) Recopie les lettres contenues dans source vers dest (et renvoie l adresse du premier char de dest). renvoie l adresse du premier char de string compare : int strcmp(char *s1,char *s2) Renvoie 0 (faux) si s1 et s2 contiennent les mêmes lettres, un entier négatif si s1 est avant s2 dans l ordre alphabétique, et un entier positif sinon. 68

69 Quelques fonctions membres des instances prédéfinies cin et cout Ne pas oublier de mettre #include <iostream> dans l en-tête du fichier. bool cin.get(char& c) lit un seul caractère et le place dans c. char c; cin.get(c); // renvoie true si la lecture a réussi cin.getline(char *s, int nmax) lit une ligne de moins de (nmax-1) lettres, et la place dans s. Si la ligne est plus longue, ce qui dépasse est perdu (mais ne provoque pas de faute de mémoire). char str[80]; cin.getline(str,80); // lit toute une ligne et en place au maximum les 79 premiers char dans str. cout.put(c); écrit le caractère c. cin.putback(c); remet le caractère c dans cin. Il sera donc le prochain caractère lu par un cin.get(c); 69

70 Chaînes C++ : la classe string (1/2) Evite les problèmes de débordement de tableau et de '\0',, mais avec un coup de traitement (en temps et en mémoire) plus élevé. Rajouter #include <string> dans l en-tête de fichier. Déclaration triviale : string s1; // s1 contient 0 caractère string s2="new York"; // s2 contient 8 caractères string s3(60,'*'); // s3 contient 60 astérisques string s4=s3; // s4 contient 60 astérisques string s5(s2,4,2); // s5 contient «Yo» Lecture et écriture triviales : string s; cin >> s; cout << s; 70

71 Chaînes C++ : la classe string (2/2) Lecture d une ligne complète : string s; getline(cin,s); // lit une ligne et la place dans s Accès à un caractère d une chaîne comme avec les chaînes C : char c=s[3]; // le 4ème caractère de s va dans c Accès (en lecture seule) à la chaîne C contenue dans le string : const char *sc=s.c_str(); // sc est l adresse du début d un tableau de char qui ne peuvent être modifiés. Longueur de la chaine : string s="pipo"; int longueur = s.length(); // -> 4 Affectation, concaténation, et comparaison de chaînes directement entre instances avec les opérateurs standards (=,+,<,>,<=, ==, etc.) : if(s1==s2) s3=s1+"p"; 71

72 (Lecture depuis/écriture vers) un fichier sur disque Ne pas oublier de mettre #include <fstream> dans l en-tête du fichier. Ecriture : Déclarer une instance de la classe ofstream (output file stream) : ofstream ofile("fichier.txt"); S en servir à la place de cout : char *str="hello"; ofile << str << endl; Lecture : Déclarer une instance de la classe ifstream (input file stream) : ifstream ifile("fichier.txt"); S en servir à la place de cin pour lire (par exemple) des entiers et calculer leur somme : int som=0,i; while(ifile >> i) som+=i; 72

73 (Lecture depuis/écriture vers) un fichier sur disque : exemples Cette portion de programme crée un fichier de texte et écrit un compte à rebours dedans : { ofstream ofile("decompte.txt"); for(int i=10;i>0;i--) ofile << i << endl; ofile << "boum!" << endl; } // la fermeture du fichier se fait toute seule // lors de la destruction de ofile. Cette portion de programme réalise la recopie caractère par caractère d un fichier dans un autre : { char c; ifstream ifile("source.txt"); ofstream ofile("destination.txt"); while(ifile.get(c)) // tant qu on arrive à lire un char ofile.put(c); // on le copie dans ofile. } Il est important de refermer le fichier aussitôt que possible en provoquant la destruction de l instance de ifstream ou de ofstream. 73

74 Flux de chaînes : istringstream et ostringstream Compromis entre un string et un istream ou ostream : Lire et écrire dedans avec >> et << comme avec istream ou ostream, Obtenir un string C++ pour une manipulation ultérieure. Utiliser la méthode str() pour obtenir le string résultant. Exemple : #include <iostream> #include <sstream> // stringstream! #include <string> { string s("pipo"); int n=10; float pi=3.14; ostringstream oss; oss<<s<<','<<n<<','<<pi; cout <<"resultat : "<<oss.str()<<endl; } A l écran : resultat : pipo,10,

75 Opérateur «->» L opérateur «->» est strictement équivalent à une combinaison des opérateurs «*» et «.», et est bien plus simple à utiliser! class A { int i; // et tout ce qui est nécessaire à A A* f(); }; A* pa= ; (*pa).i = 10; (*(*pa).f()).i=11; A* pa= ; pa->i = 10; pa->f()->i=11; 75

76 Fonctions et/ou classes amies Problème : Comment faire pour qu une fonction f() et/ou une classe B puisse accéder aux données membres privées d une classe A? Solution : déclarer dans la classe A que f() et/ou B sont amies de A : class A { private: int i; // et tout ce qui est nécessaire à A friend class B; // B est autorisée. friend void f(a& a); // f() est autorisée aussi. }; class B { // tout ce qui appartient à B, et qui peut se servir des // données membres privées de A, comme si elle était A. }; void f(a& a) { a.i=10; } // on peut changer i, même dans f(). 76

77 Le pointeur spécial d instance : this Dans certaines conditions particulières, il est nécessaire de disposer d un moyen de désigner depuis une fonction membre, non pas les données membres, mais l instance elle-même de la classe sur laquelle la méthode membre est appelée. Le mot clé «this» permet de désigner l adresse de l instance sur laquelle la fonction membre a été appelée. class A { A* f(); }; A* A::f() { return this; } A a; A *pa; pa = a.f(); Cet exemple est une façon atrocement compliquée de faire pa = &a;!!! Remarque : this est donc d un type différent suivant les contextes où il est utilisé. 77

78 Surcharge d opérateurs But : Ecrire simplement des opérations sur des classes rajoutées au C++. Exemple : addition de deux rationnels. 45 opérations : + - * / = += -= *= /= [] () ==!= <= < >= > << >> etc. (cf. tableau des priorités). Presque toutes ces opérations peuvent être (re)définies sur les nouvelles classes afin d étendre les possibilités du langage C++. Seuls «::», «.» et «.*» ne peuvent être redéfinis. Le nom de la fonction à surcharger est operatorxx xx() où xx est le symbole d usage de l opérateur. La signature de l opérateur change suivant de quel opérateur il s agit. Il est impératif de la respecter. (Il faut par exemple chercher dans un manuel pour obtenir son type exact). Surcharge avec fonction membre ou fonction non-membre amie suivant les cas. 78

79 Surcharge d opérateurs : cas 1, par des fonctions membres class Ratio { // comme vue précédemment public: Ratio& operator=(const Ratio& source); // affectation r1 = r2; Ratio& operator*=(const Ratio& source); // produit r1*= r2; }; Ratio& Ratio::operator=(const Ratio& source) { num=source.num; den=source.den; return *this; } Ratio& Ratio::operator*=(const Ratio& source) { num*=source.num; den*=source.den; return *this; } Le typage de retour Ratio& et le «return *this;» permettent d utiliser ces expressions comme R-Value : Ratio r1( ),r2( ),r3( ); r1=r2=r3; // equivalent à r2=r3; r1=r2; Toujours «return *this;» à la fin des différents «opérateurs d'affectations», car il faut renvoyer une référence sur l'instance qu'on vient de modifier, c'est-à-dire (*this). 79

80 Surcharge d opérateurs : cas 2, par des fonctions non-membres amies class Ratio { // comme vue précédemment public: friend Ratio operator*(const Ratio& r1, const Ratio& r2); friend bool operator==(const Ratio& r1, const Ratio& r2); friend ostream& operator<<(ostream& os,const Ratio& r); friend istream& operator>>(istream& is,ratio& r); }; Ratio operator*(const Ratio& r1, const Ratio& r2) { Ratio r(r1.num*r2.num,r1.den*r2.den); return r; } bool operator==(const Ratio& r1, const Ratio& r2) { return (r1.num*r2.den) == (r2.num*r1.den); } ostream& operator<<(ostream& os,const Ratio& r) { os <<r.num<<'/'<<r.den; return os; } istream& operator>>(istream& is,ratio& r) { is>>r.num; is>>r.den; return is; } 80

81 Quelques signatures d opérateurs usuels A& A::operator=(const A&); A& A::operator+=(const A&); // idem pour -= *= /= etc. friend bool operator==(const A&,const A&); // idem pour <!= etc. friend A operator+(const A&,const A&); // idem pour - * / etc. friend ostream& operator<<(ostream& os,const A&); friend istream& operator>>(istream& is,a&); A A::operator++(); // pré-incrémentation (idem pour --) A A::operator++(int); // post-incrémentation (idem pour -) // ATTENTION : ici le int ne sert à rien,, à part à // différencier les deux fonctions! C est un des // (relativement rares) cas de mauvaise conception du // langage C++. Ici «A::» marque qu'il s'agit d'une fonction membre de la classe A, et «friend» que c'est une fonction externe amie de la classe A. Attention : définition OBLIGATOIRE de l'operator= pour les mêmes raisons vues pour le constructeur par défaut et le constructeur de copie : il serait créé automatiquement sinon! 81

82 Cas particulier de l'operator[] class VecteurN { private: unsigned int nbcoord; double coord[ ]; // pour pouvoir renvoyer le i-ème élément de coord public: double& operator[](int); // modification (L-value) double operator[](int) const; // consultation (R-value) }; VecteurN v(3); // 3 coordonnées pour ce vecteur v[1]=3.15; // utilise le 1er operator[] : modifie b double c2 = v[2] // utilise le 2ème operator[] : ne modifie pas b Deux surcharges complémentaires : Soit l'accès en lecture et écriture du membre n i de B, mais sans garantie de constance du B ; Soit l'accès en lecture seule du membre n i de B, mais avec la garantie de constance du B. 82

83 Lecture depuis un fichier grâce à >> La lecture d une série d objets pour lequel un opérateur >> a été défini se fait très simplement : #include <fstream> #include "VecteurN.h" VecteurN tab_vec[suffisament_grand suffisament_grand]; unsigned int i=0; { // Ce bloc sert à rendre la durée de vie de ifs la plus // courte possible, afin de libérer le fichier le plus // vite possible! ifstream ifs("fichier.txt"); while(ifs>>tab_vec[i]) i++; } // fin de vie d ifs, et fermeture du fichier 83

84 Fonctions inline Permet de mettre une «fonction» dans la définition de classe (le.h), tout en demandant au compilateur de substituer les appels à cette fonction par son code. N a de sens que si la fonction est TRES courte/rapide! Usage classique : les fonctions accesseurs, de façon à garder la propriété de «lecture seule» tout en économisant le coût d appel de la fonction : Truc.h : class Truc { int i; public: inline int valeur_i() { return i; } }; Vous écrivez : Truc t; int j = t.valeur_i();... qui signifie : Truc t; int j = t.i; 84

85 Spécificateur extern (1/2) On sais que les variables globales sont communes à tout un programme. Idem, pour les fonctions Mais, elles ne sont connues que dans les fichiers «.cpp» dans lesquelles elles ont été définies et/ou déclarées. Problème : Comment faire connaître dans un «.cpp» l existence d une variable globale définie dans un autre fichier «.cpp»? Réponse : Il suffit de rajouter une déclaration (et PAS une définition) de cette variable dans l en-tête du deuxième fichier «.cpp». En général, on écrit une bonne fois pour toute ces déclarations dans un fichier «.h» que l ont peut ainsi facilement inclure dans l en-tête. Les déclarations de fonctions sont juste constituées des prototypes de fonctions (leur première ligne de définition). Les déclarations de variables sont constituées de leur définition précédée du mot clé extern qui permet de ne pas créer la variable, mais juste dire que cet objet existe déjà ailleurs. 85

86 Spécificateur extern (2/2) : exemple On veut créer deux variables (var1( et var2) ) et deux fonctions (fct1 et fct2) ) utilisables n importe où dans les fichiers bout1.cpp et bout2.cpp. variables.h : extern int var1; extern double var2; int fct1(int a); double fct2(double b); // Déclaration de var1 // Déclaration de var2 // Déclaration de fct1 // Déclaration de fct2 bout1.cpp : bout2.cpp : #include "variables.h" int var1=10; // Définition de var1 int fct1(int a) // Définition de fct1 { var1+=a; var2+=var1; return var1; } #include "variables.h" double var2=11; // Définition de var2 double fct2(double b) // Définition de fct2 { var2+=2.3*var2; return var2; } 86

87 Spécificateur static Malgré le nom, aucun rapport avec l allocation statique! Plusieurs notions suivant le contexte d application. Peut s appliquer à une variable, à une fonction, à une donnée membre, ou encore à une fonction membre. 87

88 static en dehors d une classe ou d une fonction truc.cpp : static int a=10; static int f() { } machin.cpp : int main() { a=10; // impossible! int i=f(); // impossible! } Limiter la visibilité d un identificateur au seul fichier où il est défini. Dans l exemple, la variable globale a et la fonction f() ne peuvent être utilisés que dans le fichier truc.cpp. Même avec extern, impossible d'accéder à a ou à f! Il devient possible de créer dans ce fichier une autre variable/fonction globale ayant le même nom! 88

89 static dans une fonction (membre ou non) unsigned compte() { static unsigned int n=0; return n++; } int main() { cout<<compte()<<endl; // O cout<<compte()<<endl; // 1 cout<<compte()<<endl; // 2 } Une des utilisations les plus fréquentes. La valeur persiste entre deux appels à la fonction. L initialisation de la variable est donc très importante! La variable se comporte un peu comme une «variable globale qui ne serait visible que dans sa fonction». 89

90 Donnée static dans une classe A.h : class A { static unsigned int compte; public: A(); unsigned int combien(); }; A.cpp : unsigned int A::compte=0; A::A() { ++compte; } unsigned int A::combien() { return compte; } int main() { A a1,a2,a3; cout<<a1.combien(); // 3! } Une autre utilisation fréquente La donnée est attachée à la classe elle-même et pas aux instances : il n y a qu un seul «compte» pour toutes les instances de A! Importance de l initialisation, qui se fait dans le.cpp grâce au spécificateur de portée! 90

91 Fonction static dans une classe A.h : class A { public: static void reset(unsigned int n=0); }; A.cpp : void A::reset(unsigned int n) { compte=n; } int main() { A a1,a2,a3; cout<<a1.combien(); // 3! A::reset(); A a4; cout<<a1.combien(); // 1! } Une utilisation peu fréquente. La fonction, bien que faisant partie de la classe, ne peut pas être appelée sur une instance de cette classe. Elle est appelée globalement, avec le spécificateur de portée. Attention : ne pas mettre «static» dans le.cpp! 91

92 Mot clé typedef Mot clé provenant du langage C Permet de donner un nouveau nom à un type existant. Syntaxe : typedef <type> > <nom< nom>; Exemples : typedef int entier; entier i=10; typedef entier *pointeur_sur_entier; pointeur_sur_entier pi=&i; // attention, plus d étoile maintenant! typedef entier tab1oentiers[10]; tab10entiers tab={1,2,3, }; typedef double (*fct)(double); fct f1=sin,f2=fabs; // f1 est l adresse de sinus, f2 de valeur absolue typedef fct (*f)(entier,fct []); // Compliqué! f est l adresse d une // fonction qui prend un entier et un tableau de pointeur sur des // fonctions de R dans R, et qui renvoie l adresse d une fonction de // R dans R. 92

93 Arguments de la ligne de commande Lors du lancement d un programme, il est courant de lui donner des paramètres. Exemple : la ligne de commande «g++ -Wall -c pipo.cpp» contient elle-même 3 paramètres. Un programme C ou C++ reçoit ses paramètres sous forme de chaînes C en paramètre de la fonction main. int argc est le nombre d arguments, char *argv[] est un tableau de chaînes C (c est-à-dire des char*,, l adresse de la première lettre de chaque mot). Remarque : argv[0] désigne le nom du programme. Le programme suivant écrit à l écran le nom du programme suivi des paramètres qui lui ont été donnés : #include <iostream> using namespace std; int main(int argc,char *argv[]) { for(int i=0;i<=argc;i++) cout<<"argv["<<i<<"]="<<argv[i]<<endl; return 0; } 93

94 Composition Composition (ou encapsulation ou agrégation) : utiliser des instances d une ou plusieurs classes déjà définies comme données membres lors de la définition d une nouvelle classe. class A { }; class B { string nom; // avec une // classe prédéfinie }; class C { A a1,a2; // avec des classes B* pb; // introduites par // l utilisateur }; L idée est : «un C est composé de deux A et d un pointeur sur un B». Exemple : Une personne a un nom et un prénom qui sont des strings. s. 94

95 Héritage L héritage (ou spécialisation, ou dérivation) : ajouter des propriétés à une classe existante pour en obtenir une nouvelle plus précise. class A { public: void f(); }; class B : public A { public: void g(); }; A a; B b; a.f(); // legal b.g(); // legal b.f(); // legal a.g(); // illegal : a n a pas de g(). L idée est : «un B est un A avec des choses en plus». Exemple : Un étudiant est une personne, et a donc un nom et un prénom. De plus, il a un numéro INE. 95

96 Propriété issue de l héritage : conversions automatiques Si B hérite de A, alors toutes les instances de B sont aussi des instances de A, et il est donc possible de faire : A a; B b; a=b; Propriété conservée lorsqu on utilise des pointeurs : A *pa; B *pb= ; pa=pb; car pointer sur un B c est avant tout pointer sur un A. Evidement, l inverse n est pas vrai : A a; B b; b=a; // ERREUR! Pareil pour les pointeurs : A *pa= ; B *pb; pb=pa; // ERREUR! car pointer sur un A n est pas pointer sur un B. 96

97 Droits d accès aux membres 3 classes de membres : public, protected et private. Cas de l héritage public. class A { public: int a; void fa(); private: int c; protected: int b; }; class B : public A { public: void fb(); }; a est visible depuis n importe où. c n est visible que dans A:: et donc pas dans B:: ni dans ::,, c est-à-dire c est utilisable dans fa() mais pas dans fb() ni dans main(). b est intermédiaire,, visible dans A:: et dans B:: mais pas dans ::,, c est-à-dire b est utilisable dans fa(),, dans fb(),, mais pas dans main(). 97