Curiously Recurring Template Pattern

The Curiously Recurring Template Pattern is an idiom in which a class X derives from a class template Y, taking a template parameter Z, where Y is instantiated with Z=X.

CRTP may be used to implement "compile-time polymorphism", when a base class exposes an interface, and derived classes implement such interface.

Declare shape class with derived type as template parameter

template <typename derived> class shape {
  public:
    virtual derived clone() { return static_cast<derived>(*this); };
};

Inherits from base and base has derived as a template parameter

class square : public shape<square> {
  public:
    square() = default;
    explicit square(const shape &){};
    // CRTP: Clone can return a square even though it's derived from shape
    square clone() override { return *this; }
};

Use a template dependant function

1 2	`square a; square b = a.clone();`

Print addresses

1
2
3

std::cout << "The square has been cloned as a real square" << '\n';
std::cout << "&a: " << &a << '\n';
std::cout << "&b: " << &b << '\n';

Share Snippets