A C ++ esetében mi a különbség az implicit konstruktor és az alapértelmezett konstruktor között?


Válasz 1:
Foo osztály {
 nyilvános:
  // Alapértelmezett ctor.
  Foo (): i_ (0) {}

  // implicit konverziós ctor.
  Foo (int i): i_ (i) {}

  // ctor másolása; nincs átalakítás.
  Foo (const Foo & f): i_ (f.i_) {}
 magán:
  int i_;
};

érvénytelen bár (foo f) {
  // Tegyen valamit f-lel
}

main () {
  Foo f0; // Alapértelmezett ctorot használ.
  Foo f1 (1); // Konverziós ctorot használ.
  Bar (f0); // Másolás ctorot használ.
  Bar (2); // implicit konverziós ctorot használ.
}
  Foo (int i = 0): i_ (i) {};

Válasz 2:
#include 
struct X {
    X () {std :: cout << "Ez az alapértelmezett ctor az X-nél \ n"; }
};
struct Y {
    Y (int n = 0) {std :: cout << "Ez az Y alapértelmezett tornya \ n"; }
};
sztrukt Z: X {
     // Z konstruktora implicit módon van meghatározva
     // mint Z (): X () {}
};
int main ()
{
    X x; // felhívja az X :: X ()
    Y y; // felhívja Y: Y ()
    Z Z; // felhívja a Z :: Z () -ot, amely felhívja az X :: X () -ot;
}