Pure Virtual Function in C++

In this lesson: Pure virtual function syntax in C++, abstract vs concrete classes and interfaces — with example. In Hindi & English.

Quick recap

A pure virtual function is a virtual function with no base implementation, and a class holding one is abstract. This page is a compact syntax reference; for the concept, interfaces, and a full worked example, see the main abstract classes lesson.

The = 0 syntax

Write the virtual function, then = 0 instead of a body. The = 0 is the "pure specifier":

class Base {
public:
    virtual void run() = 0;    // pure virtual → Base is abstract
    virtual ~Base() {}
};

Pure virtual with a body

Unusually, a pure virtual can still have a definition, which derived classes may call explicitly. The class remains abstract:

class Base {
public:
    virtual void log() = 0;    // still pure/abstract
};
void Base::log() {             // optional shared body
    cout << "[Base log]\n";
}
// Derived can call Base::log(); explicitly

Abstract vs concrete

Derivation chains

If a derived class overrides only some inherited pure virtuals, it is still abstract:

class A { public: virtual void f() = 0; virtual void g() = 0; };
class B : public A { public: void f() override {} };  // g() still pure → B abstract
class C : public B { public: void g() override {} };  // now concrete

When a class is abstract

• It declares a pure virtual function (= 0), or
• It inherits one and does not override it.

Either way, objects of that class cannot be created — only pointers/references. This underpins polymorphism and virtual functions.

Common mistakes

• Putting = 0 on a non-virtual function (it must be virtual).
• Assuming a partly-overridden derived class is concrete.
• Trying to instantiate a class that still has an unimplemented pure virtual.
• Forgetting the virtual destructor in the abstract base.

Summary

• Pure virtual syntax is virtual T f() = 0;.
• A pure virtual may optionally have a body defined outside the class.
• Abstract = has a pure virtual; concrete = fully implemented.
• A partly-overridden subclass stays abstract.
• For concept and examples, see the main abstract classes lesson.