Constructeur, destructeur & allocation dynamique

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 Constructeurs de copie

  MOOC EPFL Introduction à la programmation orientée objet (en C++) · 07:55 · 18k vues — Cette vidéo est reprise d'un MOOC (cours en-ligne) donné sur Coursera : https://www.coursera.org/course/intropoocpp

• 🇫🇷 Programmer en C++ #04 : Les constructeurs

  coursaline · 07:07 · 13k vues — Lorsqu’un objet d’une classe est créé, ses donnée membres peuvent être initialisées par la fonction constructeur de cette classe. Un constructeur est une fon...

• 🇬🇧 C++ Copy constructors (beginner-friendly tutorial + practical examples)

  CodeBeauty · 26:39 · 67k vues — This is an OOP tutorial where I'll teach you about copy constructors in C++. After watching this video, you'll learn what is the purpose of copy constructors...

1. Le constructeur

Une classe peut avoir plusieurs constructeurs (surcharge). Exemple avec une classe Fraction :

class Fraction {
   private:
      int numerateur;
      int denominateur;
   public:
      Fraction();                    // constructeur par défaut
      Fraction(int n);              // 1 paramètre
      Fraction(int n, int d);       // 2 paramètres
      ~Fraction();                   // destructeur
};

Opérateur de résolution de portée ::

<nom_classe>::<nom_méthode>(args) { ... }

Listes d'initialisation

// Version classique (affectation dans le corps)
Fraction::Fraction() {
   numerateur = 0;
   denominateur = 1;
}

// Version moderne (liste d'initialisation) — préférée
Fraction::Fraction() : numerateur{0}, denominateur{1} {}

Fraction::Fraction(int n) : numerateur{n}, denominateur{1} {}

Fraction::Fraction(int n, int d) : numerateur{n}, denominateur{d} {}

Appel des constructeurs

Fraction f1;            // constructeur par défaut — ⚠ pas de () vides
Fraction f2(10);        // constructeur 1 paramètre
Fraction f3(5, 6);      // constructeur 2 paramètres

// Initialisation à partir d'un autre objet
Fraction f4(f3);        // constructeur de copie (voir §5)
Fraction f5 = f3;       // idem — pas une affectation !

2. Le destructeur

~NomClasse() {
   // libération des ressources
}

• Le destructeur n'admet pas d'argument → impossible à surcharger
• Toute classe admet exactement un destructeur
• S'il n'est pas défini, le compilateur en génère un minimaliste

Exemple — compteur d'instances

long counter(0);   // variable globale

class Rectangle {
   int hauteur, largeur;
public:
   Rectangle() : hauteur{0}, largeur{0} { ++counter; }  // constructeur
   ~Rectangle() { --counter; }                          // destructeur
};

int main() {
   Rectangle r1;          // counter = 1
   {
      Rectangle r2;       // counter = 2
   }                      // r2 sort du scope : ~Rectangle() appelé, counter = 1
}                         // r1 détruit, counter = 0

3. Allocation dynamique — new / delete

Pile vs Tas

Allocation sur la pile vs sur le tas

void test() {
   Fraction f3(5, 6);
   // f3 vit jusqu'à la fin du scope
}  // ~Fraction() appelé automatiquement

void test() {
   Fraction* pf;
   pf = new Fraction(5, 6);
   // ...
   delete pf;  // IMPORTANT
}

Tableau dynamique — new[] / delete[]

void test() {
   int n;
   cout << "Nombre de fractions ?";
   cin >> n;

   Fraction* pf = new Fraction[n];   // n constructeurs par défaut appelés
   for (int i = 0; i < n; i++) {
      pf[i] = Fraction(i, i+1);
   }

   delete[] pf;  // les n destructeurs sont appelés
}

4. Rappels — pointeurs et tableaux

• Un tableau est une zone mémoire contenant N éléments consécutifs de même type
• Le nom d'un tableau est un pointeur constant sur le premier élément (indice 0)
• Un tableau n'est pas modifiable (lvalue non modifiable) — on ne peut pas faire tab = …;

Fraction tab[20];
Fraction* pf;
pf = &tab[0];     // équivaut à : pf = tab;
pf++;              // pf pointe sur le 2e élément
tab++;             // ERREUR — tab est un pointeur constant

Bonus de typage

Fraction tab[3];
Fraction* p;
Fraction** pp;
Fraction (*pf)[3];   // pointeur sur tableau de 3 Fractions

p  = &tab;   // WARNING : types incompatibles
pp = &tab;   // WARNING : types incompatibles
pf = &tab;   // OK — types identiques

Résumé des déclarations

5. Constructeur de copie & opérateur d'affectation

Fraction f1(5, 6);

Fraction f2(f1);    // constructeur de copie
Fraction f2 = f1;   // idem — initialisation

Fraction f3;
f3 = f1;            // opérateur d'affectation (objet déjà construit)

Comportement par défaut

Pour les classes simples, la copie/affectation par défaut est une copie membre à membre. Ça pose problème dès qu'il y a de l'allocation dynamique :

Exemple problématique — classe Vector

// vector.h
class Vector {
   private:
      double* elem;
      unsigned int sz;
   public:
      Vector(unsigned int s);    // constructeur
      ~Vector() { delete[] elem; } // destructeur
};

// vector.cpp
Vector::Vector(unsigned int s) : elem{new double[s]}, sz{s} { }

Constructeur de copie — solution

class Vector {
public:
   Vector(const Vector& a);                // constructeur de copie
   Vector& operator=(const Vector& a);     // opérateur d'affectation
};

// Implémentation du constructeur de copie
Vector::Vector(const Vector& a)
   : elem{new double[a.sz]}, sz{a.sz}     // allocation indépendante
{
   for (unsigned int i = 0; i < sz; ++i)
      elem[i] = a.elem[i];                  // copie terme à terme
}

Opérateur d'affectation — solution

Vector& Vector::operator=(const Vector& a) {
   sz = a.sz;
   delete[] elem;                      // libérer l'ancien contenu
   elem = new double[sz];               // nouvelle zone
   for (unsigned int i = 0; i < sz; ++i)
      elem[i] = a.elem[i];               // copie terme à terme
   return *this;                       // permet le chaînage v1 = v2 = v3
}

Règle de trois (rule of three)

6. Fonctions amies

Cas typique — surcharger << pour afficher

// fraction.h
class Fraction {
   private:
      int numerateur;
      int denominateur;
   public:
      friend ostream& operator<<(ostream& out, const Fraction& f);
};

// fraction.cpp
ostream& operator<<(ostream& out, const Fraction& f) {
   out << "Fraction : " << f.numerateur << "/" << f.denominateur;
   return out;
}

// main.cpp
Fraction f(5, 6);
cout << f << endl;   // "Fraction : 5/6"

Sans friend, l'operator<< ne pourrait pas accéder aux private de Fraction.

Règles de l'amitié

★ Réviser le chapitre

Pour vérifier ta compréhension

🃏 Flashcards

↻ Tout retourner

✎ Quiz éclair