从派生构造函数调用基类的虚函数

Question

I know that calling a virtual function from constructor/destructor resolves to an early binding. But I have a question here. Look at the below code

class Base
{
    public:
    virtual void fun()
    {
        cout<<"In Base"<<endl;
    }
};

class Derived : public Base
{
    public:
    Derived(Base obj)
    {
        Base *p;
        p = &obj;
        p->fun();
    }
    void fun()
    {
        cout<<"In Derived"<<endl;
    }
};

int main()
{
    Base b;
    Derived d(b);
}

O/P is : In Base

My doubt here is, that compiler might be using dynamic binding instead of early binding. Please correct me i am wrong but i need a clear explanation of how compiler performs an early binding inside a constructor?

If the method is not a constructor the compiler will convert this statement p->fun in to something like

fetch the VPTR at run time (This vptr will have the derived class VTABLE address)

invoke method at vptr + offset 

hence the right virtual function is invoked.

but since it is a constructor, does compiler stop considering the virtual mechanism and simnply forget about the pointer type and replace the above statement p->fun() to obj.fun() (internally treating it as invoking with the appropriate object)

Because even if you do early binding or late binding the result is same(invoking the local fun() )

Also if it is the local version of the function that is invoked as per the early binding mechanism inside a constructor, then how are we invoking Base version of the function which is not local to the derived (I understand derived contains base sub object but need to know the reason behind calling the base version rather than the local/derived function if the constructor performs an early binding inside a constructor for virtual functions)

Please help

Answer 1

因为您将实际的Base传递给创建者（而不是指针或引用），所以您拥有一个实际的Base实例-将指针强制转换为Derived*是无效的。

Answer 2

In your example, the constructor of Derived calls the method fun() of the object obj of type Base which you passed as parameter to Derived::Derived . This has nothing to do with the instance of Derived you are constructing, hence you simply obtain a call to Base::fun() .

If you instead simply call the method fun in Derived::Derived (with or without using this-> ) you will end up calling the method in Derived , see the following example:

#include <iostream>

class Base
{
    public:
    virtual void fun()
    {
      std::cout<<"In Base"<<std::endl;
    }
};

class Derived : public Base
{
    public:
    Derived(Base obj)
    {
      fun();
    }
    void fun()
    {
      std::cout<<"In Derived"<<std::endl;
    }
};

int main()
{
    Base b;
    Derived d(b);

    return 0;
}

Output:

In Derived

A different case (which perhaps is what you had in mind) is when you call a virtual method in the Base class. Then, when a Derived variable is created, the constructor of Base is invoked. However, at this point, Derived has not been created yet, therefore any virtual call in the costructor of the Base class will resolve to the method in Base . See the discussion here , the C++ FAQ from the website of B. Stroustrup, and the FAQ on the isocpp website.

When finally the Derived object is created, virtual calls work as usual.

The following example illustrates this case

#include <iostream>

class Base
{
    public:
    Base() { fun(); }
    virtual void fun()
    {
      std::cout<<"In Base"<<std::endl;
    }
    void callfun() { fun(); }
};

class Derived : public Base
{
    public:
    Derived(Base obj) { }
    void fun()
    {
      std::cout<<"In Derived"<<std::endl;
    }
};

int main()
{
    std::cout << "About to create Base: ";
    Base b;
    std::cout << "About to create Derived: ";
    Derived d(b);

    std::cout << "Calling b.callfun(): ";
    b.callfun();
    std::cout << "Calling d.callfun(): ";
    d.callfun();

    return 0;
}

Output:

About to create Base: In Base
About to create Derived: In Base
Calling b.callfun(): In Base
Calling d.callfun(): In Derived