Under what circumstances is it advantageous to give an implementation of a pure virtual function?
c++, performance, pure-virtual
Solution
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.
Problem
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.