C++ Composition and Runtime Polymorphism

Composition models a has-a or uses-a relationship. A reminder service uses a message sink; it is not a kind of message sink. Supplying that collaborator through the constructor or function makes the dependency visible and replaceable.

Many designs need only concrete composition. Introduce an interface when multiple providers, isolated testing, or a stable boundary creates real variation. An interface for every class adds indirection without flexibility.

#include <iostream>
#include <string_view>

class ConsoleSink
{
public:
  void send(std::string_view message) const
  {
      std::cout << message << '\n';
  }
};

class ReminderService
{
public:
  explicit ReminderService(const ConsoleSink& sink) : sink_{sink} {}
  void remind() const { sink_.send("Practice one example"); }
private:
  const ConsoleSink& sink_;
};

int main() { ConsoleSink sink; ReminderService service{sink}; service.remind(); }

A pure virtual function declares a contract that derived classes must implement. Calling through a base reference or pointer selects the derived override at runtime. Add override so the compiler verifies that a derived declaration actually matches a virtual base operation.

Keep interfaces small and caller-oriented. A sink needs send; it does not need every configuration operation of each concrete delivery system.

Pass polymorphic objects by reference or pointer to preserve dynamic type. If ownership transfers, std::unique_ptr<Base> commonly owns one derived object. A virtual base destructor ensures destruction reaches the derived resources.

Non-owning references must not outlive the implementation. Constructor injection by reference works when the composition root owns providers longer than their consumers. Use unique ownership when that lifetime relationship needs to be stored and transferred.

Public inheritance says a derived object can safely stand wherever the base is expected without breaking the base contract. Reusing a few lines of implementation is not enough. Deep hierarchies spread behavior across files and make construction and ownership harder to see.

Prefer composition for interchangeable roles and helpers. Use inheritance when the abstraction is stable, substitution is meaningful, and runtime dispatch is truly required.