Constructeur (programmation)

En programmation orientée objet, un constructeur est une fonction particulière qui permet d'instancier, càd créer un objet en mémoire vive. Le constructeur permet d'allouer la mémoire nécessaire à l'objet et d'initialiser ses attributs.

Si le langage l'autorise, la surcharge est possible et les constructeurs se différencient par le nombre et le type des paramètres passés et renvoyés mais aussi par le formalisme employé. Dans de nombreux langages, on distingue certains constructeurs en particulier :

• le constructeur par défaut n'a aucun argument ;
• le constructeur par recopie a un unique argument du même type que l'objet à créer (généralement sous forme de référence constante) et il recopie les attributs depuis l'objet passé en argument sur l'objet à créer.

Ces deux constructeurs ont souvent une définition attribuée par défaut par le compilateur. Le constructeur par défaut n'a alors aucun effet ; le constructeur de recopie par contre recopiera les valeurs de tous les membres de l'objet donné vers l'objet courant. Ceci peut s'avérer particulièrement dangereux, spécialement dans le cas où des pointeurs sont alloués par le constructeurs et libérés par le destructeur.

En Java

En Java, new est un opérateur unaire de construction qui crée un nouvel objet ou un nouveau tableau.

Pour créer un nouvel objet, le mot-clé new doit être suivi d'une méthode qui soit un constructeur. Par exemple, on pourra avoir :

MaClasse obj; 
    ... 
obj = new MaClasse(5, "bonjour");

si toutefois la classe MaClasse a un constructeur qui possède deux paramètres : un entier et une chaîne de caractères.

Pour créer un nouveau tableau, on peut par exemple écrire :

String[] arguments = new String[10];
    // ou bien : 
int[][] uneMatrice = new int[4][5];
    // ou encore : 
int[][] quatreLignes = new int[4][];

En C++

En C++, le constructeur est une fonction membre publique de la classe portant le même nom que celle-ci. Il est appelé lors de la déclaration de l'objet ou lors de l'utilisation du mot-clé new.

class Object
{
    public :
        Object ();              // Constructeur par défaut
        Object (int);           // Constructeur paramétrique
        Object (const Object&); // Constructeur par recopie
        ~Object ();             // Destructeur
};
 
int main ()
{
    Object obj, *p_obj;         // Appel du constructeur par défaut pour obj
    p_obj=new Object(27);       // Appel du constructeur paramétrique pour créer un objet pour p_obj
    Object obj2(obj);           // Appel du constructeur par recopie pour obj2
    delete p_obj;               // Appel du destructeur pour détruire l'objet contenu dans p_obj
}                               // Appel du destructeur pour obj et obj2

Critique

Dans les langages tels Java, l'appel à un constructeur est équivalent à l'appel d'une méthode statique, ce qui rend plus difficile l'écriture de tests unitaires pour une méthode. L'injection de dépendance permet au programmeur de ne plus devoir écrire aucun appel de constructeur car le framework d'injection de dépendance s'en charge à sa place.

Voir aussi

• Destructeur