Thread: Why constructor can not call pure virtual functions?

================================================== =====

UPDATE:
I think my original post was a little misleading. Here is what I indeed want to know:
When I use this->foo() in the following code, it works, even for a pure virtual function;

Code:

class A{                                                                                                                                                                     
public:                                                                                                                                                                      
    A(){                                                                                                                                                                     
        this->foo();
    }                                                                                                                                                                        
    ~A(){}                                                                                                                                                                   
    virtual void foo()=0;                                                                                                                                                    
};                                                                                                                                                                           
                                                                                                                                                                             
void A::foo(){        cout<<"Class A"<<endl; }                                                                                                                             
                                                                                                                                                                             
class B: public A{                                                                                                                                                           
public:                                                                                                                                                                      
    B(){                                                                                                                                                                     
        this->foo();
    }                                                                                                                                                                        
    ~B(){}                                                                                                                                                                   
    void foo(){                                                                                                                                                              
        cout<<"Class B"<<endl;                                                                                                                                               
    }                                                                                                                                                                        
};                                                                                                                                                                           
                                                                                                                                                                             
int main()                                                                                                                                                                   
{                                                                                                                                                                            
    B obj;                                                                                                                                                                   
    return 0;                                                                                                                                                                
}

But when I use foo() instead, I got the compile-time error

Code:

class A{                                                                                                                                                                     
public:                                                                                                                                                                      
    A(){                                                                                                                                                                     
        foo();
    }                                                                                                                                                                        
    ~A(){}                                                                                                                                                                   
    virtual void foo()=0;                                                                                                                                                    
};                                                                                                                                                                           
                                                                                                                                                                             
void A::foo(){        cout<<"Class A"<<endl; }                                                                                                                             
                                                                                                                                                                             
class B: public A{                                                                                                                                                           
public:                                                                                                                                                                      
    B(){
        foo();                                                                                                                                                             
    }                                                                                                                                                                        
    ~B(){}                                                                                                                                                                   
    void foo(){                                                                                                                                                              
        cout<<"Class B"<<endl;                                                                                                                                               
    }                                                                                                                                                                        
};                                                                                                                                                                           
                                                                                                                                                                             
int main()                                                                                                                                                                   
{                                                                                                                                                                            
    B obj;                                                                                                                                                                   
    return 0;                                                                                                                                                                
}

So I wonder what's the difference between this->foo() and foo() in my code?

================================================== ========
Original Post:

Why constructor can not call a pure virtual function, even if it's defined?
Another question is what's the difference between this->foo() and foo() ?
In my opinion they are the same.

Code:

class A{                                                                                                                                                                     
public:                                                                                                                                                                      
    A(){                                                                                                                                                                     
        //this->foo();                                                                                                                                                       
        foo();                                                                                                                                                               
    }                                                                                                                                                                        
    ~A(){}                                                                                                                                                                   
    virtual void foo()=0;                                                                                                                                                    
};                                                                                                                                                                           
                                                                                                                                                                             
void A::foo(){  cout<<"Class A"<<endl; }                                                                                                                                     
                                                                                                                                                                             
class B: public A{                                                                                                                                                           
public:                                                                                                                                                                      
    B(){                                                                                                                                                                     
        //this->foo();                                                                                                                                                       
        foo();                                                                                                                                                               
    }                                                                                                                                                                        
    ~B(){}                                                                                                                                                                   
    virtual void foo(){                                                                                                                                                      
        cout<<"Class B"<<endl;                                                                                                                                               
    }                                                                                                                                                                        
};                                                                                                                                                                           
                                                                                                                                                                             
int main()                                                                                                                                                                   
{                                                                                                                                                                            
    B obj;                                                                                                                                                                   
    return 0;                                                                                                                                                                
}

Why constructor can not call a pure virtual function, even if it's defined?

I believe you have to qualify pure virtual functions in order to call them:

Code:

A(){
    A::foo();
}

That said, read this related FAQ: When my base class's constructor calls a virtual function on its this object, why doesn't my derived class's override of that virtual function get invoked?

Another question is what's the difference between this->foo() and foo() ?
In my opinion they are the same.

Generally, yes. An exception has to do with templates, where if foo is a non-dependent name, this->foo() will cause the correct name lookup.

I tried, but the volume of posts in this forum is so high that my searches were in vain. Perhaps I searched with the wrong keywords. Anyway, you can read this related FAQ: Why am I getting errors when my template-derived-class uses a member it inherits from its template-base-class?

Thanks again. I think my original post was a little misleading. Here is what I indeed want to know:
When I use this->foo() in the following code, it works, even for a pure virtual function;

Code:

