C++ pure virtual function have body

Pure virtual functions (when we set = 0) can also have a function body.

What is the use to provide a function body for pure virtual functions, if they are not going to be called at all?

Your assumption that pure virtual function cannot be called is absolutely incorrect. When a function is declared pure virtual, it simply means that this function cannot get called dynamically, through a virtual dispatch mechanism. Yet, this very same function can easily be called statically, non-virtually, directly (without virtual dispatch).

In C++ language a non-virtual call to a virtual function is performed when a qualified name of the function is used in the call, i.e. when the function name specified in the call has the <class name>::<function name> form.

For example

struct S 
{
  virtual void foo() = 0;
};

void S::foo() 
{
  // body for pure virtual function `S::foo`
}

struct D : S 
{
  void foo() 
  {
    S::foo();       
    // Non-virtual call to `S::foo` from derived class

    this->S::foo(); 
    // Alternative syntax to perform the same non-virtual call 
    // to `S::foo` from derived class
  }
};

int main() 
{
  D d;

  d.S::foo(); 
  // Another non-virtual call to `S::foo`
}

> "Effective C++" Meyers mentions a > reason for a pure virtual function to > have a body: Derived classes that > implement this pure virtual function > may call this implementation smwhere > in their code. If part of the code of > two different derived classes is > similar then it makes sense to move it > up in the hierarchy, even if the > function should be pure virtual.

see here.

For most pure virtual functions, you'd be right. However, for a pure virtual destructor, it's actually important to define a corresponding destructor implementation:

• The "pure virtual" is to require derived classes to implement their destructor.
• Your base class destructor implementation is so that the derived class destructors can successfully "chain up" afterwards.