What are pure virtual functions in C++?

Pure virtual functions, also known as abstract functions, are virtual functions that are declared in a base class but have no implementation. They are specified by assigning the value 0 to the virtual function declaration.

When a class contains at least one pure virtual function, it becomes an abstract class. Abstract classes cannot be instantiated, but they can be used as base classes for other classes.

The purpose of pure virtual functions is to provide an interface that derived classes must implement. By defining a pure virtual function in a base class, you are essentially forcing any concrete derived class to provide its own implementation for that function.

Here's an example:

1#include <iostream>
2
3class Monster {
4 public:
5  virtual void attack() = 0;  
6};
7
8class Dragon : public Monster {
9 public:
10  void attack() override {
11    std::cout << "Dragon breathes fire!\n"; }
12};
13
14class Orc : public Monster {
15 public:
16  void attack() override {
17    std::cout << "Orc swings a club!\n"; }
18};
19
20int main() {
21  Monster* monsters[2];
22  monsters[0] = new Dragon();
23  monsters[1] = new Orc();
24
25  for (int i = 0; i < 2; ++i) {
26    monsters[i]->attack();
27  }
28
29  delete monsters[0];
30  delete monsters[1];
31}

1Dragon breathes fire!
2Orc swings a club!

In this example, the Monster class is an abstract class because it contains a pure virtual function attack(). The Dragon and Orc classes are concrete classes that inherit from Monster and provide their own implementations for the attack() function.

By using pure virtual functions, you can define an interface that derived classes must adhere to. This allows for polymorphic behavior and ensures that derived classes implement the required functionality.

Note that if a derived class does not implement all the pure virtual functions it inherits, it will also become an abstract class.

Pure virtual functions are a powerful tool for designing class hierarchies and enforcing contracts between base and derived classes.