FAQ C++ moderne et erreurs courantes

La liste d'initialisation est l'endroit où le constructeur crée tous ses membres ainsi que (éventuellement) la classe de base dont la classe hérite directement. Elle se situe avant l'accolade ouvrante qui contient le code du constructeur :

class MaClasse {
public:
    MaClasse(/* éventuels paramètres */)     
    /* ICI */
    {
        // PAS LÀ
    }
};

MaClasse::MaClasse(/* éventuels paramètres */)
/* ICI */
{
    // PAS LÀ
}

La liste d'initialisation débute par deux points : et sépare chaque initialisation par une virgule ,. Chaque initialisation étant de la forme suivante (avec des parenthèses, ou des accolades depuis C++11 permettant de nouvelles formes d'initialisation) et construisant chaque membre dans le même ordre que leur déclaration :

ClasseDeBase(/* ses paramètres constructeurs */)

variable_membre(/* ses paramètres constructeurs / sa valeur initiale */)

Si l'on a par exemple une classe de base avec le constructeur ClasseDeBase(int a, int b) nous pourrons l'initialiser ainsi :

ClasseDeBase(1, 2)

Si l'on a par exemple un membre int value_;, nous l'initialiserons ainsi :

value_(42)

Si l'on a par exemple un membre std::vector<int> vec_; que l'on souhaite initialiser avec 10 fois la valeur 5, nous aurons :

vec_(10, 5)

ou avec les valeurs {1,2,3,4,5} :

vec_{1,2,3,4,5}

Le tout cumulé nous donnera :

class MaClasse : public ClasseDeBase {
    int value_;
    std::vector<int> vec_;
 
public:
    MaClasse(/* éventuels paramètres */)     
      : ClasseDeBase(1, 2)
      , value_(42)
      , vec_{1,2,3,4,5}
    {
        // PAS LÀ
    }
};

MaClasse::MaClasse(/* éventuels paramètres */)
  : ClasseDeBase(1, 2)
  , value_(42)
  , vec_{1,2,3,4,5}
{
    // PAS LÀ
}

1. les références : elles doivent obligatoirement désigner un objet dès leur construction, cf. '[…]' declared as reference but not initialized.

