Le constructeur par défaut est un constructeur qui ne prend aucun paramètre. C'est le constructeur qui est appelé pour initialiser l'objet par défaut.

std::string nom;             // Création d'un object chaîne de caractère 
                             // puis appel du constructeur par défaut.
std::string prenom;

Le constructeur par défaut est déclaré comme le constructeur n'ayant aucun paramètre.

class MyClass
{
public:
    MyClass()                // Constructeur par défaut.
    {}
};

Une bonne pratique consiste à ce que le programmeur s'assure que le constructeur par défaut initialise l'ensemble des champs de l'objet à une valeur donnée.

Par défaut, c'est à dire sans action de la part du programmeur, les champs sont initialisés comme suit :

• Pour des champs ayant comme type des types atomiques comme les types int, char, …, aucune initialisation n'est réalisée et la valeur contenu dans le champ est indéfini. Attention, ceci peut amener des comportements indésirables et il est souhaitable d'initialiser le champ à une valeur définie.

• Pour des champs ayant comme type un type objet, le constructeur par défaut de la classe est automatiquement appelé. Cependant, si aucun constructeur par défaut n'est définit pour la classe, une erreur de compilation est générée.

• Pour des champs pour lesquels il est spécifié une valeur par défaut, le champ prend cette valeur par défaut.

En l'absence de tout autre constructeur spécialisé, un constructeur par défaut est automatiquement généré.

Ce constructeur par défaut est :

• public,
• il appelle pour chacun des champs de la classe et des classes de bases soit le constructeur, soit procède à l'affectation de la valeur par défaut, soit procède à l'initialisation par défaut du type (qui peut consister justement à ne rien faire).
• le corps du constructeur est vide.

Pour la classe MyClass dérivant des classes BaseClass et ImplementationClass et possédant un champ entier value, le constructeur par défaut généré automatiquement correspond au constructeur suivant

class MyClass: 
  public BaseClass, 
  private ImplementationClass
{
    private:
        int value;
    public:
        MyClass(): BaseClass(), ImplementationClass(), 
            value() // Correspond au constructeur par défaut généré automatiquement
                    // en C++.
        {}
}; 

Comme corollaire, pour pouvoir générer automatiquement un constructeur par défaut, il est impératif que l'ensemble des champs et des classes de bases exposent un constructeur par défaut ou un mécanisme d'initialisation par défaut. Si ce n'est pas le cas, le compilateur ne génèrera pas de constructeur par défaut.