Pure Virtual Function called error

Question

I find this strange. In the ctor of Sample_Base, I call bar() which internally calls fun() which is a pure virtual function. I get the error "pure virtual function" called. Which is fine. Now, if I call fun() directly from Sample_Base's ctor, I don't get that error. I tried it on VC++ 2010 Beta 2 and on g++ 4.4.1 on Ubuntu 9.10. I agree that giving an implementation for pure virtual function, other than pure virtual destructor, is meaningless. But, I am a bit surprised about this behaviour.

class Sample_Base
{
public:
    Sample_Base()
    {
        bar();
       // fun();
    }
    /* This is code does not throw any error.
    Sample_Base()
    {
       fun();
    }
    */

    void bar()
    {
        fun();
    }
    virtual void fun() = 0;
    virtual ~Sample_Base();
};

Sample_Base::~Sample_Base()
{

}

void Sample_Base::fun()
{
    std::cout << "Sample_Base::fun\n";
}

class Sample_Derived : public Sample_Base
{
public:
    Sample_Derived() : Sample_Base()
    {
        fun();
    }

    void fun()
    {
        std::cout << "Sample_Derived::fun\n";
    }

    ~Sample_Derived()
    {

    }
};

Answer 1

When you call the function directly, since you are in the constructor, the compiler resolves the static type of your object (Sample_Base) and calls Sample_Base::fun() directly. Since you provided an implementation for it, the compiler finds the function and it works.

When you call it indirectly, through bar(), the compiler must use the dynamic type, so it does a virtual call that gets resolved at runtime. And there it fails, because it calls a pure virtual function.

So the difference is in the moment it binds the function to the call.