Vous êtes sur la page 1sur 81

Le langage C++

Plan
Rappel de quelques aspects du langage C
Apports de C++ Les fonctions

Les classes

Rappel
Considrons ce petit programme en C:

#include <stdio.h> #define TVA 18.6 void main() { float HT,TTC; puts ("veuillez entrer le prix H.T."); scanf("%f",&HT); TTC=HT*(1+(TVA/100)); printf("prix T.T.C. %f\n",TTC); }
3

Rappel
Des directives du pr processeur (commenant par #) #include : Inclus le fichier dclarant les fonctions standard d'entres/sorties (en anglais STanDard In/Out), qui feront le lien entre le programme et la console (clavier/cran). Dans cet exemple il s'agit de puts, scanf et printf. 1. #define : Dfinit une constante. Chaque fois que le compilateur rencontrera, dans sa traduction de la suite du fichier en langage machine, le mot TVA, ces trois lettres seront remplaces par le nombre 18.6. Ces transformation sont faites dans une premire phase (appele pr compilation), o l'on ne fait que du "traitement de texte", c'est--dire des remplacements d'un texte par un autre sans chercher en comprendre la signification.
1. 2.
4

Rappel
Une entte de fonction. Dans ce cas, on ne possde qu'une seule fonction, la fonction principale (main function). Cette ligne est obligatoire en C, elle dfinit le "point d'entre" du programme, c'est--dire l'endroit o dbutera l'excution du programme. 5. Un "bloc d'instructions", dlimit par des accolades {}, et comportant des dclarations de variables.
4.

Rappel
Dfinition de type: Linstruction typedef

Linstruction typedef permet de renommer des types de donnes:


Typedef int INTEGER; ainsi on peut utiliser INTEGER

au lieu de int. Typedef char *ADRESSE; ADRESSE voudra dire un pointeur sur char. Typedef struct etudiant STUDENT; Typedef int *TP[2]; TP x; x est un tableau de deux pointeurs sur int.

Typedef ne dfinit pas de nouveau types de donnes. Elle permet lutilisation de nouveaux mnmoniques pour dsigner des dfinitions dj tablies. Elle rend le programme plus lisible.
6

Rappel
Conversion automatique ou le casting:

On peut imposer une conversion en prfixant lopration dun type entour de parenthses: Exemple: x1=(float)i/j; x2=i/j; x1 et x2 ne reoivent pas le mme rsultat. Les variables locales et les paramtres qui sont aussi considrs comme des variables locales, sont crs lentre de la fonction sont dtruites ds quon quitte la fonction. Les variables cres par malloc ne seront pas dtruites la fin de la fonction.
7

Rappel
Les pointeurs de type void:

Il est possible de dclarer des pointeurs avec des types indtermins. Un tel pointeur peut recevoir une adresse mais ne peut pas faire lobjet doprations: *,++ ou sauf si le type est spcifi par un casting.
Exemple:

Main() { void *p; int l=2, float f=1.5 char buf [ ]=ABC; float x [ ]={1.2,3.4,5.6}; p=&i; //pas de problme P=buf; *p=3; //erreur car *p na pas de type ((char*)p)++; *(int*)p=3; //pas de problme buf P=x; p=&f; ((float=)p)++; *(float*)p+=1; //f prend la valeur 2.5 F=*(float*)p; (*(float*)p)++; //f prend la valeur 3.5 }
8

//p pointe sur B de

// p pointe sur 1.2 // p pointe surn3.4 //f contient 3.3

Rappel
Fonction qui renvoie un pointeur:

Il est possible de concevoir une fonction qui retourne un pointeur sur une variable mais il faut faire trs attention. Car si la variable dont on retourne ladresse est une variable locale, elle va tre dtruite la fin de la fonction et le programme appelant reoit une adresse dont la variable point nexiste plus. Si la variable point, parce quelle est globale par exemple, continue exister il ny a pas de problme.
9

Rappel
Exemple de fonction fausse:

int *somme(int a, int b) { int x; x=a+b; return &n; }

10

Rappel
Pointeur sur fonction: passage dune fonction en

argument: Il est utile de concevoir une fonction admettant un paramtre qui indique une rfrence une fonction. Ainsi lors de lappel, on peut spcifier comme argument telle ou telle fonction. Or, on sait quon peut faire rfrence une fonction en dclarant un pointeur sur une fonction et en y plaant ladresse dbut de la fonction. Un pointeur sur une fonction se dclare de la manire suivante: int (*p)(int, float); p est pointeur sur une fonction qui retourne un entier et qui a deux paramtres int et float.
11

Rappel
Exemple dapplication:

Le tri par partition appel tri rapide ou quisk sort est bien connu en algorithme et on le trouve dans toute bibliothque fournie avec le compilateur C. Le problme cest que, lors de lcriture de la fonction, on ne connait ni le type des donnes na la mnire de les comparer entre eux. Le prototype de quicksort est donc comme suit: void qsort (void *base, unisgned int n, unsigned int taille, int (*fcmp)(const void*, const void*)); //fcmp est un pointeur sur la fonction de comparaison
12

Rappel
Ainsi la fonction qsort sapplique nimporte quel type de

donnes(int, float, char, chaine de caractres, structure,) Le programme appelant doit crire et spcifier la fonction de comparaison de deux lments qui renvoie une valeur entire 0,1,-1. Exemple: tri dun tableau dentiers #include <stdlib.h> int compare (const void*, const void*); Main() { int tab [ ]={6,-8,12,3,5,14,26,1,3,-51}; qsort(tab, 10, sizeof(int), compare); }

13

Rappel
Int compare (const void*a, const void*b)

{ return *(int*)a-*(int*)b; } Exemple: tri de nom partir dun tableau de pointeurs #include<stdlib.h> #include<string.h> Int compare (const void*, const void*); Main() { char *tab[ ]={ALI, MOHAMED, SALAH, AZIZ}; qsort(tab,4, sizeof(char*), compare); }
14

Rappel
int compare(const void *a, const void *b)

{ Return strcmp(*(char**)a, *(char**)b); }

15

Apports du C++
Les entres sorties en langage C seffectuent par

les fonctions scanf et printf de la librairie stdio.h En C++, on peut continuer utiliser ces fonctions. Le C++ introduit de nouvelles fonctions bases sur la notions de flux (ou flot ou stream).
Cout
Cin cerr

16

Apports de C++
#include<iostream.h> Void main()

int i=123; float f=123.45;


char ch [80]=Bonjour\n, rep; cout<<i=<<i<<f=<<f<<ch=<<ch; cout<<i=?; cin>>i; //lecture dun entier cout<<f=?; cin>>f; //lecture dun rel cout<<rep=?; cin>>rep; //lecture dun caractre cout<<ch=?; cin>>ch; //lecture du premier mot dune chaine cout<<ch=<<ch; //cest bien le premier mot..

17

Apports du C++
Rsultat de lexcution:

i=123, f=123.45 ch=Bonjour i=? 12 f=? 3.6 rep=? Y ch=? C++ is easy ch=c++

18

Apports du C++
Loprateur (surcharg) << permet denvoyer des

valeurs dans un flot de sortie Loprateur >> permet dextraire des valeurs dun flot dentre.
Tout comme la fonction scanf. Notons labsence de loprateur & dans la syntaxe de

cin. Ce dernier na pas besoin de connaitre ladresse de la variable lire. Les constantes: Le mot rserv const permet de dfinir une constante. Lobjet ainsi spcifi ne pourra pas tre modifi durant toute sa dure de vie.
19

Apports de C++
Les manipulateurs:

Les manipulateurs sont des lments qui modifient la faon dont les lments sont lus ou crits dans le flot.

Les principaux manipulateurs sont: dec lecture/criture dun entier en dcimal Oct lecture/criture dun entier en octal Hex lecture/criture dun entier en hxadcimal Endl insrtion dun saut de ligne et vide les tampons
20

Apports de C++
setw(int n): Affichage de n caractres setprecicion(int n): Affichage de la valeur avec n chiffre avec eventuellement un arrondi de la valeur setfill(char): Dfinit le caractre de remplissage flush et vide les tampons aprs criture.

21

Apports de C++
Dfinition des variables:

En C++, vous pouvez dclarer les variables ou les fonctions nimporte ou dans le code. La porte de telles variables va de lendroit de la dclaration jusqu la fin du bloc courant. Ceci permet de dfinir une variable aussi ^prs que possible de son utilisation afin damliorer la lisibilit.

22

Apport de C++
Exemple:

#include <stdio.h> Void main() { int i=0; i++; int j=1; j++; int somme(int n1, int n2); printf(%d+%d=%d\n, i, j, somme(i,j)); }
23

Apports de C++
Constantes et pointeurs:

Il faut distinguer ce qui est point du pointeur lui-

mme. La donne point est constante: Const char *ptr1= QWERTY ; Ptr1++; //autoris *ptr1=A ; // Error: assignment to const type

24

Apports de C++
Le pointeur est constant:

char *const ptr2= QWERTY ; ptr2++; Error: increment of const type *ptr2=A; //autoris Le pointeur et la donne sont constants: const char * const ptr3= QWERTY ; ptr3++; //error: increment of const type *ptr3=A; //error: assignment to const type

25

Apports de C++
En plus des variables normales et des pointeurs,

le C++ offre les variables rfrences. Une variable rfrence permet de crer une variable qui est un synonyme dautre. Ds lors, une modification de lune affectera le contenu de lautre. Int i Int &ir=i; //ir est une rfrence i Int *ptr;

26

Apports de C++
Une variable rfrence doit tre initialise et le

type de lobjet initial doit tre le mme que lobjet rfrence. Interet: passage des paramtres par rfrence qui offre lavantage de ne pas trainer le caractre *.

27

Apports de C++
Allocation mmoire: Le C++ met la disposition du programmeur deux oprateurs new et delete pour remplacer respectivement malloc et free. A chaque instruction new doit correspondre une instruction delete. Il est important de librer lespace mmoire ds que celui-ci nest plus ncessaire. La mmoire alloue en cours de programme sera libre automatiquement la fin du programme.
28

Les fonctions en C++


Passage par rfrence:

En plus du passage par valeur et du passage de pointeur (utilis pour avoir le passage par adresse), le C++ dfinit le passage par rfrence. Lorsque lon passe une fonction un paramtre par rfrence, cette fonction reoit un synonyme du paramtre rel. Toute modification du paramtre rfrence est percute sur le paramtre rel.
Lappel se fait de manire trs simple
29

Les fonctions
Valeur par dfaut des paramtres

Certains arguments dune fonction peuvent prendre souvent la mme valeur. C++ permet de dclarer des valeurs par dfaut dans le prototype de la fonction. Les paramtres par dfaut sont obligatoirement les derniers de la liste. Ils ne sont dclars que dans le prototype de la fonction et pas dans sa dfinition.

30

Les fonctions
Exemple:

Void print (long valeur, int base=10); Void main() { print (16); //Affiche 16 (16 en base 10) print(16,2); //Affiche 10000 (16 en base 2) } Void print (long valeur, int base) { cout << ltostr(valeur,base) << endl; }
31

Les fonctions
Fonction inline:

Normalement le code dune fonction est gnr une seule fois mme si elle est appel plusieurs fois. Le qualitatif inline permet de gnrer le code de la fonction lendroit de chaque appel. Gagner un peu de temps ncessaire la prparation de la liste des paramtres et au changement de contexte. Perte despace mmoire. Il faut donc rserver cette possibilit aux fonctions trs courtes et trs sollicites.
32

Les fonctions
Exemple:

include <iostream.h> inline int carre(int n); // dclaration Void main() { cout <<carre(10)<< endl; } //inline facultatif la dfinition, mais prfrable Inline int carre (int n) { Return n*n; }
33

Les fonctions
Une fonction se dfinit par:

Son nom
Sa liste type de paramtres formels Le type de la valeur quelle retourne

Les deux premiers critres sont discriminants. Signature de la fonction. Donner un mme nom des fonctions qui ont des paramtres diffrents.

34

Les fonctions
Exemple:

int somme(int n1, int n2) { return n1+n2;} Int somme (int n1, int n2, int n3) { return n1+n2+n3; } Int somme (double n1, double n2) { return n1+n2; } Void main() { cout<<1+2=<<somme(1,2)<<endl; cout<<1+2+3=<<somme(1,2,3)<<endl; Cout<<1.2+1.3=<< somme(1.2,1.3)<<endl; }
35

Les fonctions
Autre exemples: int somme1 (int n1, int n2) {return n1+n2;} int somme1(const n1, const n2) {return n1+n2;} //Erreur int somme2(int n1, int n2) {return n1+n2;} int somme2(int &n1, int &n2) {return n1+n2;} // Erreur int somme3(int n1, int n2) {return n1+n2;} double somme3(int n1, int n2) {return n1+n2;} .. Erreur
36

Les fonctions
Retour dune rfrence:

Une fonction peut retourner une valeur par rfrence On peut agir lextrieur de cette fonction sur cette valeur de retour.

37

Les classes
Objectif:

Concevoir des programmes sous forme dobjets qui changent des messages au lieu davoir une liste de sous programme qui se partagent des donnes. Chaque objet aura ses propres donnes et ses propres programmes spcialiss dans la manipulation de ses donnes. Les donnes seront inaccessible au monde extrieur qui ne connait lobjet que par lintermdiaire dun certain nombre de point daccs. Cest le concept dencapsulation.
38

Les classes

39

Les classes
Un objet sera caractris par plusieurs

notions:
Les attributs: qui sont les donnes de lobjet. Les mthodes: appeles aussi fonctions

membres; elles caractrisent le comportement de lobjet cest--dire lensemble des actions que lobjet peut raliser Lidentit: chaque objet doit avoir une identit qui permet de le distinguer des autres objets.
40

Les classes
La structure dun objet fera lobjet dune

dclaration au sein de se qui est appel classe . Plusieurs objets peuvent avoir la mme structure donc issue dune mme classe

41

Les classes
exemple, la structure dune voiture(moteur, roues, cabine) fera lobjet dune classe alors quune mercedes-2000 est un objet de type classe. Les avantages dune telle conception sont: Protection des donnes Meilleure structuration du programme Maintenance plus facile
Par

42

Les classes
Dfinition dune classe:

La classe dcrit le modle structurel dun objet. Elle est compos de: Ensemble des attributs (ou champs ou donnes membres) dcrivant sa structure Ensemble des oprations (ou mthodes ou fonctions membres) qui lui sont applicables. Une classe en C++ est une structurequi contient: Des fonctions membres Des donnes membres
43

Les classes
Les mots rservs public et private dlimitent les sections

visibles par lapplication. Exemple: Class Avion { public: //fonctions membres publiques void init(char [], char*,float); void affiche(); private: //membres privse char immatriculation[6], *type; //donnes membres prives float poids; void erreur(char *message); //fonction membre prive }; //noubliez pas ce ; aprs laccolade

44

Les classes
Droits daccs:

Lencapsulation consiste marquer laccs certains attributs et mthodes dune classe . Elle est ralise laide des mots cls: private: les membres privs ne sont accessibles que par les fonctions membres de la classe. La partie prive est aussi appele ralisation. protected: les membres protg sont comme les membres privs. Mais elles sont aussi accessibles par les fonctions membres public

45

Les classes
public:

les membres publics sont accessibles par tous. La partie publique est appele interface. private, protected et public plusieurs fois dans la classe. Le droit ne change nouveau droit nest pas

Les mots rservs peuvent figurer dclarations de la pas tant quun spcifi.

46

Types de classe:

Les deux structures struct et union introduites par le langage C et la structure classe introduite par le C++ sont considres comme des classes. Mais cest la troisime qui est la plus utilise. Struct Class1{/*..*/} Tous les membre sont par dfaut daccs public, le contrle daccs est modifiable. Cette structure est conserve pour pouvoir compiler des programmes crits en C.
47

Les classes
Exemple:

struct Date { //mthodes publiques(par dfauts) void set_date(int, int, int); void next_date(); //autres mthodes.. private: //donnes privs; int _jour, _mois, _an; }
48

Les classes
Union class2 {/*..*/}

tous les membres sont daccs public par dfaut, le contrle daccs est modifiable Class Class3 {/**/} Tous les membres sont daccs private (par dfaut). Le contrle daccs est modifiable. Cest cette dernire forme qui est utilise en programmation objet C++ pour dfinir des classes.

49

Les classes
Dfinition des fonctions membres:

En gnral, la dclaration dune classe contient simplement les prototypes des fonctions membres de la classe. Class Avion { public: void init(char[], char*, float ); //prototype des fonctions membres void affiche(); pivate: char _immatriculation[6], *_type; float _poids; Void _erreur(char *message); };
50

Les classes
Les fonctions membres sont dfinies dans un

module spar ou plus loin dans le code source. Syntaxe: Type_valeur_retourne Classe::nom_fonction(paramtres_formels) { // corps de la fonction }

51

Les classes
Exemple:

Exemple de dfinition de mthode de la classe Avion : void Avion::init(char m[], char *t, float p) { strcpy(_immatriculation, m); _type = new char [strlen(t)+1]; strcpy(_type, t); _poids = p; } void Avion::affiche() { cout << _immatriculation << " " << _type; cout << " " << _poids << endl; }
52

Les classes
La dfinition de la mthode peut avoir lieu

lintrieur de la dclaration de la classe. Dans ce cas, ces fonctions sont automatiquement traites par le compilateur comme tant des fonctions inline. Une fonction membre dfinie lextrieur de la classe peut tre aussi qualifie explicitement de fonction inline.

53

Les classes
Exemple: class Nombre { public : void setnbre(int n) { nbre = n; } // fonction inline int getnbre() { return nbre; } // fonction inline void affiche(); private : nt nbre; }; inline void Nombre::affiche() { // fonction inline cout << "Nombre = " << nbre << endl; } Rappel : La visibilit dune fonction inline est restreinte au module seul dans la quelle elle est dfinie.

54

Les classes
Instanciation dune classe :

De faon similaire une struct ou une union, le nom de la classe reprsente un nouveau type de donne. On peut donc dfinir des variables de ce nouveau type; on dit alors que vous crez des objets ou des instances de cette classe. Exemple : Avion av1; // une instance simple (statique) Avion *av2; // un pointeur (non initialis) Avion compagnie[10]; // un tableau dinstances av2 = new Avion; // cration (dynamique) dune instance
55

Les classes
Utilisation des objets:

Aprs avoir cr une instance (de faon statique ou dynamique) on peut accder aux attributs et mthodes de la classe. Cet accs se fait comme pour les structures laide de loprateur . (point) ou -> (tiret suprieur).
Exemple :

av1.init("FGBCD", "TB20", 1.47); av2->init("FGDEF", "ATR 42", 80.0); compagnie[0].init("FEFGH","A320", 150.0); av1.affiche(); av2->affiche(); compagnie[0].affiche(); av1.poids = 0; // erreur, poids est un membre priv

56

Les classes
Fonctions constantes :

Certaines mthodes dune classe ne doivent (ou ne peuvent) pas modifier les valeurs des donnes membres de la classe, ni retourner une rfrence non constante ou un pointeur non constant dune donne membre. On dit que ce sont des fonctions membres constantes. Ce type de dclaration renforce les contrles effectus par le compilateur et permet donc une programmation plus sre sans cot dexcution.
57

Les classes

Exemple : class Nombre { public : void setnbre(int n) { nbre = n; } // mthodes constantes int getnbre() const { return nbre; } void affiche() const; private : int nbre; }; inline void Nombre::affiche() const { cout << "Nombre = " << nbre << endl; }

Une fonction membre const peut tre appele sur des objets constants ou pas, alors quune fonction membre non constante ne peut tre appele que sur des objets non constants.

58

Les classes
Surcharge dune mthode par une mthode constante :

Une mthode dclare comme constante permet de surcharger une mthode non constante avec le mme nombre de paramtres du mme type. Exemple : class String { public : void init(char *ch = ""); // etc ... char & nieme(int n); // (1) char nieme(int n) const; // (2) // etc... private : char *_str; };

59

Les classes
Sil ny a pas lattribut const dans la deuxime mthode, le

compilateur gnre une erreur ("String::nieme() cannot be redeclared in class"). Cette faon de faire permet dappliquer la deuxime mthode nieme() des objets constants et la premire mthode nieme() des objets variables :
void main() { String ch1; ch1.init("toto"); const String ch2; ch2.init("coco"); cout << ch1.nieme(1); // appel de la mthode (1) cout << ch2.nieme(1); // appel de la mthode (2) }

60

Les classes
Constructeurs et destructeurs :

Les donnes membres dune classe ne peuvent pas tre initialises; il faut donc prvoir une mthode dinitialisation de celles-ci (voir la mthode init de lexemple pcdent). Si lon oublie dappeler cette fonction dinitialisation, le reste na plus de sens et il se produira trs certainement des surprises facheuses dans la suite de lexcution. De mme, aprs avoir fini dutiliser lobjet, il est bon de prvoir une mthode permettant de dtruire lobjet (libration de la mmoire dynamique ...).
61

Les classes
Le constructeur est une fonction membre spcifique de la classe

qui est appele implicitement linstanciation de lobjet, assurant ainsi une initialisation correcte de lobjet. Ce constructeur est une fonction qui porte comme nom, le nom de la classe et qui ne retourne pas de valeur (pas mme un void). Exemple : class Nombre { public : Nombre(); // constructeur par dfaut // ... private : int _i; }; Nombre::Nombre() { _i = 0; }
62

Les classes
On appelle constructeur par dfaut un

constructeur nayant pas de paramtre ou ayant des valeurs par dfaut pour tous les paramtres. class Nombre { public : Nombre(int i=0); // constructeur par dfaut // ... private : int _i; }; Nombre::Nombre(int i) { _i = i; }

63

Les classes
Si le concepteur de la classe ne spcifie pas de

constructeur, le compilateur gnrera un constructeur par dfaut. Comme les autres fonctions, les constructeurs peuvent tre surchargs. class Nombre { public : Nombre(); // constructeur par dfaut Nombre(int i); // constructeur 1 paramtre private : Int _i; };

64

Les classes
Le constructeur est appel linstanciation de lobjet. Il nest

donc pas appel quand on dfinit un pointeur sur un objet ... Exemple : Nombre n1; // correct, appel du constructeur par dfaut Nombre n2(10); // correct, appel du constructeur 1 paramtre Nombre *ptr1, *ptr2; // correct, pas dappel aux constructeurs ptr1 = new Nombre; // appel au constructeur par dfaut ptr2 = new Nombre(12); // appel du constructeur 1 paramtre Nombre tab1[10]; // chaque objet du tableau est initialis // par un appel au constructeur par dfaut Nombre tab2[3] = { Nombre(10), Nombre(20), Nombre(30) }; // initialisation des 3 objets du tableau // par les nombres 10 20 et 30

65

Les classes
De la mme faon que pour les constructeurs, le destructeur est une

fonction membre spcifique de la classe qui est appele implicitement la destruction de lobjet. Ce destructeur est une fonction qui : porte comme nom, le nom de la classe prcd du caractre (tilda) ne retourne pas de valeur (pas mme un void ) naccepte aucun paramtre (le destructeur ne peut donc pas tre surcharg)

66

Les classes
Exemple :

class Exemple { public : // ... ~Exemple(); private : // ... }; Exemple::~Exemple() { // ... }


Comme pour le constructeur, le compilateur gnrera

un destructeur par dfaut si le concepteur de la classe nen spcifie pas un.


67

Les classes
Constructeur copie : Prsentation du problme : Une variable peut tre cre de trois manires diffrentes :

Dclaration : int a ; Par new : p = new int; Dclaration int b=a; Paramtre dune fonction: A chaque paramtre est cre sur la pile une variable qui recevra une copie du paramtre. Cette variable locale sera dtruite automatiquement la sortie de la fonction.

68

Les classes
Dans les deux premiers cas, le constructeur

dune classe est appel automatiquement. Par contre il nest pas appel dans le troisime et le quatrime cas. Le destructeur quant lui est appel dans tous les cas. On peut crer un constructeur spcial dit constructeur de copie qui sera appel uniquement dans le troisime cas. Ce constructeur portera le mme nom que le constructeur standard mais avec un paramtre qui devra tre une rfrence un objet de la mme classe : Classe ( classe & ) ;

69

Les classes
Classes imbriques :

Il est possible de crer une classe par une relation dappartenance : relation un ou est compose de. Exemple : une voiture a un moteur, a des roues ... class Moteur { /* ... */ }; class Roue { /* ... */ }; class Voiture { public: // .... private: Moteur _moteur; Roue _roue[4]; // .... };
70

Les classes
Affectation et initialisation :

Le langage C++ fait la diffrence entre linitialisation et l affectation. Laffectation consiste modifier la valeur dune variable (et peut avoir lieu plusieurs fois). Linitialisation est une opration qui na lieu quune fois immdiatement aprs que lespace mmoire de la variable ait t allou. Cette opration consiste donner une valeur initiale lobjet ainsi cr.

71

Les classes
Le pointeur this :

Toute mthode dune classe X a un paramtre cach : le pointeur this qui contient ladresse de lobjet qui la appel. Il est implicitement dclar comme (pour une variable): X * const this; et comme (pour un objet constant) : const X * const this; et initialis avec ladresse de lobjet sur lequel la mthode est appele. Il peut tre explicitement utilis

72

Les classes
Exemple:

classe X { public: int f1() { return this->i; } // idem que : int f1() { return i; } private: int i; // ... };
73

Les classes
Pointeur sur des membres dune classe :

Il est possible de dclarer de lextrieur un pointeur sur un membre dune classe. Exemple : Class X { public : int a ; // .. }; X var1 ; Int var1 ::*p = &var1 ::a ;
74

Les classes
Les membres statiques :

Ces membres sont utiles lorsque lon a besoin de grer des donnes communes aux instances dune mme classe. On peut avoir des donnes statiques et des fonctions statiques.

75

Les classes
Donnes membres statiques :

Si lon dclare une donne membre comme static, elle est commune tous les objets , elle existe mme si aucun objet na t cr et elle aura la mme valeur pour toutes les instances de cette classe. Elle est accessible en spcifiant non pas le nom de lobjet mais celui de la classe. class Ex1 { public: Ex1() { nb++; /* ... */ } ~Ex1() { nb--; /* ... */ } private: static int nb; // initialisation impossible ici }; Linitialisation de cette donne membre statique se fera en dehors de la classe et en global par une dclaration : int Ex1::nb = 0; // initialisation du membre static

76

Les classes
Fonctions membres statiques :

De mme que les donnes membres statiques, il existe des fonctions membres statiques. Une fonction static ne peut accder quaux membres statiques et ne peut pas tre surcharge. Elle existe mme sil ny a pas dinstance de la classe. class Ex1 { public: Ex1() { nb++; /* ... */ } ~Ex1() { nb--; /* ... */ } static void affiche() { // fonction membre statique cout << nb << endl; } private: static int nb; };
77

Les classes
int Ex1::nb = 0; // initialisation du membre static (en global) void main() { Ex1.affiche(); // affiche 0 (pas dinstance de Ex1) Ex1 a, b, c; Ex1.affiche(); // affiche 3 a.affiche(); // affiche 3 }

78

Les classes
Classes et fonctions amies :

Une classe peut dclarer amie une autre classe ou des fonctions externes. Ainsi un ami peut toucher les membres prives ou protgs de la classe. Cest le mot cl friend qui permet de le faire. Cest une infraction aux rgles dencapsulation pour des raisons defficacit.

79

Les classes
Exemple de fonction amie : class Nombre { // ici je dsigne les fonctions qui pourront accder // aux membres privs de ma classe friend int manipule_nbre(); // fonction amie public : int getnbre(); // ... private : int _nbre; }; int manipule_nbre(Nombre n) { return n._nbre + 1; // je peux le faire en tout lgalit // parce que je suis une fonction amie // de la classe Nombre. }

80

Les classes
Exemple de classe amie :

class Window { // dclaration de la classe Window }; class Screen { friend class Window; public: //... private : //... }; Les fonctions membres de la classe Window peuvent accder aux membres non-publics de la classe Screen.
81