=0 Question

class Animal{public:                    Animal( );    void            Speak( );    void            Move(float fDistance);}

class Animal{public:                    Animal( );    virtual         ~Animal( );    virtual void    Speak( );    virtual void    Move(float fDistance);}

class Dog : public Animal{public:                    Dog( );    void            Speak( );    void            Move(float fDistance);}

virtual void        Speak( ) = 0;

Quote:

Original post by Sc4Freak You can't call the pure virtual function itself - because it has no implementation. That's why you can't instantiate an abstract class and why you can't even attempt to call the pure virtual function.

class abstractBase{public:    virtual void Func() = 0    {        cout << "In abstract base!" << endl;    }    abstractBase();    virtual ~abstractBase();};class concreteDerived : public abstractBase{public:    void Func()    {        cout << "In concrete derived!" << endl;        abstractBase::Func();    // NOTE call to pure virtual function    }    concreteDerived();    ~concreteDerived();};

Quote:

Original post by SunTzu Quote: Original post by Sc4Freak You can't call the pure virtual function itself - because it has no implementation. That's why you can't instantiate an abstract class and why you can't even attempt to call the pure virtual function. Not true. It is entirely possible to both implement and call a pure virtual function. Pure only means that derived classes must override it with an implementation of their own, or else they are not allowed to be instantiated. By your logic, a "pure virtual function" would simply be a virtual function with no implementation, and the =0 syntax would be redundant. As proof try the following: Create an object of type concreteDerived, call it's Func(), watch what happens. Scott Meyers mentions a case where this might be a useful technique in More Effective C++ but I don't have that book with me and can't think of a useful application for it off the top of my head... but it can be done.

Quote:

Original post by SunTzu Scott Meyers mentions a case where this might be a useful technique in More Effective C++ but I don't have that book with me and can't think of a useful application for it off the top of my head... but it can be done.

  #include <iostream>  // Base is an ABC (abstract base class).  class Base  {  public:    ~Base() = 0;  }  Base::~Base()  {    std::cerr << "Base destructor called.\n";  }  // Derived is a concrete implementation.  class Derived: public Base  {  public:    ~Derived()    {      std::cerr << "Derived destructor called.\n";    }  };  int main()  {    Base* pBase = new Derived();    // use pBase to do something sinful and fattening    delete pBase;  }

Quote:

Original post by BregmaHere's where you're required to have an pure virual function with an implementation.