Calling virtual functions inside constructors

Question

Suppose I have two C   classes   class A   public    A     fn         virtual void fn      n   1      int getn     return  n     protected    int  n      class B   public A   public    B     A         virtual void fn      n   2         If I write the following code   int main       B b    int n   b getn        One might expect that n is set to 2   It turns out that n is set to 1  Why

User · Accepted Answer

Calling virtual functions from a constructor or destructor is dangerous and should be avoided whenever possible. All C++ implementations should call the version of the function defined at the level of the hierarchy in the current constructor and no further.

The C++ FAQ Lite covers this in section 23.7 in pretty good detail. I suggest reading that (and the rest of the FAQ) for a followup.

Excerpt:

[...] In a constructor, the virtual call mechanism is disabled because overriding from derived classes hasn’t yet happened. Objects are constructed from the base up, “base before derived”.

[...]

Destruction is done “derived class before base class”, so virtual functions behave as in constructors: Only the local definitions are used – and no calls are made to overriding functions to avoid touching the (now destroyed) derived class part of the object.

EDIT Corrected Most to All (thanks litb)

User · Answer

The C   FAQ Lite Covers this pretty well      Essentially  during the call to the base classes constructor  the object is not yet of the derived type and thus the base type s implementation of the virtual function is called and not the derived type s

User · Answer

Firstly Object is created and then we assign it  s address to pointers Constructors are called at the time of object creation and used to initializ the value of data members  Pointer to object comes into scenario after object creation  Thats why  C   do not allows us to make constructors as virtual    another reason is that  There is nothing like pointer to constructor    which can point to virtual constructor because one of the property of virtual function is that it can be used by pointers only     Virtual functions are used to assign value dynamically as constructors are static so we can not make them virtual

User · Answer

As has been pointed out  the objects are created base-down upon construction  When the base object is being constructed  the derived object does not exist yet  so a virtual function override cannot work   However  this can be solved with polymorphic getters that use static polymorphism instead of virtual functions if your getters return constants  or otherwise can be expressed in a static member function   This example uses CRTP  https   en wikipedia org wiki Curiously recurring template pattern    template lt typename DerivedClass gt  class Base   public      inline Base         foo DerivedClass  getFoo                inline int fooSq             return foo   foo             const int foo      class A   public Base lt A gt    public      inline static int getFoo     return 1        class B   public Base lt B gt    public      inline static int getFoo     return 2        class C   public Base lt C gt    public      inline static int getFoo     return 3        int main         A a      B b      C c       std  cout  lt  lt  a fooSq    lt  lt        lt  lt  b fooSq    lt  lt        lt  lt  c fooSq    lt  lt  std  endl       return 0      With the use of static polymorphism  the base class knows which class  getter to call as the information is provided at compile-time

User · Answer

The vtables are created by the compiler   A class object has a pointer to its vtable   When it starts life  that vtable pointer points to the vtable  of the base class   At the end of the constructor code  the compiler generates code to re-point the vtable pointer to the actual vtable for the class   This ensures that constructor code that calls virtual functions calls the base class implementations of those functions  not the override in the class

User · Answer

The reason is that C   objects are constructed like onions  from the inside out  Base classes are constructed before derived classes  So  before a B can be made  an A must be made  When A s constructor is called  it s not a B yet  so the virtual function table still has the entry for A s copy of fn

User · Answer

Do you know the crash error from Windows explorer    Pure virtual function call      Same problem       class AbstractClass    public      AbstractClass               if you call pureVitualFunction I will crash              virtual void pureVitualFunction     0       Because there is no implemetation for the function pureVitualFunction   and the function is called in the constructor the program will crash

User · Answer

During the object s constructor call the virtual function pointer table is not completely built  Doing this will usually not give you the behavior you expect  Calling a virtual function in this situation may work but is not guaranteed and should be avoided to be portable and follow the C   standard

User · Answer

Other answers have already explained why virtual function calls don t work as expected when called from a constructor  I d like to instead propose another possible work around for getting polymorphic-like behavior from a base type s constructor   By adding a template constructor to the base type such that the template argument is always deduced to be the derived type it s possible to be aware of the derived type s concrete type  From there  you can call static member functions for that derived type   This solution does not allow non-static member functions to be called  While execution is in the base type s constructor  the derived type s constructor hasn t even had time to go through it s member initialization list  The derived type portion of the instance being created hasn t begun being initialized it  And since non-static member functions almost certainly interact with data members it would be unusual to want to call the derived type s non-static member functions from the base type s constructor   Here is a sample implementation     include  lt iostream gt   include  lt string gt   struct Base   protected      template lt class T gt      explicit Base const T     class name T  Name                  std  cout  lt  lt  class name  lt  lt    created n          public      Base     class name Name                  std  cout  lt  lt  class name  lt  lt    created n               virtual  Base             std  cout  lt  lt  class name  lt  lt    destroyed n              static std  string Name             return  Base          private      std  string class name       struct Derived   public Base          Derived     Base this         this  is used to allow Base  Base lt T gt  to deduce T      static std  string Name             return  Derived             int main int argc  const char  argv           Derived        Create and destroy a Derived     Base           Create and destroy a Base      return 0      This example should print   Derived created Derived destroyed Base created Base destroyed   When a Derived is constructed  the Base constructor s behavior depends on the actual dynamic type of the object being constructed