2. les classes de base et membres ne possédant pas de constructeur par défaut : vous êtes obligé de leur passer des paramètres :

   Montrer la démonstration pour la classe de base

   Sélectionnez class Base { public: // Base() n'est ici pas défini implicitement à cause des deux suivants Base(int) {} Base(Base const &) = delete; virtual ~Base() = default; Base & operator = (Base const &) = delete; };
   Sélectionnez class Derivee : public Base { public: Derivee() // Appel implicite de Base() // => Erreur Base n'a pas de constructeur par défaut {} };	Sélectionnez class Derivee : public Base { public: Derivee() : Base(0) // OK Base(int) appelé {} };

   Montrer la démonstration pour le membre

   Sélectionnez class A { public: A(int); // Le constructeur par défaut n'est pas généré };
   Sélectionnez class MaClasse { A a_; public: MaClasse() // Appel implicite de A() // => Erreur A n'a pas de constructeur par défaut {} };	Sélectionnez class MaClasse { A a_; public: MaClasse() : a_(0) // OK A(int) appelé {} };

3. les types primitifs, pointeurs nus et tableaux C : non initialisés, vous aurez un UB dès que vous voudrez lire leurs valeurs / accéder à l'adresse pointée :

   Montrer la démonstration

   Sélectionnez class MaClasse { int i_; int * p_; int tab_[10]; public: MaClasse() {} // Attention : i_, chaque case de tab_ et // p_ n'ont pas été initialisés ! };

   Sélectionnez class MaClasse { int i_; int * p_; int tab_[10]; public: MaClasse() : i_{42} , p_{nullptr} , tab_{0,1,2,3,4,5,6,7,8,9} {} // OK : ils ont été initialisés };

4. les classes non copiables/déplaçables, en particulier les classes ayant une sémantique d'entité, (auquel s'ajoute éventuellement le 2.) : vous ne pourrez pas faire appel à l'opérateur d'affectation par copie et/ou déplacement dans le corps du constructeur :

   Montrer la démonstration

   Sélectionnez class Base { public: Base() = default; virtual ~Base() = default; Base(Base const &) = delete; Base & operator = (Base const &) = delete; /* à cause des delete ci-dessus, nous avons implicitement : Base(Base &&) = delete; Base & operator = (Base &&) = delete; */ }; class Derivee : public Base { public: Derivee() : Derivee(0) {} Derivee(int value) : value_(value) {} /* implicitement, par l'héritage : Derivee(Derivee const &) = delete; Derivee & operator = (Derivee const &) = delete; Derivee (Derivee &&) = delete; Derivee & operator = (Derivee &&) = delete; */ private: int value_; };

   Sélectionnez class MaClasse { public: MaClasse(int i) // Appel implicite de Derived() // Erreur : appel de operator = (Derivee &&) marqué « delete » { d_ = Derivee(i); } private: Derivee d_; };

   Sélectionnez class MaClasse { public: MaClasse(int i) : d_(i) {} // OK : appel du constructeur Derivee(int) private: Derivee d_; };

Passons maintenant aux erreurs courantes (se basant sur l'exemple complet qui suit) :

#include <vector>
#include <string>
#include <iostream>
 
class Base {
    int a_;
    int b_;
public:
    virtual ~Base() = default;
    Base(Base const &) = delete;
    Base & operator = (Base const &) = delete;

    Base(int a, int b)
      : a_{a}
      , b_{b}
    { }
    
    virtual void print() const {
        std::cout << "a_   = " << a_ << '\n'
                  << "b_   = " << b_ << '\n';        
    }
};
 
 
class Derivee : public Base {
    std::vector<int> vec_;
    std::string str_;
    int i_;
public:
    Derivee()
      : Base(0,0) // Nous appelons le constructeur de la classe de base avec a = b = 0
                  // vec_ non mentionné, un appel à son constructeur par défaut est effectué (tableau vide)
      , str_("Hello World!")
      , i_(42)
    { }
    
    Derivee(int a, int b, std::size_t size, std::string const & s, int i)
      : Base(a, b) // Ici nous transmettons les paramètres a et b au constructeur de notre classe de Base
      , vec_(size) // Nous construisons un tableau de size éléments (initialisés à 0)
      , str_(s)    // str_…
      , i_(i)      // … et i_ sont initialisés avec les valeurs des paramètres s et i
    { }
    
    void print() const override {
        Base::print();
        std::cout << "vec_ = [ ";
        for (int value : vec_) {
            std::cout << value << ' ';
        }
        std::cout << "]\n"
                  << "str_ = " << str_ << '\n'
                  << "i_   = " << i_   << '\n'
                  << '\n';
    }
};
 
int main () {
    Derivee d1;
    d1.print();
    
    Derivee d2(1, 2, 10, "Liste d'initialisation", 5);
    d2.print();
    
    return 0;
}

a_   = 0
b_   = 0
vec_ = [ ]
str_ = Hello World!
i_   = 42

a_   = 1
b_   = 2
vec_ = [ 0 0 0 0 0 0 0 0 0 0 ]
str_ = Liste d'initialisation
i_   = 5

Derivee(/* … */)
{
    /* … */
}

Derivee(/* … */)
  : Base(/* paramètres à passer au constructeur */)
  // éventuelle initialisation de vec_ et str_ si vous ne les voulez pas vides
  , i_(/* valeur initiale */)
{ }

Derivee(/* … */)
{ 
    Base(1, 2);
}

Derivee(/* … */)
{ 
    Derivee(/* … */);
}

Derivee(/* … */)
{ 
    {
        Base temp(1, 2);
    } // détruit ici
}

Derivee(/* … */)
  : Base(1, 2)
{ }

Derivee(/* … */)
/* … */
{ 
    str_ = "Hello World!";
}

Derivee(/* … */)
  /* … */
  , str_("Hello World!")
{ }

Derivee(/* … */)
/* … */
{ 
    vec_(10);
    i_(42);
}

In constructor 'Derivee::Derivee( ... )':
error: expression cannot be used as a function
         i_(42);
              ^
error: no match for call to '(std::vector<int>) (int)'
         vec_(10);
                ^

error: called object type 'int' is not a function or function pointer
        i_(42);
        ~~^
error: type 'std::vector<int>' does not provide a call operator
        vec_(10);
        ^~~~

error C2064: le terme ne correspond pas à une fonction qui prend 1 arguments
error C2064: le terme ne correspond pas à une fonction qui prend 1 arguments

error C2064: term does not evaluate to a function taking 1 arguments
error C2064: term does not evaluate to a function taking 1 arguments

Derivee(/* … */)
  /* … */
  , vec_(10) // initialisé avec 10 éléments ayant pour valeur 0
  , i_(42)   // initialisé à la valeur 42
{ }

Derivee(/* … */)
  /* … */
{ 
    int i_(42);
}

Derivee(/* … */)
  /* … */
  , i_(42)   // initialisé à la valeur 42. Cf. suivant, notez l'absence du type devant
{ }

Derivee(/* … */)
/* … */
int i_(42);
{ }

Derivee(/* … */)
  /* … */
  , i_(42)
{ }

class MaClasse {
    int premier; // déclaré en premier
    int second;
 
public:
    MaClasse(int i) : second(i++), premier(i++) { }
};

MaClasse mc(0); // premier = 0 ; second = 1 et non l'inverse !

warning: 'MaClasse::second' will be initialized after
[…]
warning: 'MaClasse::premier' [-Wreorder]
[…]
warning: when initialized here
[…]