Cours

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== La création des objets ======

===== Les deux phases =====

Une classe définit la structure d'un objet. 

Elle définit d'une part un ensemble de champs et d'autre part un ensemble de fonctions membres qui accèdent aux champs définis au sein de la classe.

Cependant, la classe n'alloue pas de mémoire pour les champs. C'est au moment de la création de l'objet que la mémoire nécessaire à stocker l'ensemble des champs nécessaire est allouée. Une fois la mémoire allouée, il est parfois nécessaire d'initialiser l'ensemble des champs de l'objet afin de pouvoir utiliser l'objet dès que l'opération d'initialisation soit terminé.

De fait, la création d'un objet comporte deux phases :

  * Phase 1 : La création d'un bloc mémoire suffisamment grand pour contenir l'ensemble des champs définis par la classe de l'objet.
  * Phase 2 : L'initialisation des champs de cet objet en exécutant une séquence d'instructions pour initialiser les champs de l'objet.

===== L'allocation mémoire =====

Classiquement, la mémoire allouée pour un objet se trouve : 

  * soit sur la pile. 
  * soit sur le tas.
  * soit dans la zone de mémoire globale.

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 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.


<code cpp>
void display_message()
{
    std::string message = "Un message";
    message += " qui est complété.";
    std::cout << message << std::endl;   
}
</code>

Naturellement, le bloc mémoire disparait automatiquement lorsque l'on quitte la fonction. 

<code cpp>
std::string* get_message()
{
    std::string message = "Un message";
    return &message;
}

int main()
{
    std::string* message = get_message();
    std::cout << *message << std::endl;
        // Génère une segmentation fault puisque la mémoire 
        // l'objet message a été supprimée à la fin 
        // de la fonction.
    return 0:
}
</code>

==== L'allocation sur le tas =====

La mémoire est allouée dans le tas. Pour ce faire, un appel au gestionnaire de mémoire du système d'exploitation est effectuée pour retourner un bloc mémoire suffisamment grand pour stocker l'ensemble des champs ainsi que la table des méthodes virtuelles associés à l'objet.   

<code cpp>
void display_message()
{
    std::string* message = new std::string("Un message");
        // allocation de l'objet sur le tas. 
        // c'est un pointeur sur un objet de type std::string 
        // qui est retourné.
    message->append(" qui est complété.");
    std::cout << message << std::endl;   
    delete message;
        // attention: la mémoire n'est pas automatiquement 
        // libérée, il faut faire attention à ne pas oublier
        // de libérer la mémoire une fois que l'objet n'est 
        // plus utilisé.
}
</code>

De fait, la mémoire allouée n'est libérée que par un appel à 
l'opérateur ''delete''. Ceci signifie qu'il est parfaitement
possible de retourner un pointeur sur un objet qui aurait été 
alloué par une fonction. 

<code cpp>
std::string* get_message()
{
    std::string* message = new std::string("Un message");
        // allocation de l'objet sur le tas. 
        // c'est un pointeur sur un objet de type std::string 
        // qui est retourné.
    message->append(" qui est complété.");
    return message;
}

int main()
{
    std::string* message = get_message();
    std::cout << *message << std::endl;
    delete message;
        // attention: la mémoire n'est pas automatiquement 
        // libérée, il faut faire attention à ne pas oublier
        // de libérer la mémoire une fois que l'objet n'est 
        // plus utilisé.
    return 0:
}
</code>

==== L'allocation dans la zone mémoire globale =====


Il est parfaitement possible de déclarer un objet comme 
une variable globale. Dans ce cas, la mémoire de l'objet est 
allouée au moment du chargement du segment mémoire.

<code cpp>

std::string message = "Un message";

void extend_message()
{
    message->append(" qui est complété.");
}

int main()
{
    extend_message();
    std::cout << message << std::endl;
    return 0:
}
</code>


===== 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 aucun ou plusieurs paramètres.

Le code suivant défini deux constructeurs ''Point()'' et ''Point(int, int)'' pour la classe ''Point''.

<code cpp>
class Point
{
private:
    double X, Y;
    
public: 
    Point(): 
    {
        X = 0.0;
        Y = 0.0;
    }
    Point(int x, int y)
    {
        X = x;
        Y = y;
    }
};

</code>

Lorsque nous créons un objet sur la pile (ou en mémoire globale) :

<code cpp>
void allocate_point_on_stack()
{
    Point pointA; 
        // appelle le constructeur par défaut,
        //  ie. le constructeur Point()
    Point pointB(3.4, 3.5);
        // appelle le constructeur spécialisé prenant 
        // deux valeurs en entrées, ie. le constructeur Point(double, double)
}
</code>
 
La syntax est légèrement différente quand l'objet est alloué dans le tas :

<code cpp>
void allocate_point_on_stack()
{
    Point* pointA = new Point(); 
        // appelle le constructeur par défaut,
        //  ie. le constructeur Point()
    Point* pointB = new Point(3.4, 3.5);
        // appelle le constructeur spécialisé prenant 
        // deux valeurs en entrées, ie. le constructeur Point(double, double)
}
</code>

Cependant il est parfaitement possible d'utiliser une syntaxe équivalente
pour allouer un objet sur la pile en écrivant l'allocation comme suit. 
Cependant cette écriture n'est pas recommandée, puisqu'elle peut 
parfois entrainer certaines confusions.

<code cpp>
void allocate_point_on_stack()
{
    Point pointA = Point(); 
        // appelle le constructeur par défaut,
        //  ie. le constructeur Point()
    Point pointB = Point(3.4, 3.5);
        // appelle le constructeur spécialisé prenant 
        // deux valeurs en entrées, ie. le constructeur Point(double, double)
}
</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;
    m_height;
    MyClass(): [member initializer list]
    {
        [initialization code body]
    }
</code>

Plus précisément, en C++, l'initialisation est systèmatiquement effectué comme suit. 

Phase 1 : pour chacun des champs présents dans l'objet, soit appel du constructeur spécifique selon l'ordre défini dans le constructeur, soit pour l'ensemble des champs non présent dans la liste des   


==== Les différents types de constructeurs ====


C++ définit plusieurs types de constructeurs. 

  * [[in204:constructor:default|Le constructeur par défaut]]. Il s'agit d'un constructeur ne prenant aucun argument. 
  * [[in204: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: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:constructor:spezialized|Les constructeurs spécialisés]]. Ce sont des constructeurs qui permettent d'initialiser un objet à partir d'un ensemble de paramètres.

<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>
Cours

User Tools

Site Tools

Page Tools