User · Answer

As a supplement  calling a virtual function of an object that has not yet completed construction will face the same problem  For example  start a new thread in the constructor of an object  and pass the object to the new thread  if the new thread calling the virtual function of that object before the object completed construction will cause unexpected result  For example   include  lt thread gt   include  lt string gt   include  lt iostream gt   include  lt chrono gt   class Base   public    Base           std  thread worker  this             This will print  quot Base quot  rather than  quot Sub quot         this- gt Print                worker detach           Try comment out this code to see different output      std  this thread  sleep for std  chrono  seconds 1          virtual void Print           std  cout  lt  lt   quot Base quot   lt  lt  std  endl          class Sub   public Base   public    void Print   override         std  cout  lt  lt   quot Sub quot   lt  lt  std  endl          int main       Sub sub    sub Print      getchar      return 0     This will output  Base Sub

User · Answer

One solution to your problem is using factory methods to create your object    Define a common base class for your class hierarchy containing a virtual method afterConstruction       class Object   public    virtual void afterConstruction                     Define a factory method     template lt  class C  gt  C  factoryNew       C  pObject   new C      pObject- afterConstruction       return pObject       Use it like this     class MyClass   public Object    public    virtual void afterConstruction              do something                   MyClass  pMyObject   factoryNew

User · Answer

The C   Standard  ISO IEC 14882-2014  say s      Member functions  including virtual functions  10 3   can be called   during construction or destruction  12 6 2   When a virtual function   is called directly or indirectly from a constructor or from a   destructor  including during the construction or destruction of the   class   s non-static data members  and the object to which the call   applies is the object  call it x  under construction or destruction    the function called is the final overrider in the constructor   s or   destructor   s class and not one overriding it in a more-derived class    If the virtual function call uses an explicit class member access    5 2 5  and the object expression refers to the complete object of x   or one of that object   s base class subobjects but not x or one of its   base class subobjects  the behavior is undefined    So  Don t invoke virtual functions from constructors or destructors that attempts to call into the object under construction or destruction  Because the order of construction starts from base to derived and the order of destructors starts from derived to base class   So  attempting to call a derived class function from a base class under construction is dangerous Similarly  an object is destroyed in reverse order from construction  so attempting to call a function in a more derived class from a destructor may access resources that have already been released

User · Answer

I am not seeing the importance of the virtual key word here  b is a static-typed variable  and its type is determined by compiler at compile time  The function calls would not reference the vtable  When b is constructed  its parent class s constructor is called  which is why the value of  n is set to 1

User · Answer

Calling a polymorphic function from a constructor is a recipe for disaster in most OO languages  Different languages will perform differently when this situation is encountered   The basic problem is that in all languages the Base type s  must be constructed previous to the Derived type  Now  the problem is what does it mean to call a polymorphic method from the constructor  What do you expect it to behave like  There are two approaches  call the method at the Base level  C   style  or call the polymorphic method on an unconstructed object at the bottom of the hierarchy  Java way    In C   the Base class will build its version of the virtual method table prior to entering its own construction  At this point a call to the virtual method will end up calling the Base version of the method or producing a pure virtual method called in case it has no implementation at that level of the hierarchy  After the Base has been fully constructed  the compiler will start building the Derived class  and it will override the method pointers to point to the implementations in the next level of the hierarchy   class Base   public     Base     f         virtual void f     std  cout  lt  lt   Base   lt  lt  std  endl        class Derived   public Base   public     Derived     Base         virtual void f     std  cout  lt  lt   Derived   lt  lt  std  endl       int main        Derived d       outputs   Base  as the vtable still points to Base  f   when Base  Base   is run   In Java  the compiler will build the virtual table equivalent at the very first step of construction  prior to entering the Base constructor or Derived constructor  The implications are different  and to my likings more dangerous   If the base class constructor calls a method that is overriden in the derived class the call will actually be handled at the derived level calling a method on an unconstructed object  yielding unexpected results  All attributes of the derived class that are initialized inside the constructor block are yet uninitialized  including  final  attributes  Elements that have a default value defined at the class level will have that value   public class Base      public Base     polymorphic         public void polymorphic            System out println   Base            public class Derived extends Base      final int x     public Derived  int value           x   value        polymorphic            public void polymorphic           System out println   Derived      x             public static void main  String args             Derived d   new Derived  5              outputs  Derived 0             Derived 5        so much for final attributes never changing  P   As you see  calling a polymorphic  virtual in C   terminology  methods is a common source of errors  In C    at least you have the guarantee that it will never call a method on a yet unconstructed object

[c++] Calling virtual functions inside constructors

Examples related to c++

Examples related to constructor

Examples related to overriding

Examples related to virtual-functions