Differences

This shows you the differences between two versions of the page.

--- in204:cpp:syntax:class:constructor [2019/09/17 21:35]
147.250.80.102 [Allocation sur le tas]
+++ in204:cpp:syntax:class:constructor [2022/11/18 10:51] (current)
@@ Line 24: / Line 24: @@
 Cependant, il est possible d'avoir des mécanismes d'allocation mémoire dans d'autres zones que les zones précédemment énumérées en implantant des mécanismes d'allocation sur mesure.
-==== Allocation sur la pile =====
+==== Allocation dans la pile =====
 Dans ce cas, la mémoire est allouée dans la pile. L'allocation mémoire est relativement rapide puisqu'il s'agit de réserver un bloc mémoire capable de contenir l'ensemble des champs ainsi que la table des méthodes virtuelles de l'objet. La mémoire n'est pas initialisée et les différents champs contiennent des valeurs indéterminées.
@@ Line 135: / Line 135: @@
 ===== L'initialisation =====
-Une fois allouée, l'objet doit être initialisé. Cette initialisation se produit après l'allocation mémoire de l'objet. L'initialisation est effectuée en appelant une méthode spéciale de l'objet qui est appelé le ** constructeur **. Un constructeur est un méthode qui a le même nom que la classe, qui n'a pas de type de retour et qui prend aucune ou plusieurs paramètres.
+Une fois allouée, l'objet doit être initialisé. Cette initialisation se produit après l'allocation mémoire de l'objet. L'initialisation est effectuée en appelant une méthode spéciale de l'objet qui est appelé le ** constructeur **. Un constructeur est un méthode qui a le même nom que la classe, qui n'a pas de type de retour et qui prend aucun ou plusieurs paramètres.
 Le code suivant défini deux constructeurs ''Point()'' et ''Point(int, int)'' pour la classe ''Point''.
@@ Line 146: / Line 146: @@
 public:
-    Point()
+    Point():
     {
         X = 0.0;
@@ Line 204: / Line 204: @@
 }
 </code>
+==== Les différents modes d'initialisation des champs ====
+Dans les exemples précédents, nous avons initialisé les champs par une séquence d'instruction présente dans le corps du constructeur :
+<code cpp>
+class Point
+{
+  ...
+    Point():
+    {
+        X = 0.0;
+        Y = 0.0;
+    }
+    Point(int x, int y)
+    {
+        X = x;
+        Y = y;
+    }
+  ...
+</code>
+Si cette syntaxe est correcte, elle n'est pas optimale. En effet, il est souhaitable qu'avant d'exécuter un quelconque code, nous ayons initialisé l'ensemble des champs de l'objet. Pour ce faire, C++ propose de scinder le processus d'initialisation d'un constructeur en deux phases :
+  * Une première phase avant l'exécution du code entre les parenthèses correspondant à l'initialisation des différents champs,
+  * Une seconde phase consistant à l'exécution du code présent dans le corps du constructor.
+Pour ce faire, le constructor en C++ s'écrit comme suit :
+<code cpp>
+class Box
+{
+    int width;
+    int height;
+    MyClass(): width(0), height(0) // Liste d'initialisateurs
+    {
+        // Corps du constructeur
+    }
+</code>
+Plus spécifiquement :
+  * ''width(0), height(0)'' définit une liste d'initialisateurs des champs et des [[in204:class:derivation|classes de base]]. Chaque initialisateur a pour syntaxe ''membre(paramètres)'' où ''membre'' est le nom du champ ou le type de la classe de base et où ''paramètres'' représentent le ou les paramètres qui sont passés au constructeur du membre (éventuellement aucun paramètre si c'est le membre est initialisé par défaut). Chaque initialisateur est séparer de son successeur par une ','. Les membres sont initialisés dans l'ordre dans lequel ils apparaissent dans la liste d'initialisateurs. Ainsi dans l'exemple précédent, le champ ''width'' est initialisé avant le champ ''height''.
+  * le code contenu dans le corps du constructeur est exécuté une fois l'ensemble des membres initialisés.
+De fait, si pour un champ donné ou une classe de base, aucun initialisateur n'est spécifié dans la liste, dans ce cas, c'est l'initisateur par défaut qui est automatiquement appelé avant d'exécuter le code contenu dans le corps de la fonction.
+==== Les différents types de constructeurs ====
+C++ définit plusieurs types de constructeurs.
+<code cpp>
+class Complex
+{
+private:
+    double re;
+    double im;
+public:
+    Complex(): re(0.0), im(0.0)         // Constructeur par défaut.
+    {}
+    Complex(const Complex& theSource):  // Constructeur de recopie
+        re(theSource.re), im(theSource.im)
+    {}
+    Complex(double aFloat):             // Conversion
+        re(aFloat), im(0.0)
+    {}
+    Complex(double theReal, double theImaginary)
+        re(theReal), im(theImaginary)   // Constructeur spécialisé
+    {}
+};
+</code>
+  * [[in204:cpp:syntax:class:constructor:default|Le constructeur par défaut]]. Il s'agit d'un constructeur ne prenant aucun argument.
+  * [[in204:cpp:syntax:class:constructor:copy|Le constructeur de recopie]]. Ce constructeur est un constructeur servant à initialiser un objet en recopiant les informations d'un objet déjà existant et de même type.
+  * [[in204:cpp:syntax:class:constructor:conversion|Les constructeurs de promotion ou de conversion]]. Ces constructeurs permettent d'initialiser un objet de manière à ce qu'il soit équivalent à un objet ou un valeur ayant un autre type.
+  * [[in204:cpp:syntax:class:constructor:spezialized|Les constructeurs spécialisés]]. Ce sont des constructeurs qui permettent d'initialiser un objet à partir d'un ensemble de paramètres.

Cours

User Tools

Site Tools

Differences

Page Tools