class A{                                                                                                                                                                     
public:                                                                                                                                                                      
    A(){                                                                                                                                                                     
        this->foo();
    }                                                                                                                                                                        
    ~A(){}                                                                                                                                                                   
    virtual void foo()=0;                                                                                                                                                    
};                                                                                                                                                                           
                                                                                                                                                                             
void A::foo(){        cout<<"Class A"<<endl; }                                                                                                                             
                                                                                                                                                                             
class B: public A{                                                                                                                                                           
public:                                                                                                                                                                      
    B(){                                                                                                                                                                     
        this->foo();
    }                                                                                                                                                                        
    ~B(){}                                                                                                                                                                   
    void foo(){                                                                                                                                                              
        cout<<"Class B"<<endl;                                                                                                                                               
    }                                                                                                                                                                        
};                                                                                                                                                                           
                                                                                                                                                                             
int main()                                                                                                                                                                   
{                                                                                                                                                                            
    B obj;                                                                                                                                                                   
    return 0;                                                                                                                                                                
}

But when I use foo() instead, I got the compile-time error

Code:

class A{                                                                                                                                                                     
public:                                                                                                                                                                      
    A(){                                                                                                                                                                     
        foo();
    }                                                                                                                                                                        
    ~A(){}                                                                                                                                                                   
    virtual void foo()=0;                                                                                                                                                    
};                                                                                                                                                                           
                                                                                                                                                                             
void A::foo(){        cout<<"Class A"<<endl; }                                                                                                                             
                                                                                                                                                                             
class B: public A{                                                                                                                                                           
public:                                                                                                                                                                      
    B(){
        foo();                                                                                                                                                             
    }                                                                                                                                                                        
    ~B(){}                                                                                                                                                                   
    void foo(){                                                                                                                                                              
        cout<<"Class B"<<endl;                                                                                                                                               
    }                                                                                                                                                                        
};                                                                                                                                                                           
                                                                                                                                                                             
int main()                                                                                                                                                                   
{                                                                                                                                                                            
    B obj;                                                                                                                                                                   
    return 0;                                                                                                                                                                
}

So I wonder what's the difference between this->foo() and foo() in my code?

When I use this->foo() in the following code, it works, even for a pure virtual function;

I am not sure what the standard says, but I believe this is the same case as qualifying the pure virtual function call. Consider: it does not normally make sense to call a pure virtual function itself. One might appear to call it, but typically expect that its override would be called.

Originally Posted by meili100

Thanks again. I think my original post was a little misleading. Here is what I indeed want to know:
When I use this->foo() in the following code, it works, even for a pure virtual function;

But when I use foo() instead, I got the compile-time error

So I wonder what's the difference between this->foo() and foo() in my code?

I get no compile error with foo() or this->foo() in either A or B, with VS2005 Express. Also, the code performed as expected.

I suspect you're running an old compiler.

I get no compile error with foo() or this->foo() in either A or B, with VS2005 Express. Also, the code performed as expected.

I suspect you're running an old compiler.

The MinGW port of g++ 3.4.5 reports an error. The Comeau online compiler reports a warning. Personally, I think a warning is more proper since an implementation was provided.

However, to settle this, the C++ Standard section 10.4 states:

Member functions can be called from a constructor (or destructor) of an abstract class; the effect of making a virtual call (10.3) to a pure virtual function directly or indirectly for the object being created (or destroyed) from such a constructor (or destructor) is undefined.

Obligatory counter-example: GCC 4.2 tells me this:

Code:

g++     pure.cpp   -o pure
/tmp/ccWd2q3c.o: In function `foo::foo()':
pure.cpp:(.text._ZN3fooC2Ev[foo::foo()]+0x1d): undefined reference to `foo::beep()'

for:

Code:

#include <iostream>

class foo
{
public:
  foo() { this->beep(); }
  virtual ~foo() {}
  virtual void beep() = 0;
};

class bar : public foo
{
public:
  bar() {}
  virtual void beep() { std::cout << "beep\n"; }
};

int main()
{
  bar b;
}

I get the same error message and a warning if I remove the explicit this.

CornedBee, you forgot to implement foo::beep(). That would explain the "undefined reference to `foo::beep()'".

It's pure virtual. Why would I implement it?

(Yeah, I know there are situations. But still ...)

It's pure virtual. Why would I implement it?

To keep in line with meili100's question. If not, your "obligatory counter-example" is not a counter-example at all, but a slightly different example that thus results in a different set of compiler errors/warnings.

EDIT:
Then again, your counter-example is definitely not a counter-example since grumpy mused that "the compiler that allows this->foo() to compile is exercising that rule", but you got a linker error, not a compiler error.