Chapitre 2 poo classe objet c++

1

Chapitre 2: notions de classes, objets en C++

1

22

33

44

55

66

77

88

99

10

1111

1212

1313

1414

prenom=p; nom = n;

1515

…main(…) { ……….Personne P; Personne P1("ali"  , " ben saleh“);P1.affichage();. …………..

void affichage() ;void modification(string , string);

Personne::affichage () {cout << prenom << endl << nom << endl;}

Personne:: modification ( string p, string n) {Prenom=p; nom= n;}

Prenom=«  »; nom=«  »;

P.modification(« ali1 »,  « hj»);P.affichage();

}

16

compte(double d) : actif(d) { }

17

1818

1919

20

Objet statique

21

22

Objet dynamique

……………………

23

24

25

26

27

28

Problème constructeur par copie implicite (variables dynamiques)

Copier membre à membre un pointeur signifie que ptr de l'objet y pointe au même endroit que ptr de l'objet x (une recopie d'adresse).!

29

30

31

class T { int *ptr; int nbre;public : T(const T& t2) { nbre= t2.nbre; ptr = new int[nbre]; for (int i=0; i<nbre ; i++) ptr[i]= t2.ptr[i]; }…..}………T t1;….. Remplir les elémént de t1 [1, 3, 5]T t2=t1; // copie de t1 à t2

T t2(t1);

3232

3333

3434

3535

3636

3737

3838

3939

4040

ClassTestStatic a, b;

a.NbObjet =10;

4141

4242

4343

4444

4545

4646

4747

4848

4949

5050

5151

5252

Instanciation dynamique– Le destructeur

le destructeur est une méthode appelée lorsque l'objet est détruit. Le destructeur doit être impérativement écrit pour libérer la mémoire allouée de façon dynamique pendant la vie d'un objet.

class A { private: ... public: A(); // Constructeur par défaut ~A(); // Destructeur ... };

– Durée de vie d'un objetLe destructeur est appelé lorsque l'objet est détruit. Quand un objet est-il détruit ? Dans le cas d'une instanciation

automatique (c'est à dire non dynamique), l'objet est détruit à la fin du bloc dans lequel il a été déclaré.int main() { A a1; for(int i = 0; i<10; i++) { A a2; a2.afficher(); } // Destruction de a2 a1.afficher();} // Destruction de a1

5353

Instanciation dynamiqueL'allocation dynamique du C++ s'effectue avec les opérateurs new et delete, on doit absolument éviter d'utiliser les fonctions malloc et free qui sont propres

au C. L'allocation dynamique s'effectue avec l'opérateur new : l'objet est alloué puis initialisé par appel au constructeur.// Allocation dynamique d'un entier

int * ptr_entier = new int;

// Allocation dynamique d'un objet de classe Etudiant// Le constructeur par défaut est appelé

Etudiant * ptr_etudiant1 = new Etudiant; // Allocation dynamique d'un objet de classe Etudiant// Le constructeur avec un paramètre de type double est appelé

Etudiant * ptr_etudiant2 = new Etudiant(12.5); On utilise l'opérateur delete pour la suppression d'un objet dynamique. // Suppression de l'objet pointé par ptr_entier

delete ptr_entier;

// Suppression de l'objet pointé par ptr_etudiant1// Le destructeur de l'objet (de classe Etudiant) est appelé

delete ptr_etudiant1;

// Suppression de l'objet pointé par ptr_etudiant2// Le destructeur de l'objet (de classe Etudiant) est appelé

delete ptr_etudiant2;

5454

Exemple de tableau :

Tableau d’étudiants qui n’est pas dynamique :Etudiant promo2002[30];

L'allocation dynamique d'un tableau s'effectue comme suit :Etudiant * promo2003 = new Etudiant[30];

Dans ce cas là, il faut à la libération du tableau appeler l'opérateur delete [], sinon seul le premier élément du tableau sera effectivement détruit :

delete [] promo2003;

Instanciation dynamique

5555

5656

57

Exemple : 1

58

59

60

Exemple 2

61

62

63

64

Exemple 3

65

66

67

68

69

Exemple 4

70

71

72

Exemple 5

73

74

75