C++ interview inheritance puzzle

Question

Possible Duplicate:
C++ virtual function from constructor
Calling virtual functions inside constructors

This question was asked in interview .

I guess I had answered the 1st part correctly but not sure about the 2nd part. In fact I have no clue about 2nd part.

1. What output does the following code generate? Why?
2. What output does it generate if you make A::Foo() a pure virtual function?

When I tried running same question on my compiler with virtual void foo() = 0; it throws error "undefined reference to `A::Foo()'"

#include <iostream>

using namespace std;

class A     
{    
public:       
    A()             
    {
        this->Foo();
    }
    virtual void Foo() 
    {
        cout << "A::Foo()" << endl;
    }
};

class B : public A      
{     
public:     
    B()      
    {
        this->Foo();      
    }
    virtual void Foo() 
    {
        cout << "B::Foo()" << endl;
    }
};

int main(int, char**)
{
    B   objectB;
    return 0;
}

Answer 1

When you instantiate a B object, the following happens:

1. B's constructor is called.

2. First thing, B's constructor calls the base constructor A().

3. Inside A's constructor, the function call is dispatched to A::foo(), since this has static and dynamic type A* (nothing else makes sense if you think about it); now the A subobject is complete.

4. Now B's constructor body runs. Here the function call is dispatched to B::foo(). Now the entire B object is complete.

If A::foo() is pure-virtual, step (3) causes undefined behaviour; cf. 10.6/4 in the standard.

_{(In your case possibly manifesting as a linker error, since the compiler optimizes to resolve the call statically, and the symbol A::foo is not found.)}

Answer 2

In the second case you have undefined behavior (calling a pure virtual of class T in a class T constructor), so the output could be anything – if it even compiles.

The main thing to understand is that in C++, the dynamic type of an object is T when an object's T constructor executes.

This makes it safe to call virtual functions from a C++ constructor. You don't get a call down into an uninitialized derived class sub-object. In contrast, in Java and C# (and similar languages) you can easily get that kind of bug, and it's common.

Answer 3

Methods in constructors are dispatched as the dynamic type of the class. A's constructor is calling Foo with dynamic type A. (see AlfP.Steinbach's comment for the correct definition)

If A is an abstract base then the error is because it's trying to call a pure virtual method.

A()             
{
    this->Foo(); // call A::Foo
}

From Effective C++ by Scott Meyers:

There's a good reason for this seemingly counterintuitive behavior. Because base class constructors execute before derived class constructors, derived class data members have not been initialized when base class constructors run. If virtual functions called during base class construction went down to derived classes, the derived class functions would almost certainly refer to local data members, but those data members would not yet have been initialized. That would be a non-stop ticket to undefined behavior and late-night debugging sessions. Calling down to parts of an object that have not yet been initialized is inherently dangerous, so C++ gives you no way to do it.

Answer 4

Constructors will be called so that the parents are constructed first, so that there won't be any dependencies on undefined objects. Thus it's A::A followed by B::B. Edit: It's also possible that B's constructor calls A's directly, as Kerrek SB says - the end effect is the same.

In the first case, the output will be "A::Foo()" followed by "B::Foo()". At the time of A's construction B doesn't exist yet, and its virtual functions aren't yet part of the object.

In the second case, you'll be calling a pure virtual function A::Foo which will generate a fault or refuse to compile altogether.