Yes. You also need to implement the destructor: class A { public: virtual ~A() = 0; }; inline A::~A() { } should suffice. If you derive anything from A and then try to delete or destroy it, A‘s destructor will eventually be called. Since it is pure and doesn’t have an implementation, undefined behavior will … Read more
Probably the real reason that pure virtual destructors are allowed is that to prohibit them would mean adding another rule to the language and there’s no need for this rule since no ill-effects can come from allowing a pure virtual destructor. Nope, plain old virtual is enough. If you create an object with default implementations … Read more
A pure virtual function must be implemented in a derived type that will be directly instantiated, however the base type can still define an implementation. A derived class can explicitly call the base class implementation (if access permissions allow it) by using a fully-scoped name (by calling A::f() in your example – if A::f() were … Read more
A virtual function makes its class a polymorphic base class. Derived classes can override virtual functions. Virtual functions called through base class pointers/references will be resolved at run-time. That is, the dynamic type of the object is used instead of its static type: Derived d; Base& rb = d; // if Base::f() is virtual and … Read more
To expand on the answer by bradtgmurray, you may want to make one exception to the pure virtual method list of your interface by adding a virtual destructor. This allows you to pass pointer ownership to another party without exposing the concrete derived class. The destructor doesn’t have to do anything, because the interface doesn’t … Read more