Abstract Classes and Pure Virtual Methods
Define interfaces with pure virtual methods and enforce derived-class contracts.
Abstract Classes and Pure Virtual Methods is a free C++ Academy lesson on CoddyKit. This is lesson 3 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the C++ Academy learning path, and your progress syncs across the web and the CoddyKit app. The C++ Academy course includes 4 lessons in total.
What is an Abstract Class?
An abstract class has at least one pure virtual function — declared with = 0. You cannot instantiate it directly.
class Animal {
public:
virtual void speak() const = 0; // pure virtual
virtual ~Animal() = default;
};
// Animal a; // ERROR: cannot instantiatePure Virtual Functions
The = 0 marks a function as having no default implementation. Derived classes must override it before the class can be instantiated.
Implementing the Interface
Derived classes provide concrete bodies for every pure virtual.
class Dog : public Animal {
public:
void speak() const override {
std::cout << "Woof!\n";
}
};
Dog d;
d.speak(); // Woof!Abstract Classes as Interfaces
An abstract class with only pure virtual methods (and no data members) acts like an interface in other languages.
class Drawable {
public:
virtual void draw() const = 0;
virtual ~Drawable() = default;
};Combining Implementation and Interface
Abstract classes can have both pure virtual methods and concrete methods. Pure virtuals define the contract; concrete methods give shared behavior.
class Logger {
public:
void logInfo(const std::string& msg) { log("INFO", msg); }
void logError(const std::string& msg) { log("ERROR", msg); }
protected:
virtual void log(const std::string& level, const std::string& msg) = 0;
};Pure Virtual with a Default Body
A pure virtual can have a body — useful as a default that derived classes can call.
class Base {
public:
virtual void f() = 0;
};
void Base::f() {
std::cout << "default behavior\n";
}
class Derived : public Base {
public:
void f() override {
Base::f(); // call the default
std::cout << "extra\n";
}
};Use Through Pointers and References
Polymorphic code holds abstract objects through pointers or references to the base type.
void perform(const Animal& a) {
a.speak();
}Storing in Containers
Vectors cannot hold abstract types by value. Use pointers — typically smart pointers.
std::vector<std::unique_ptr<Animal>> zoo;
zoo.push_back(std::make_unique<Dog>());
zoo.push_back(std::make_unique<Cat>());
for (auto& a : zoo) a->speak();When to Use Abstract Classes
Use them when:
- You want to define a common interface for multiple unrelated implementations
- You need a base type for polymorphic containers
- You want to inject behavior via subclasses (Template Method pattern)
Alternatives: Concepts and Templates
For compile-time polymorphism, C++20 concepts and templates often replace abstract classes — zero runtime cost. Use virtual when polymorphism is needed at runtime.
Pitfall: Slicing
Pass abstract classes by reference or pointer. Pass-by-value is impossible anyway (cannot instantiate abstract type) — but derived classes pass-by-value would slice.
Quick Check
What makes a class abstract in C++?
Recap
Abstract classes — those with at least one pure virtual method — define interfaces for polymorphic code. Use them with pointers or references (often smart pointers) to dispatch behavior at runtime.
Learn C++ with an AI tutor — free
Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.
- Courses
- 51
- Lessons
- 203
Frequently Asked Questions
Is the “Abstract Classes and Pure Virtual Methods” lesson free?
Yes — any 3 lessons of the C++ Academy learning path, including “Abstract Classes and Pure Virtual Methods”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The C++ Academy course includes 4 lessons in total.
What will I learn in “Abstract Classes and Pure Virtual Methods”?
Define interfaces with pure virtual methods and enforce derived-class contracts. You practise C++ Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start C++ Academy?
No prior experience is required. C++ Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.
How long does the “Abstract Classes and Pure Virtual Methods” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this C++ Academy lesson?
Yes. Every C++ Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Single and Multiple Inheritance
- Virtual Functions and the vtable
- Abstract Classes and Pure Virtual Methods
- Inheritance vs Composition Trade-offs