Abstract classes and pure virtual interfaces

Understanding Abstract classes and pure virtual interfaces

The = 0 after a virtual function declaration is not an assignment of any kind; it is a marker saying this class declares the operation but refuses to define it. Any class with at least one such unimplemented operation is abstract, and the compiler will not let you create an object of it: not as a local, not as a data member by value, not as an array element, not through new. The reason is direct rather than arbitrary. An object of that class would expose a member function callers are entitled to invoke, and there is nothing to run, so the language rejects the request for an object instead of waiting for the call.

Abstract does not mean empty. An abstract class may hold data members, define constructors that derived classes are forced to call, and implement ordinary member functions, including virtual ones that carry a usable default. That combination gives a shape worth reaching for: a public non-virtual function in the base expresses the fixed part of an algorithm and delegates only the varying steps to its own pure virtuals. Callers get a single entry point, and each derived class supplies just the decisions that genuinely differ.

What people call an interface in C++ is the extreme case of this: an abstract class with no data, nothing but pure virtual functions and a virtual destructor. Abstractness is a per-class property that is recomputed for every derived class, so if you override three of four pure virtuals your class is still abstract, and the diagnostic appears at the first attempt to instantiate it rather than at the missing override. Since a value of an abstract type can never exist, polymorphic code refers to it as Base& or unique_ptr<Base>, which is why interfaces show up in parameter lists and members but never as return-by-value types.

#include <cstddef>
#include <iostream>
#include <memory>
#include <string>
#include <vector>

class Compressor {
public:
    virtual ~Compressor() = default;

    // No sensible generic implementation exists: every format differs.
    virtual std::string name() const = 0;
    virtual std::string pack(const std::string& data) const = 0;

    // Concrete code living in the abstract base, phrased via the pure virtuals.
    void report(const std::string& data) const {
        std::string out = pack(data);
        std::cout << name() << ": " << data.size() << " -> " << out.size()
                  << " bytes (" << out << ")\n";
    }
};

class RunLength : public Compressor {
public:
    std::string name() const override { return "rle"; }
    std::string pack(const std::string& data) const override {
        std::string out;
        for (std::size_t i = 0; i < data.size();) {
            std::size_t j = i;
            while (j < data.size() && data[j] == data[i]) ++j;
            out += data[i];
            out += std::to_string(j - i);
            i = j;
        }
        return out;
    }
};

class Identity : public Compressor {
public:
    std::string name() const override { return "none"; }
    std::string pack(const std::string& data) const override { return data; }
};

int main() {
    // Compressor c;  // error: cannot declare an object of abstract type
    std::vector<std::unique_ptr<Compressor>> pipeline;
    pipeline.push_back(std::make_unique<RunLength>());
    pipeline.push_back(std::make_unique<Identity>());

    for (const auto& c : pipeline)
        c->report("aaabbbbcc");
}

Worked examples

#include <iostream>

class Logger {
public:
    virtual ~Logger() = default;
    virtual void write(const char* msg) = 0;
    virtual void flush() = 0;
};

// A pure virtual function may be defined, but only out of line.
void Logger::write(const char* msg) {
    std::cout << "[base] " << msg << "\n";
}

class Timestamped : public Logger {   // still abstract: flush() not overridden
public:
    void write(const char* msg) override {
        std::cout << "12:00 ";
        Logger::write(msg);           // reuse the shared part
    }
};

class Console : public Timestamped {
public:
    void flush() override { std::cout << "[flushed]\n"; }
};

int main() {
    // Timestamped t;   // error: flush() is still pure here
    Console c;
    Logger& l = c;
    l.write("ready");
    l.flush();
}

#include <iostream>
#include <type_traits>

struct Validator {
    virtual ~Validator() = default;
    virtual bool check(int v) const = 0;
    virtual const char* why() const = 0;
};

struct Positive : Validator {
    bool check(int v) const override { return v > 0; }
    // why() left alone, so it stays pure
};

struct PositiveMsg : Positive {
    const char* why() const override { return "must be > 0"; }
};

int main() {
    std::cout << std::boolalpha;
    std::cout << "Validator abstract:   " << std::is_abstract_v<Validator> << "\n";
    std::cout << "Positive abstract:    " << std::is_abstract_v<Positive> << "\n";
    std::cout << "PositiveMsg abstract: " << std::is_abstract_v<PositiveMsg> << "\n";

    PositiveMsg v;
    const Validator& ref = v;   // naming an abstract type is fine
    std::cout << ref.check(-3) << " " << ref.why() << "\n";
}

Important notes

Common mistakes

Try it yourself