Virtuelle C++-Funktion vom Konstruktor [duplicate]

Warum gibt das folgende Beispiel “0” aus und was muss sich ändern, damit es wie erwartet “1” ausgibt?

#include <iostream>
struct base {
   virtual const int value() const {
      return 0;
   }
   base() {
      std::cout << value() << std::endl;
   }
   virtual ~base() {}
};

struct derived : public base {
   virtual const int value() const {
      return 1;
   }
};

int main(void) {
   derived example;
}

weil base wird zuerst konstruiert und ist nicht zu einem “gereift”. derived noch. Es kann keine Methoden für ein Objekt aufrufen, wenn es nicht garantieren kann, dass das Objekt bereits ordnungsgemäß initialisiert ist.

Wenn ein abgeleitetes Objekt konstruiert wird, muss der Basisklassenkonstruktor abgeschlossen werden, bevor der Hauptteil des abgeleiteten Klassenkonstruktors aufgerufen wird. Bevor der Konstruktor der abgeleiteten Klasse aufgerufen wird, ist der dynamische Typ des Objekts im Aufbau eine Basisklasseninstanz und keine abgeleitete Klasseninstanz. Aus diesem Grund können beim Aufrufen einer virtuellen Funktion von einem Konstruktor nur die Überschreibungen der virtuellen Funktion der Basisklasse aufgerufen werden.

Tatsächlich gibt es eine Möglichkeit, dieses Verhalten zu erreichen. “Jedes Problem in der Software kann mit einem Umweg gelöst werden.”

/* Disclaimer: I haven't done C++ in many months now, there might be a few syntax errors here and there. */
class parent
{
public:
     parent( ) { /* nothing interesting here. */ };
protected:
     struct parent_virtual
     {
         virtual void do_something( ) { cout << "in parent."; }
     };

     parent( const parent_virtual& obj )
     {
          obj.do_something( );
     }
};

class child : public parent
{
protected:
     struct child_virtual : public parent_virtual
     {
         void do_something( ) { cout << "in child."; }
     };
public:
      child( ) : parent( child_virtual( ) ) { }
};

Die Frage, wie es funktioniert ist ein FAQ-Element.

Zusammenfassend, während der Klasse T konstruiert wird, ist der dynamische Typ Twodurch virtuelle Aufrufe von abgeleiteten Klassenfunktionsimplementierungen verhindert werden, die, falls zulässig, Code ausführen könnten, bevor die relevante Klasseninvariante eingerichtet wurde (ein häufiges Problem in Java und C#, aber C++ ist in dieser Hinsicht sicher).

Die Frage, wie die spezifische Initialisierung abgeleiteter Klassen in einem Basisklassenkonstruktor durchgeführt wird, ist ebenfalls ein FAQ-Artikeldirekt nach dem zuvor erwähnten.

Zusammenfassend kann die Verwendung von statischem oder dynamischem Polymorphismus die relevanten Funktionsimplementierungen bis zum Basisklassenkonstruktor (oder -klasse) weitergeben.

Eine bestimmte Möglichkeit, dies zu tun, besteht darin, a zu übergeben Objekt „Teilefabrik“. up, wo dieses Argument voreingestellt werden kann. Zum Beispiel ein General Button -Klasse könnte eine API-Funktion zur Erstellung von Schaltflächen an ihre übergeben Widget Basisklassenkonstruktor, sodass dieser Konstruktor das richtige Objekt auf API-Ebene erstellen kann.

Du solltest nicht polymorph Rufen Sie die virtuellen Methoden vom Konstruktor auf. Stattdessen können Sie sie nach der Konstruktion des Objekts aufrufen.

Ihr Code kann wie folgt umgeschrieben werden

struct base {
   virtual const int value() const {
      return 0;
   }
   base() {
      /* std::cout << value() << std::endl; */
   }
   virtual ~base() {}
};

struct derived : public base {
   virtual const int value() const {
      return 1;
   }
};

int main(void) {
   derived example;
   std::cout << example.value() << std::endl;
}

Die allgemeine Regel ist, dass Sie keine virtuelle Funktion von einem Konstruktor aufrufen.

In C++ können Sie keine virtual/override-Methode von einem Konstruktor aufrufen.

Nun, es gibt einen guten Grund, warum Sie dies tun können. Als „Best Practice in Software“ sollten Sie möglichst vermeiden, zusätzliche Methoden von Ihrem Konstruktor aufzurufen, auch nicht virtuelle.

Aber es gibt immer eine Ausnahme von der Regel, daher möchten Sie vielleicht eine “Pseudo-Konstruktormethode” verwenden, um sie zu emulieren:

#include <iostream>

class base {
   // <constructor>
   base() {
      // do nothing in purpouse
   }
   // </constructor>

   // <destructor>
   ~base() {
      // do nothing in purpouse
   }
   // </destructor>

   // <fake-constructor>
   public virtual void create() {
      // move code from static constructor to fake constructor
      std::cout << value() << std::endl;
   }
   // </fake-constructor>

   // <fake-destructor>
   public virtual void destroy() {
      // move code from static destructor to fake destructor
      // ...
   }
   // </fake-destructor>

   public virtual const int value() const {
      return 0;
   }

   public virtual void DoSomething() {
      // std:cout << "Hello World";
   }
};

class derived : public base {
   // <fake-constructor>
   public override void create() {
      // move code from static constructor to fake constructor
      std::cout << "Im pretending to be a virtual constructor," << std::endl;
      std::cout << "and can call virtual methods" << std::endl;
   }
   // </fake-constructor>


   // <fake-destructor>
   public override void destroy() {
      // move code from static destructor to fake destructor
      std::cout << "Im pretending to be a virtual destructor," << std::endl;
      std::cout << "and can call virtual methods" << std::endl;
   }
   // </fake-destructor>

   public virtual const int value() const {
      return 1;
   }
};

int main(void) {
   // call fake virtual constructor in same line, after real constructor
   derived* example = new example(); example->create();

   // do several stuff with your objects
   example->doSomething();

   // call fake virtual destructor in same line, before real destructor
   example->destroy(); delete example();
}

Als Pluspunkt empfehle ich Programmierern, “struct” nur für Feldstrukturen und “class” für Strukturen mit Feldern, Methoden, Konstruktoren, … zu verwenden.