Essential Books

Curiously recurring template pattern (CRTP)

suggest change

CRTP is a powerful, static alternative to virtual functions and traditional inheritance that can be used to give types properties at compile time. It works by having a base class template which takes, as one of its template parameters, the derived class. This permits it to legally perform a static_cast of its this pointer to the derived class.

Of course, this also means that a CRTP class must always be used as the base class of some other class. And the derived class must pass itself to the base class.

Let’s say you have a set of containers that all support the functions begin() and end(). The standard library’s requirements for containers require more functionality. We can design a CRTP base class that provides that functionality, based solely on begin() and end(): 

#include <iterator>
template <typename Sub>
class Container {
  private:
    // self() yields a reference to the derived type
    Sub& self() { return *static_cast<Sub*>(this); }
    Sub const& self() const { return *static_cast<Sub const*>(this); }

  public:
    decltype(auto) front() {
      return *self().begin();
    }

    decltype(auto) back() {
      return *std::prev(self().end());
    }

    decltype(auto) size() const {
      return std::distance(self().begin(), self().end());
    }

    decltype(auto) operator[](std::size_t i) {
      return *std::next(self().begin(), i);
    }
};

The above class provides the functions front(), back(), size(), and operator[] for any subclass which provides begin() and end(). An example subclass is a simple dynamically allocated array: 

#include <memory>
// A dynamically allocated array
template <typename T>
class DynArray : public Container<DynArray<T>> {
  public:
    using Base = Container<DynArray<T>>;

    DynArray(std::size_t size)
      : size_{size},
      data_{std::make_unique<T[]>(size_)}
    { }

    T* begin() { return data_.get(); }
    const T* begin() const { return data_.get(); }
    T* end() { return data_.get() + size_; }
    const T* end() const { return data_.get() + size_; }

  private:
    std::size_t size_;
    std::unique_ptr<T[]> data_;
};

Users of the DynArray class can use the interfaces provided by the CRTP base class easily as follows: 

DynArray<int> arr(10);
arr.front() = 2;
arr[2] = 5;
assert(arr.size() == 10);

Usefulness: This pattern particularly avoids virtual function calls at run-time which occur to traverse down the inheritance hierarchy and simply relies on static casts: 

DynArray<int> arr(10);
DynArray<int>::Base & base = arr;
base.begin(); // no virtual calls

The only static cast inside the function begin() in the base class Container<DynArray<int>> allows the compiler to drastically optimize the code and no virtual table look up happens at runtime.

Limitations: Because the base class is templated and different for two different DynArrays it is not possible to store pointers to their base classes in an type-homogenous array as one could generally do with normal inheritance where the base class is not dependent on the derived type: 

class A {};
class B: public A{};

A* a = new B;
Found a mistake? Have a question or improvement idea? Let me know.

Feedback about page:

Feedback:
Optional: your email if you want me to get back to you:

Templates:
* Templates
* Basic class template
* Curiously recurring template pattern (CRTP)
* Function templates
* Iterating over a parameter pack
* CRTP to avoid code duplication
* Variadic template data structures
* Partial template specialization
* Argument forwarding
* Template specialization
* Template parameter deduction for constructors
* Alias template
* Template template parameters
* Non-type template parameter
* Declaring non-type template arguments with auto
* Explicit instantiation
* Default template parameter value
Table Of Contents
0 Getting started
1 Literals
2 Basic type keywords
3 Operator precedence
4 Floating point arithmetic
5 Bit operators
6 Bit manipulation
7 Bit fields
8 Arrays
9 Flow control
10 const keyword
11 Loops
12 mutable keyword
13 friend keyword
14 keywords
15 Variable declaration keywords
16 auto keyword
17 Pointers
18 Type keywords (class, enum, struct, union)
19 Classes / structs
20 std::string
21 Enumeration
22 std::atomic
23 std::vector
24 std::array
25 std::pair
26 std::map
27 std::unordered_map
28 std::set and std::multiset
29 std::any
30 std::variant
31 std::optional
32 std::integer_sequence
33 std::function
34 std::forward_list
35 std::iomanip
36 Iterators
37 Basic I/O
38 File I/O
39 Streams
40 Stream manipulators
41 Metaprogramming
42 Returning multiple values from a function
43 References
44 Polymorphism
45 Value and reference semantics
46 Function call by value vs. by reference
47 Copying vs assignment
48 Pointers to class / struct members
49 The this pointer
50 Smart pointers
51 Unions
52 Templates
53 Namespaces
54 Function overloading
55 Operator overloading
56 Lambdas
57 Threading
58 Value categories
59 Preprocessor
60 SFINAE
61 Rule of three, five and zero
62 RAII
63 Exceptions
64 Implementation-defined behavior
65 Special member functions
66 Random numbers
67 Sorting
68 Regular expressions
69 Perfect forwarding
70 Virtual member functions
71 Undefined behavior
72 Overload resolution
73 Move semantics
74 Pimpl idiom
75 Copy elision
76 Fold expressions
77 Unnamed types
78 Singleton
79 ISO C++ Standard
80 User-defined literals
81 Type erasure
82 Memory management
83 Explicit type conversions
84 RTTI
85 Standard library algorithms
86 Expression templates
87 Scopes
88 Atomic types
89 static assert
90 constexpr
91 Date and time with std::chrono
92 Trailing return type
93 Function template overloading
94 Common compile linker errors
95 Design patterns
96 Optimizations
97 Compiling and building
98 Type traits
99 One definition rule
100 Unspecified behavio
101 Argument dependent name lookup
102 Attributes
103 Internationalization
104 Profiling
105 Return type covariance
106 Non-static member functions
107 Recursion
108 Callable objects
109 Constant class member functions
110 C++ vs. C++ 11 vs C++ 17
111 Inline functions
112 Client server examples
113 Header files
114 Const correctness
115 Refactoring techniques
116 Parameter packs
117 Iteration
118 type deduction
119 C++ 11 memory model
120 Build systems
121 Concurrency with OpenMP
122 Type inference
123 Resource management
124 Storage class specifiers
125 Alignment
126 Inline variables
127 Linkage specifications
128 Curiusly recurring template pattern
129 Using declaration
130 Typedef and type aliases
131 Layout of object types
132 C incompatibilities
133 Optimization
134 Semaphore
135 Thread synchronization
136 Debugging
137 Futures and promises
138 More undefined behaviors
139 Mutexes
140 Recursive mutex
141 Unit testing
142 decltype
143 Digit separators
144 C++ Containers
145 Arithmetic meta-programming
146 Contributors