Pure Virtual vs Virtual

A regular virtual function is a member function that you can override in derived classes to provide specific implementations.

When a function is marked as virtual in the base class, it allows derived classes to override it, providing different behavior for each derived type.

A pure virtual function, on the other hand, is a function that has no implementation in the base class and must be overridden in any derived class.

This is done by assigning the function to 0 in the base class. Pure virtual functions make the base class abstract, meaning you cannot create objects of this class directly.

Here's an example:

1#include <iostream>
2#include <string>
3
4class Character {
5public:
6  virtual std::string GetTaunt() {
7    return "???";
8  }
9  virtual std::string GetName() = 0; 
10};
11
12class Orc : public Character {
13public:
14  std::string GetTaunt() override {
15    return "Come get some!";
16  }
17  std::string GetName() override {
18    return "Orc";
19  }
20};
21
22int main() {
23  Orc basher;
24  std::cout << basher.GetName() << ": "
25    << basher.GetTaunt() << "\n";
26}

1Orc: Come get some!

In this example:

• GetTaunt() is a regular virtual function. It has a default implementation in the Character class but can be overridden in derived classes.
• GetName() is a pure virtual function. It does not have an implementation in the Character class and must be overridden in derived classes.

Pure virtual functions enforce a contract that derived classes must adhere to, ensuring they provide specific functionality. Regular virtual functions allow base classes to provide default behavior while still allowing derived classes to override that behavior.