C++ : Automatically run function when derived class is constructed

Question

So I recently accidentally called some virtual functions from the constructor of a base class, i.e. Calling virtual functions inside constructors.

I realise that I should not do this because overrides of the virtual function will not be called, but how can I achieve some similar functionality? My use-case is that I want a particular function to be run whenever an object is constructed, and I don't want people who write derived classes to have to worry about what this is doing (because of course they could call this thing in their derived class constructor). But, the function that needs to be called in-turn happens to call a virtual function, which I want to allow the derived class the ability to override if they want.

But because a virtual function gets called, I can't just stick this function in the constructor of the base class and have it get run automatically that way. So I seem to be stuck.

Is there some other way to achieve what I want?

edit: I happen to be using the CRTP to access other methods in the derived class from the base class, can I perhaps use that instead of virtual functions in the constructor? Or is much the same issue present then? I guess perhaps it can work if the function being called is static?

edit2: Also just found this similar question: Call virtual method immediately after construction

Answer 1

If really needed, and you have access to the factory.

You may do something like:

template <typename Derived, typename ... Args>
std::unique_ptr<Derived> Make(Args&&... args)
{
    auto derived = std::make_unique<Derived>(std::forward<Args>(args));
    derived->init(); // virtual call
    return derived;
}

Answer 2

There is no simple way to do this. One option would be to use so-called virtual constructor idiom, hide all constructors of the base class, and instead expose static 'create' - which will dynamically create an object, call your virtual override on it and return (smart)pointer.

This is ugly, and what is more important, constrains you to dynamically created objects, which is not the best thing.

However, the best solution is to use as little of OOP as possible. C++ strength (contrary to popular belief) is in it's non-OOP specific traits. Think about it - the only family of polymorphic classess inside standard library are streams, which everybody hate (because they are polymorphic!)

Answer 3

If you take a look at how others solved this problem, you will notice that they simply transferred the responsibility of calling the initialization function to client. Take MFC’s CWnd, for instance: you have the constructor and you have Create, a virtual function that you must call to have a proper CWnd instantiation: “these are my rules: construct, then initialize; obey, or you’ll get in trouble”.

Yes, it is error prone, but it is better than the alternative: “It has been suggested that this rule is an implementation artifact. It is not so. In fact, it would be noticeably easier to implement the unsafe rule of calling virtual functions from constructors exactly as from other functions. However, that would imply that no virtual function could be written to rely on invariants established by base classes. That would be a terrible mess.” - Stroustrup. What he meant, I reckon, is that it would be easier to set the virtual table pointer to point to the VT of derived class instead of keep changing it to the VT of current class as your constructor call goes from base down.

I realise that I should not do this because overrides of the virtual function will not be called,...

Assuming that the call to a virtual function would work the way you want, you shouldn't do this because of the invariants.

class B // written by you
{
public:
  B() { f(); }
  virtual void f() {}
};

class D : public B // written by client
{
  int* p;
public:
  D() : p( new int ) {}
  void f() override { *p = 10; } // relies on correct initialization of p  
};

int main()
{
  D d;
  return 0;
}

What if it would be possible to call D::f from B via VT of D? You will use an uninitialized pointer, which will most likely result in a crash.

...but how can I achieve some similar functionality?

If you are willing to break the rules, I guess that it might be possible to get the address of desired virtual table and call the virtual function from constructor.

Answer 4

I want a particular function to be run whenever an object is constructed, [... it] in-turn happens to call a virtual function, which I want to allow the derived class the ability to override if they want.

This can be easily done if you're willing to live with two restrictions:

1. the constructors in the entire class hierarchy must be non-public, and thus
2. a factory template class must be used to construct the derived class.

Here, the "particular function" is Base::check, and the virtual function is Base::method.

First, we establish the base class. It has to fulfill only two requirements:

1. It must befriend MakeBase, its checker class. I assume that you want the Base::check method to be private and only usable by the factory. If it's public, you won't need MakeBase, of course.
2. The constructor must be protected.

https://github.com/KubaO/stackoverflown/tree/master/questions/imbue-constructor-35658459

#include <iostream>
#include <utility>
#include <type_traits>
using namespace std;

class Base {
   friend class MakeBase;
   void check() {
      cout << "check()" << endl;
      method();
   }
protected:
   Base() { cout << "Base()" << endl; }
public:
   virtual ~Base() {}
   virtual void method() {}
};

The templated CRTP factory derives from a base class that's friends with Base and thus has access to the private checker method; it also has access to the protected constructors in order to construct any of the derived classes.

class MakeBase {
protected:
   static void check(Base * b) { b->check(); }
};

The factory class can issue a readable compile-time error message if you inadvertently use it on a class not derived from Base:

template <class C> class Make : public C, MakeBase {
public:
   template <typename... Args> Make(Args&&... args) : C(std::forward<Args>(args)...) {
      static_assert(std::is_base_of<Base, C>::value,
                    "Make requires a class derived from Base");
      check(this);
   }
};

The derived classes must have a protected constructor:

class Derived : public Base {
   int a;
protected:
   Derived(int a) : a(a) { cout << "Derived() " << endl; }
   void method() override { cout << ">" << a << "<" << endl; }
};

int main()
{
   Make<Derived> d(3);
}

Output:

Base()
Derived() 
check()
>3<

Answer 5

Seems you want this, or need more details.

class B 
{
    void templateMethod()
    {
        foo();
        bar();
    }

    virtual void foo() = 0;
    virtual void bar() = 0;
};   

class D : public B
{
public:
    D()
    {
        templateMethod();           
    }

    virtual void foo()
    {
        cout << "D::foo()";
    }

    virtual void bar()
    {
        cout << "D::bar()";
    }
};

Answer 6

I would write a constructor for the base class which calls the function that you want and inherit the constructor

class Base {
public:
    Base() {someFunc(); /* Rest of instructions the constructor should handle */}

protected:
    // Protected stuff

private:
    void someFunc() {/* Function Body */}
};


class Derived : Base {
public:
    Derived() : Base() {/* Your derived constructor */}

// ...
};

(This is of course only convenient if the base constructor handles general functionality of the derived classes)