Let’s consider the following class:

class Writer
{
  public:
    Writer() { }
    virtual ~Writer() { }

    virtual void write(const char* aStr) const = 0;
};

This class will be useful as the base class for implementing several specialized writers (a file writer and a console writer come to my mind right now), for instance:

class FileWriter : public Writer
{
  public:
    FileWriter(FILE* aFile) { mFile = aFile; }
    virtual ~FileWriter() { fclose(mFile); }

    virtual void write(const char* aStr) const
    {
      fprintf(mFile, "%s\n", aStr);
    }

  private:
    FILE* mFile;
};

class ConsoleWriter : public Writer
{
  public:
    ConsoleWriter() { }
    virtual ~ConsoleWriter() { }

    virtual void write(const char* aStr) const
    {
      printf("%s\n", aStr);
    }
};

Nice, isn’t it? We can use the Writer::write() method to write on any kind of media depending on the subclass we implement. So, what is the problem here? PERFORMANCE: Your application must decide, in runtime, what implementation of your method must be executed and it takes some time.

The “curiously recurring template pattern” (CRTP) is a very elegant way of implement something called “static polymorphism”; using “static polymorphism” your application will not need to decide the method implementation to be executed, because that decision will be taken by…….. THE COMPILER!

The idea of the CRTP idiom is:

1. Creating a template class Base that will be used as a base class.
2. Implementing the method that will call to the wanted method implemented in the child class.
3. Creating a subclass Child : Base (T = Child… that is why this is called “recurring”)
4. Implementing the wanted method in the child class.

So, my example could be converted to:

template <class T>
class Writer
{
  public:
    Writer()  { }
    ~Writer()  { }

    void write(const char* str) const
    {
      static_cast<const T*>(this)->writeImpl(str); //here the magic is!!!
    }
};

class FileWriter : public Writer<FileWriter>
{
  public:
    FileWriter(FILE* aFile) { mFile = aFile; }
    ~FileWriter() { fclose(mFile); }

    //here comes the implementation of the write method on the subclass
    void writeImpl(const char* str) const
    {
      fprintf(mFile, "%s\n", str);
    }

  private:
    FILE* mFile;
};


class ConsoleWriter : public Writer<ConsoleWriter>
{
  public:
    ConsoleWriter() { }
    ~ConsoleWriter() { }

    void writeImpl(const char* str) const
    {
      printf("%s\n", str);
    }
};

And we could use it in this way:

int main()
{
  FILE* file;
  file = fopen("file.txt", "w");
  FileWriter writer(file);
  writer.write("Hello world");
  return 0;
}

As you can see in this last example, the Writer::write() method behaves like the virtual method written in my first example, but the binding is done in compile time, thus, the performance of
calling a method using this pattern is better than implementing everything in the “normal” way.

Obviously, you do not have the flexibility of dynamic polymorphism, but this idiom can be very useful if you want to create some classes with a basic functionality, create the subclasses with a more specific functionality and use them with no performance cost added.