Co to jest curiously recurring template pattern (CRTP)?

Tutaj możesz zobaczyć świetny przykład. Jeśli używasz metody wirtualnej, program będzie wiedział, co wykonać w trybie runtime. Implementacja CRTP to kompilator, który decyduje w czasie kompilacji!!! To jest świetne przedstawienie!

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 jest techniką implementacji polimorfizmu w czasie kompilacji. Oto bardzo prosty przykład. W poniższym przykładzie ProcessFoo() pracuje z interfejsem klasy Base i Base::Foo wywołuje metodę foo() obiektu pochodnego, co jest tym, co chcesz zrobić z metodami wirtualnymi.

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

Wyjście:

derived foo
AnotherDerived foo

Tak jak uwaga:

CRTP może być używany do implementacji polimorfizmu statycznego (który podobnie jak polimorfizm dynamiczny, ale bez tabeli wskaźników funkcji wirtualnych).

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

Wyjście będzie:

Derived1 method
Derived2 method

To nie jest bezpośrednia odpowiedź, ale raczej przykład, w jaki sposób CRTP może być przydatny.

Dobrym konkretnym przykładem CRTP jest std::enable_shared_from_this z C++11:

[util.smartptr.enab]/1

Klasa T może dziedziczyć z enable_­shared_­from_­this<T>, Aby dziedziczyć shared_­from_­this funkcje Członkowskie, które otrzymują instancję shared_­ptr wskazującą na *this.

To znaczy, dziedziczenie z std::enable_shared_from_this umożliwia uzyskanie współdzielonego (lub słabego) wskaźnika do twojego instancja bez dostępu do niej (np. z funkcji member, gdzie wiadomo tylko o *this).

Jest to przydatne, gdy trzeba dać std::shared_ptr, ale masz dostęp tylko do *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));
    }
};

Powodem, dla którego nie można po prostu przejść this bezpośrednio zamiast shared_from_this(), jest to, że złamałoby to mechanizm własności:

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