从基类构造函数调用派生类的成员函数

Question

Suppose I have

struct C {
   C() { init(); };
   void init() { cout << "C" << endl; };
};

struct D : public C {
   D() : C() { };
   void init() { cout << "D" << endl; }
};

D();

why I get "C" printed? How can change this behaviour (and get "D").

How if I want both?

Answer 1

why I get "C" printed?

C::init() is not declared as virtual , so D cannot override it. But even if C::init() were declared as virtual , D::init() would still not be called when init () is called inside of C 's constructor.

C++ constructs base classes before derived classes (and destructs derived clases before base classes). So C 's constructor runs before D is constructed (and C 's destructor runs after D is destructed). The VMT of the object being constructed/destructed simply does not point at D 's method table when C is being constructed/destructed, it points at C 's method table instead.

How can change this behaviour (and get "D").

You cannot call a derived virtual method from inside of a base class constructor/destructor. The VMT does not contain a pointer to the derived class method table at those stages.

Answer 2

You have a quite fundamental problem here: You want to call a member function of a derived class on an object that does not exist yet.

Remember that objects are constructed by first constructing the base sub-object and then the derived object. So even if you'd manage to apply a “clever” trick to actually invoke the derived class' init function, as soon as that function would try to access any data member of the derived object, it would cause arbitrary damage. On the other hand, it is fine to access only the base object, as long as you don't rely on any invariant that the constructor has not established yet. Therefore, if you don't need access to the derived object's data, you can make the init function static and pass it a reference to the base class object.

Maybe this is coming close to what you are trying to do.

#include <iostream>

struct Base
{
  Base(void (*fp)(Base&) = Base::init) { fp(*this); }
  static void init(Base&) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

struct Derived : Base
{
  Derived() : Base(Derived::init) { }
  static void init(Base&) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

int
main()
{
  Base b {};
  std::cout << std::endl;
  Derived d {};
}

Output:

static void Base::init(Base&)

static void Derived::init(Base&)

Here, the base class constructor takes a function pointer to an initializer function that takes a reference to a Base object. The function defaults to Base::init but derived classes can replace it. Be aware, however, that in this design, the Base class constructor may not safely assume that any side effect of Base::init actually took place. It is fine as an extension mechanism (if Base::init does nothing or is disposable), though.

But I doubt that you need to use this kind of machinery. If all you want to do – and this should be the normal case – is to first initialize the base object and then the derived object, C++ already will do the right thing by default if you simply call the functions from the respective constructors.

struct Base
{
  Base() { this->init(); }
  void init() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

struct Derived : Base
{
  Derived() { this->init(); }
  void init() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

// main() as above ...

Output:

void Base::init()

void Base::init()
void Derived::init()

And if we only want to call the most derived class' init function, we can simply tell the base class not to run its own.

struct Base
{
  Base(const bool initialize = true) { if (initialize) this->init(); }
  void init() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

struct Derived : Base
{
  Derived() : Base(false) { this->init(); }
  void init() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

// main() as above ...

Output:

void Base::init()

void Derived::init()

Answer 3

You only can remove init() from C constructor to not print "C". To also print "D" add init() in D() constructor.

If for some cases you want print "C" or "D" and in some don't do something like this

struct C {
   C() { };
   void init() { cout << "C" << endl; };
};

struct D : public C {
   D() : C() 
   { 
     if(some condition)
       C::init();

     if(some condition)
       init();
   };

   void init() { cout << "D" << endl; }
};

D();