Constructeur par défaut - Default constructor

Dans les langages de programmation informatique , le terme constructeur par défaut peut faire référence à un constructeur qui est automatiquement généré par le compilateur en l'absence de tout constructeur défini par le programmeur (par exemple en Java), et est généralement un constructeur nul . Dans d'autres langages (par exemple en C ++), c'est un constructeur qui peut être appelé sans avoir à fournir d'arguments, que le constructeur soit généré automatiquement ou défini par l'utilisateur. Notez qu'un constructeur avec des paramètres formels peut toujours être appelé sans arguments si des arguments par défaut ont été fournis dans la définition du constructeur.

C ++

En C ++ , la norme décrit le constructeur par défaut d'une classe comme un constructeur qui peut être appelé sans argument (cela inclut un constructeur dont les paramètres ont tous des arguments par défaut). Par exemple:

class MyClass
{
public:
    MyClass();  // constructor declared

private:
    int x;
};

MyClass::MyClass() : x(100)  // constructor defined
{
}

int main()
{
    MyClass m;  // at runtime, object m is created, and the default constructor is called
}

Lors de l'allocation dynamique de mémoire, le constructeur peut être appelé en ajoutant des parenthèses après le nom de la classe. Dans un sens, il s'agit d'un appel explicite au constructeur:

int main()
{
    MyClass * pointer = new MyClass();  // at runtime, an object is created, and the
                                        // default constructor is called
}

Si le constructeur a un ou plusieurs paramètres, mais qu'ils ont tous des valeurs par défaut, il s'agit toujours d'un constructeur par défaut. N'oubliez pas que chaque classe peut avoir au plus un constructeur par défaut, soit un sans paramètres, soit un dont tous les paramètres ont des valeurs par défaut, comme dans ce cas:

class MyClass
{
public:
    MyClass (int i = 0, std::string s = "");  // constructor declared

private:
    int x;
    int y;
    std::string z;
};

MyClass::MyClass(int i, std::string s)     // constructor defined
{
    x = 100;
    y = i;
    z = s;
}

En C ++, les constructeurs par défaut sont importants car ils sont automatiquement appelés dans certaines circonstances; et par conséquent, dans ces circonstances, c'est une erreur pour une classe de ne pas avoir de constructeur par défaut:

• Lorsqu'une valeur d'objet est déclarée sans liste d'arguments (par exemple MyClass x; :) ou allouée dynamiquement sans liste d'arguments (par exemple: new MyClass; ou new MyClass(); ), le constructeur par défaut de MyClass est utilisé pour initialiser l'objet.
• Lorsqu'un tableau d'objets est déclaré, par exemple MyClass x[10]; ; ou alloué dynamiquement, par exemple new MyClass [10] . Le constructeur par défaut de MyClass est utilisé pour initialiser tous les éléments.
• Lorsqu'un constructeur de classe dérivée n'appelle pas explicitement le constructeur de classe de base dans sa liste d'initialiseurs, le constructeur par défaut de la classe de base est appelé.
• Lorsqu'un constructeur de classe n'appelle pas explicitement le constructeur de l'un de ses champs à valeur objet dans sa liste d'initialisation, le constructeur par défaut de la classe du champ est appelé.
• Dans la bibliothèque standard, certains conteneurs «remplissent» les valeurs en utilisant le constructeur par défaut lorsque la valeur n'est pas donnée explicitement. Par exemple, vector<MyClass>(10); initialise le vecteur avec dix éléments, qui sont remplis avec un MyClass objet construit par défaut .

Si une classe n'a pas de constructeur explicitement défini, le compilateur déclarera et définira implicitement un constructeur par défaut pour elle. Ce constructeur par défaut défini implicitement est équivalent à un constructeur explicitement défini avec un corps vide. Par exemple:

class MyClass
{
    int x;  // no constructor, so the compiler produces an (implicit) default constructor
};

int main()
{
    MyClass m;   // no error at runtime: the (implicit) default constructor is called
}

Si les constructeurs sont explicitement définis pour une classe, mais qu'ils ne sont pas tous par défaut, le compilateur ne définira pas implicitement un constructeur par défaut, conduisant à une situation où la classe n'a pas de constructeur par défaut. C'est la raison d'une erreur typique, illustrée par l'exemple suivant.

class MyClass
{
public:
    MyClass (int y);  // declaration a non-default constructor

private:
    int x;
};

MyClass::MyClass (int y)
{
    x = y;
}

int main()
{
    MyClass m(100);     // the non-default constructor is called
    MyClass * p;        // for pointer declarations, the compiler does not need to know about constructors
    p = new MyClass();  // error at compilation: no default constructor
    return 0;
}

Puisque ni le programmeur ni le compilateur n'ont défini de constructeur par défaut, la création de l'objet pointé par p conduit à une erreur.

D'un autre côté en C ++ 11, un constructeur par défaut peut être créé explicitement:

class MyClass
{
public:
    MyClass () = default;  // force generation of a default constructor
};

Ou explicitement inhibé:

class MyClass
{
public:
    MyClass () = delete;  // prevent generation of default constructor
};

Java et C #

En Java et en C # , un «constructeur par défaut» fait référence à un constructeur nul qui est automatiquement généré par le compilateur si aucun constructeur n'a été défini pour la classe. Le constructeur par défaut appelle implicitement le constructeur nullaire de la superclasse, puis exécute un corps vide. Tous les champs sont laissés à leur valeur initiale de 0 (types entiers), 0,0 (types à virgule flottante), false ( boolean type) ou null (types de référence). Un constructeur défini par le programmeur qui n'accepte aucun paramètre est également appelé constructeur par défaut en C # , mais pas en Java .

Les références