En C ++, quelle est la différence entre un constructeur implicite et un constructeur par défaut?


Réponse 1:
classe Foo {
 Publique:
  // Ctor par défaut.
  Foo (): i_ (0) {}

  // Ctor de conversion implicite.
  Foo (int i): i_ (i) {}

  // Copier ctor; aucune conversion n'est impliquée.
  Foo (const Foo & f): i_ (f.i_) {}
 privé:
  int i_;
};

void Bar (Foo f) {
  // Faites quelque chose avec f
}

principale() {
  Foo f0; // Utilise le ctor par défaut.
  Foo f1 (1); // Utilise le convertisseur de conversion.
  Barre (f0); // Utilise copie ctor.
  Bar (2); // Utilise le convertisseur de conversion implicite.
}
  Foo (int i = 0): i_ (i) {};

Réponse 2:
#include 
struct X {
    X () {std :: cout << "C'est le ctor par défaut pour X \ n"; }
};
struct Y {
    Y (int n = 0) {std :: cout << "C'est le ctor par défaut pour Y \ n"; }
};
struct Z: X {
     // le constructeur de Z est implicitement défini
     // comme Z (): X () {}
};
int main()
{
    X x; // appelle X :: X ()
    Y y; // appelle Y :: Y ()
    Z z; // appelle Z :: Z (), qui appelle X :: X ();
}