C++ Abstract Classes

A function that must be filled in

A virtual function with = 0 is pure virtual. The base class says the name and the signature. It does not say the body. Any class that contains a pure virtual function is abstract: the compiler will not let you make an object of that type.

You inherit the abstract class and write the missing function in each derived class. That is the contract: every concrete shape can answer kind(), but there is no generic shape sitting in memory with a fake answer. Include <string> when the function returns string.

virtual string kind() = 0

Write virtual string kind() = 0; in the base. In each derived class, writestring kind() override and return a label. override asks the compiler to check that you really replaced the base function.

Shape s; does not compile. Circle c; does, because Circle provideskind(). The polymorphism chapter used a base that still had a body. Here the base has none.

Two derived types, one Shape reference

You can still use the abstract type as a reference or a pointer. A function that takesShape& will accept a Circle or a Square. The call tokind() runs the derived version.

#include <iostream>
#include <string>
using namespace std;

class Shape {
public:
  virtual string kind() = 0;
};

class Circle : public Shape {
public:
  string kind() override {
    return "circle";
  }
};

class Square : public Shape {
public:
  string kind() override {
    return "square";
  }
};

void show(Shape& s) {
  cout << s.kind() << endl;
}

int main() {
  Circle c;
  Square q;
  show(c);
  show(q);
  return 0;
}

Output is circle then square. The objects live on the stack.show never names Circle or Square. UncommentingShape s; inside main is a compile error.

Call kind on the objects directly

Direct calls work too. You do not need a helper. The reference version matters when one function must handle every kind of shape without a growing if chain.

#include <iostream>
#include <string>
using namespace std;

class Shape {
public:
  virtual string kind() = 0;
};

class Circle : public Shape {
public:
  string kind() override {
    return "circle";
  }
};

class Square : public Shape {
public:
  string kind() override {
    return "square";
  }
};

int main() {
  Circle c;
  Square q;
  cout << c.kind() << endl;
  cout << q.kind() << endl;
  return 0;
}

A vector of unique_ptr

A vector<Shape> is impossible: the vector would have to construct Shapeobjects. Store owning pointers instead. unique_ptr<Shape> from <memory>holds a derived object and frees it when the pointer dies. Give the base a virtual destructor so that delete through the base pointer runs the right cleanup.

#include <iostream>
#include <memory>
#include <string>
#include <vector>
using namespace std;

class Shape {
public:
  virtual string kind() = 0;
  virtual ~Shape() = default;
};

class Circle : public Shape {
public:
  string kind() override {
    return "circle";
  }
};

class Square : public Shape {
public:
  string kind() override {
    return "square";
  }
};

int main() {
  vector<unique_ptr<Shape>> shapes;
  shapes.push_back(make_unique<Circle>());
  shapes.push_back(make_unique<Square>());
  for (const unique_ptr<Shape>& s : shapes) {
    cout << s->kind() << endl;
  }
  return 0;
}

make_unique<Circle>() is C++14 and legal in C++17. s->kind() is a virtual call through the pointer. You do not write delete: unique_ptr does that when the vector is destroyed.

Rules that keep this small

• Pure virtual: virtual string kind() = 0; in the base.
• Each concrete class writes kind() with override.
• Do not construct the abstract type. Construct Circle or Square.
• Pass Shape& for stack objects. Use unique_ptr<Shape> when you need a list.
• If you delete through Shape*, the destructor in Shape must be virtual.

When a class should be abstract

Use an abstract base when every derived type must supply a behavior and a default in the base would be a lie. A shape that cannot say what it is should not exist. A file reader that cannot read should not exist. Shared fields and non-virtual helpers can still live in the base; only the required hook is pure.

If the base can provide a reasonable default, a plain virtual function is enough — that was the Animal example in the polymorphism chapter. Pure virtual is the stricter tool.

End of the C++ track

This is the last chapter. Return to /cpp for the full list, or to/cpp/examples for complete programs you can copy. Anything that still feels new compiles at /cpp/try.