How to Declare an Interface in C++: Abstract Base Classes Explained

By the end of this page, you will understand how C++ represents interfaces using abstract base classes, what pure virtual functions do, why virtual destructors matter, and how concrete classes implement those interfaces in real code.

In C++, there is no separate interface keyword like in some other languages such as Java or C#. Instead, the usual way to model an interface is to create an abstract base class.

A class becomes abstract when it contains at least one pure virtual function. A pure virtual function is declared by assigning = 0 at the end of the function declaration.

class Shape {
public:
    virtual double area() const = 0;
};

This means:

• Shape cannot be instantiated directly.
• Any derived class must provide an implementation for area() unless it is also abstract.
• The class acts as a contract: derived classes promise to provide certain behavior.

In practice, an interface-style class in C++ usually has:

• only pure virtual functions
• no data members
• a virtual destructor

For example:

class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void log(const std::string& message) = 0;
};

This pattern matters because it lets you write code against a common contract instead of a specific implementation. That makes code easier to extend, test, and reuse.

For example, code can depend on ILogger without caring whether the real object writes to a file, the console, or a remote service.

Although an interface in C++ is usually an abstract base class, not every abstract base class is used purely as an interface. Some abstract base classes also contain shared implementation or member data. So the key idea is:

• Interface-style class: abstract base class used mainly as a contract
• General abstract base class: abstract class that may also provide reusable implementation

Think of an interface in C++ like a job description.

The interface says:

• what tasks must be done
• what function names and signatures must exist
• but not exactly how the work is performed

For example, a Printer interface might say every printer must support print().

A laser printer and a PDF printer both satisfy the same job description, but they do the work differently.

So:

• the interface is the contract
• the derived class is the worker fulfilling that contract
• the pure virtual functions are the required tasks

This is why abstract base classes are used for interfaces in C++: they define required behavior without forcing one specific implementation.

Basic interface-style class in C++

class IAnimal {
public:
    virtual ~IAnimal() = default;
    virtual void speak() const = 0;
};

What this means

• IAnimal is abstract because speak() is pure virtual.
• virtual ~IAnimal() = default; makes destruction safe through a base-class pointer.
• You cannot create an IAnimal directly.

Implementing the interface

#include <iostream>
using namespace std;

class IAnimal {
public:
    virtual ~IAnimal() = default;
    virtual void speak()  = ;
};

  :  IAnimal {
:
    {
        cout << ;
    }
};

{
    Dog d;
    d.();
}

Consider this example:

#include <iostream>
using namespace std;

class IAnimal {
public:
    virtual ~IAnimal() = default;
    virtual void speak() const = 0;
};

class Dog : public IAnimal {
public:
    void speak() const override {
        cout << "Woof\n";
    }
};

int main() {
    IAnimal* animal = new Dog();
    animal->speak();
    delete animal;
}

Step-by-step

1. IAnimal is declared with a pure virtual function speak().

Interfaces in C++ are commonly used when multiple classes should provide the same behavior in different ways.

Common examples

• Logging systems

  • ILogger can be implemented by ConsoleLogger, FileLogger, or NetworkLogger.

• Payment providers

  • IPaymentProcessor can be implemented by Stripe, PayPal, or a mock test processor.

• Game engines

  • IRenderer might have OpenGL, Vulkan, or DirectX implementations.

• Device drivers

  • A common interface can describe devices that read data, while each device class handles hardware-specific details.

• Testing and mocking

  • If your code depends on an interface, you can replace the real class with a fake or mock version in tests.

Example scenario

class IDataStore {
public:
    virtual ~() = ;
    = ;
};

In real projects, interface-style classes are often used to separate what a system does from how it does it.

Common patterns

Dependency injection

A class receives an interface instead of creating a concrete dependency directly.

class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void log(const std::string& message) = 0;
};

class Service {
private:
    ILogger& logger;

public:
    Service(ILogger& logger) : logger(logger) {}

    void run() {
        logger.log("Service started");
    }
};

This makes Service easier to test and reuse.

Testing with fake implementations

class FakeLogger : public ILogger {
public:
    {
        
    }
};

1. Forgetting the virtual destructor

This is one of the most important mistakes.

Broken code

class IAnimal {
public:
    virtual void speak() const = 0;
};

If you delete a derived object through an IAnimal*, behavior is unsafe because the base destructor is not virtual.

Correct code

class IAnimal {
public:
    virtual ~IAnimal() = default;
    virtual void speak() const = 0;
};

2. Trying to instantiate the interface

Broken code

IAnimal animal;

This fails because IAnimal is abstract.

Fix

Instantiate a concrete derived class instead.

Interface-style class vs abstract base class

• Every interface-style class in C++ is typically an abstract base class.
• But not every abstract base class is a pure interface.
• Some abstract base classes include common logic for derived classes.

Pure virtual vs regular virtual

Quick reference

Declare an interface-style class

class IExample {
public:
    virtual ~IExample() = default;
    virtual void doWork() = 0;
};

Implement it

class Example : public IExample {
public:
    void doWork() override {
        // implementation
    }
};

Rules to remember

• C++ has no built-in interface keyword.
• Use an abstract base class to model an interface.
• A class becomes abstract when it has at least one pure virtual function.
• Pure virtual syntax: virtual ReturnType name(...) = 0;
• Add a virtual destructor for safe polymorphic deletion.
• Use override in derived classes.
• You cannot instantiate an abstract class directly.

Is there an interface keyword in C++?

No. C++ usually models interfaces with abstract base classes containing pure virtual functions.

Is an interface in C++ just an abstract base class?

Usually yes. More specifically, an interface-style class is an abstract base class used mainly to define a contract.

What makes a class abstract in C++?

A class is abstract if it has at least one pure virtual function, written with = 0.

Why should an interface have a virtual destructor?

So deleting an object through a base-class pointer works correctly and safely.

Can an abstract base class contain normal method implementations?

Yes. An abstract base class can contain both pure virtual and fully implemented methods. If it does, it is not a pure interface-only design.

Can an interface in C++ have member variables?

It can, but interface-style classes usually avoid data members and focus only on behavior.

Should I use override when implementing interface methods?

Yes. It helps the compiler detect signature mismatches and makes code clearer.

• Pure virtual functions — These are the mechanism that make a class abstract in C++.
• Virtual functions — They enable runtime polymorphism and dynamic dispatch.
• Abstract classes — The broader category that includes interface-style classes.
• Inheritance — Interfaces are implemented through class inheritance.
• Polymorphism — Interfaces are mainly used to enable polymorphic behavior.
• Virtual destructors — Important for safely deleting derived objects through base pointers.
• Override specifier — Helps ensure derived methods correctly match the interface.
• Dependency injection — Interfaces are commonly used to inject interchangeable dependencies.
• Smart pointers — Frequently used to manage polymorphic objects safely in modern C++.