Calling virtual functions inside constructors


Suppose I have two C++ classes:

class A
  A() { fn(); }

  virtual void fn() { _n = 1; }
  int getn() { return _n; }

  int _n;

class B : public A
  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?

7/9/2018 8:07:28 AM

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.


[...] 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)

10/16/2018 7:04:45 AM

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 {
   Base() { f(); }
   virtual void f() { std::cout << "Base" << std::endl; } 
class Derived : public Base
   Derived() : Base() {}
   virtual void f() { std::cout << "Derived" << 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;
   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...

Licensed under: CC-BY-SA with attribution
Not affiliated with: Stack Overflow