Under what circumstances is it advantageous to give an implementation of a pure virtual function?

Question

In C++, it is legal to give an implementation of a pure virtual function:

class C { public:   virtual int f() = 0; };  int C::f()  {   return 0; } 

Why would you ever want to do this?

Related question: The C++ faq lite contains an example:

class Funct { public:   virtual int doit(int x) = 0;   virtual ~Funct() = 0; };  inline Funct::~Funct() { }  // defined even though it's pure virtual; it's faster this way; trust me 

I don't understand why the destructor is declared pure virtual and then implemented; and I don't understand the comment why this should be faster.

Answer 1

Declared destructors must always be implemented as the implementation will call them as part of derived object destruction.

Other pure virtual functions may be implemented if they provide a useful common functionality but always need to be specialized. In the case, typically derived class implementations will make an explicit call to the base implementation:

void Derived::f() {     Base::f();      // Other Derived specific functionality } 

Typically, you make a destructor virtual if you need to make a class abstract (i.e. prevent non-derived instances from being created) but the class has no other functions that are naturally pure virtual. I think the 'trust me it's faster' is refering to the fact that because destructors called as part of derived object clean up don't need to use a vtable lookup mechanism, the inline implementation can be taken advantage of, unlike typical virtual function calls.