¿Qué es el patrón de plantilla curiosamente recurrente (CRTP)?

Aquí puedes ver un gran ejemplo. Si utiliza el método virtual, el programa sabrá qué ejecutar en tiempo de ejecución. Implementando CRTP el compilador es el que decide en tiempo de compilación!!! Esta es una gran actuación!

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);
    }
};

CRTP es una técnica para implementar polimorfismo en tiempo de compilación. Aquí hay un ejemplo muy simple. En el siguiente ejemplo, ProcessFoo() está trabajando con la interfaz de clase Base y Base::Foo invoca el método foo() del objeto derivado, que es lo que pretende hacer con los métodos virtuales.

Http://coliru.stacked-crooked.com/a/2d27f1e09d567d0e

template <typename T>
struct Base {
  void foo() {
    (static_cast<T*>(this))->foo();
  }
};

struct Derived : public Base<Derived> {
  void foo() {
    cout << "derived foo" << endl;
  }
};

struct AnotherDerived : public Base<AnotherDerived> {
  void foo() {
    cout << "AnotherDerived foo" << endl;
  }
};

template<typename T>
void ProcessFoo(Base<T>* b) {
  b->foo();
}


int main()
{
    Derived d1;
    AnotherDerived d2;
    ProcessFoo(&d1);
    ProcessFoo(&d2);
    return 0;
}

Salida:

derived foo
AnotherDerived foo

Como nota:

CRTP podría usarse para implementar polimorfismo estático (que como polimorfismo dinámico pero sin tabla de puntero de función virtual).

#pragma once
#include <iostream>
template <typename T>
class Base
{
    public:
        void method() {
            static_cast<T*>(this)->method();
        }
};

class Derived1 : public Base<Derived1>
{
    public:
        void method() {
            std::cout << "Derived1 method" << std::endl;
        }
};


class Derived2 : public Base<Derived2>
{
    public:
        void method() {
            std::cout << "Derived2 method" << std::endl;
        }
};


#include "crtp.h"
int main()
{
    Derived1 d1;
    Derived2 d2;
    d1.method();
    d2.method();
    return 0;
}

La salida sería:

Derived1 method
Derived2 method

Esta no es una respuesta directa, sino más bien un ejemplo de cómo CRTP puede ser útil.

Un buen ejemplo concreto de CRTP es std::enable_shared_from_this de C++11:

[util.smartptr.enab]/1

Una clase T puede heredar de enable_­shared_­from_­this<T> para heredar las funciones miembro shared_­from_­this que obtienen una instancia shared_­ptr que apunta a *this.

Es decir, heredar de std::enable_shared_from_this hace posible obtener un puntero compartido (o débil) a su instancia sin acceso a ella (por ejemplo, desde una función miembro donde solo conoce *this).

Es útil cuando necesitas dar un std::shared_ptr pero solo tienes acceso a *this:

struct Node;

void process_node(const std::shared_ptr<Node> &);

struct Node : std::enable_shared_from_this<Node> // CRTP
{
    std::weak_ptr<Node> parent;
    std::vector<std::shared_ptr<Node>> children;

    void add_child(std::shared_ptr<Node> child)
    {
        process_node(shared_from_this()); // Shouldn't pass `this` directly.
        child->parent = weak_from_this(); // Ditto.
        children.push_back(std::move(child));
    }
};

La razón por la que no puedes simplemente pasar this directamente en lugar de shared_from_this() es que rompería el mecanismo de propiedad:

struct S
{
    std::shared_ptr<S> get_shared() const { return std::shared_ptr<S>(this); }
};

// Both shared_ptr think they're the only owner of S.
// This invokes UB (double-free).
std::shared_ptr<S> s1 = std::make_shared<S>();
std::shared_ptr<S> s2 = s1->get_shared();
assert(s2.use_count() == 1);