Call virtual functions during construction

[evenstar]

hello every body,
I know I shouldn't call virtual functions during construction or destruction.

#include <iostream>
using namespace std;
 
class   BaseWithPureFunction 
{ 
public: 
 
 
    virtual   void   PureFunc()   =   0; 
    void   CallPureFunc()   
    { 
        PureFunc();     
    } 
 
    BaseWithPureFunction() ;
}; 
 
   BaseWithPureFunction::BaseWithPureFunction()   
{ 
   /* 
    Call pure-virtual via CallPureFun. 
    Cause r6025 error.I have no question here.
   */
    CallPureFunc();   
 
} 
 
void BaseWithPureFunction::PureFunc()
{
   cout<<"Pure!"<<endl;
}
 
 
 
 
class   BaseEx:public   BaseWithPureFunction 
{ 
public: 
    virtual   void   PureFunc() 
    { 
        printf( "BaseEx::PureFunc()\r\n "); 
    } 
}; 
 
int _tmain(int argc, _TCHAR* argv[])
{
 
   BaseEx ex;
 
   return 0;
}
 
 
 

If replace the BaseWithPureFunction function :

   BaseWithPureFunction::BaseWithPureFunction()   
{ 
    /*
      Call pure-virtual directly.
      Running well.I puzzled.
 
    */
          PureFunc();   
 
}
 
 

I puzzled why call pure-virtual directly, the programe won't cause error.I found some explanation in "Effective C++ Item 9".But I still think that this explanation is not detailed enough.

[weaknessforcats]

Think about this.

When you have a virtual function, you instruct the compiler that when there is a choice between calling the base function or the derived function, the derived function is to be called.

Therefore, if you have:

class Base
{
public:
virtual void Method();
};

[weaknessforcats]

Think about this.

When you have a virtual function, you instruct the compiler that when there is a choice between calling the base function or the derived function, the derived function is to be called.

However, during construction there is no guarantee that the derived object has been created yet. Therefore, when the base portion of the object is created, the call goes to the base virtual function.

The reverse appplies during destruction. Since the object is destroyed in reverse order, calling a virtual function in a destirctor results in a call to the local function since the derived portion of the object may have already been destroyed.

The net result is the the virtual keyword is ignored inside constructors and destructors.

[evenstar]

Thanks for your help.
I know during construction the base virtual function will be called.So What you said is not that I want to know.
I want to find the answer :why this part of code can go well:

BaseWithPureFunction::BaseWithPureFunction()    
{  
    /* 
      Call pure-virtual directly. 
      Running well.I puzzled. 
    */ 
          PureFunc();    
  } 
 

In my opnion,it will cause r6025 error,too.But...

[weaknessforcats]

You are creating a BaseEx object.

That object inherits BaseWithPureFunction::PureFunc.

You call BaseWithPureFunction::PureFunc from a BaseEx member function.

So what's the problem?

Remember, a pure virtual function cannot be called by an object of its class but it's OK to call it from some other object.

To enforce not calling BaseWithPureFunction::PureFunc using a BaseWithPureFunction object, the compiler will not allow you to create a BaseWithPureFunction object.

But can create a BaseEx object and call BaseWithPureFunction::PureFunc usign the BaseEx object.

[evenstar]

The fact was that I called the function of PureFunc directly and by the CallPureFunc function indirectly had different results.One is running well,but the other cause a error.Tow ways both invoked PureFunc function by the same types of 'this' pointer that pointed to base type,but they had different results.
Is there any ambiguous?

[weaknessforcats]

You should not be using CallWithPureFunc().

That function is a member function of the class BaseWithPureFunction and wghen you code:

BaseWithPureFunction  obj;
obj.CallWithPurFunc();

you a compile error that you can't create an object of an abstract class because you can't use a BaseWithPureFunction object to call a pure virtual function in the BaseWithPureFunction class.

However, you can code:

BaseEx  obj;
obj.BaseWithPureFunction::PureFunc();

to call PureFunc using a BaseEx object.

You could also:

BaseEx obj1;
obj1.PureFunc();

but no it's not cleas whether BaseEx::PureFunc() or BaseWithPureFunction::PureFunc() is being called unless you look in the code and see. Therefore, this is the preferred code:

BaseEx  obj;
obj.BaseWithPureFunction::PureFunc();

[evenstar]

Thanks again for your help.
At the point the base class constructor is invoked from the derived class constructor, the object ex is not yet of type BaseEx.The base class constructor initializes the BaseWithPureFunction subobject within ex to behave like a BaseWithPureFunction object. Therefore, when the virtual PureFunc is called in base class constructor, it binds to BaseWithPureFunction::PureFunc.According to holy,it should lead a error.But when I running this code it goes well.
So I altered BaseWithPureFunction constructor I made it invoke the BaseWithPureFunction::CallPureFunc.Then the virtual function PureFunc will be invoked by CallPureFunc.
When I running the code I have altered,a r6025 error appeared.
Two kinds of codes are both equal to using a BaseWithPureFunction object-a base object- to call a pure virtual function .
So I begin to think why two kinds of codes will lead differernt results.

[weaknessforcats]

The virtual keyword is suspended in constrcutors and destructors. It's like its not there.

Re-read my post #3.

[evenstar]

...My question has been answered?May be my expression is unclear.
Please look at the question again,and make sure what I want to know.Thank you.

#include <iostream>
using namespace std;
 
struct BaseWithPureFunction
{ 
    virtual void PureFunc() = 0;
 
    void CallPureFunc()
    {
        PureFunc();
    }
 
    BaseWithPureFunction();
};
 
BaseWithPureFunction::BaseWithPureFunction()
{
    PureFunc();//running well
    CallPureFunc(); //error.
  //Is there any difference between PureFunc and CallPureFunc.
}
 
void BaseWithPureFunction::PureFunc()
{
    cout << 3 << endl;
}
 
struct BaseEx : BaseWithPureFunction
{ 
    virtual void PureFunc()
    {
        cout << "BaseEx::PureFunc()" << endl;
    }
};
 
int main()
{
    BaseEx ex;
 
    return 0;
}
 
 

[weaknessforcats]

This is your code:

struct BaseWithPureFunction 
{  
    virtual void PureFunc() = 0; 
 
    void CallPureFunc() 
    { 
        PureFunc(); 
    } 
 
    BaseWithPureFunction(); 
}; 
 
BaseWithPureFunction::BaseWithPureFunction() 
{ 
    PureFunc();//running well 
    CallPureFunc(); //error. 
  //Is there any difference between PureFunc and CallPureFunc. 
} 

When you call PureFunc(), you really are calling
BaseWithPureFunction::PureFunc() because the virtual keyword is suspended inside a constructor.

However, when you are inside CallPureFunc() you may not be inside a constructor so when you call PureFunc() the VTBL is accessed and you bomb with a run-time error about calling a pure virtual function. All you need to do is tell the compiler to call the function without using the VTBL. That is, you need to specify the complete function name:

struct BaseWithPureFunction 
{  
    virtual void PureFunc() = 0; 
 
    void CallPureFunc() 
    { 
        BaseWithPureFunction::PureFunc(); 
    } 
 
    BaseWithPureFunction(); 
}; 

Now you are calling the function by name directly without using the VTBL. Now the program runs correctly.

[evenstar]

I finally understand.
Thank you very much indeed .