class B {

public: /*…other stuff…*/

virtual ~B() = 0; // pure virtual dtor

};

Of course, any derived class’ destructor must call the base class’ destructor, and so the destructor must still be defined (even if it’s empty):

// file b.cpp

B::~B() { /* possibly empty */ }

If this definition were not supplied, you could still derive classes from B but they could never be instantiated, which isn’t particularly useful.

How many pure virtual functions can an abstract class have?

It is pretty common to be confused as to how many pure virtual functions can an abstract class have – well, the answer is zero; here are few simple examples of pure virtual function in c++.

class AbstractClass {
public:
// declare a pure virtual function:
// this class is now abstract
virtual void f(int) = 0;
};

class StillAbstract : public AbstractClass {
// does not override f(int),
// so this class is still abstract
};

class Concrete : public StillAbstract {
public:
// finally overrides f(int),
// so this class is concrete
void f(int) { /*…*/ }
};

AbstractClass a; // error, abstract class
StillAbstract b; // error, abstract class
Concrete c; // ok, concrete class