本を参照せずに、コード例を使用してCRTP
の適切な説明を提供してください。
要するに、CRTPは、クラスA
に、クラスA
自体のテンプレート特化である基本クラスがある場合です。例えば。
template <class T>
class X{...};
class A : public X<A> {...};
それはis不思議なことに繰り返されますよね? :)
さて、これはあなたに何を与えますか?これは、実際にX
テンプレートにその特殊化の基本クラスになる能力を与えます。
たとえば、次のような汎用シングルトンクラス(簡易バージョン)を作成できます。
template <class ActualClass>
class Singleton
{
public:
static ActualClass& GetInstance()
{
if(p == nullptr)
p = new ActualClass;
return *p;
}
protected:
static ActualClass* p;
private:
Singleton(){}
Singleton(Singleton const &);
Singleton& operator = (Singleton const &);
};
template <class T>
T* Singleton<T>::p = nullptr;
ここで、任意のクラスA
をシングルトンにするために、これを行う必要があります
class A: public Singleton<A>
{
//Rest of functionality for class A
};
ご覧のように?シングルトンテンプレートは、任意のタイプX
の特殊化がsingleton<X>
から継承されるため、GetInstance
!を含むすべての(パブリック、保護された)メンバーにアクセスできると想定しています。 CRTPには他にも便利な用途があります。たとえば、クラスに現在存在するすべてのインスタンスをカウントしたいが、このロジックを別のテンプレートにカプセル化したい場合(具体的なクラスのアイデアは非常に単純です-静的変数、ctorの増分、dtorの減分があります) )。練習としてやってみてください!
Boostのもう1つの有用な例(どのように実装しているかはわかりませんが、CRTPも同様です)。クラスには演算子<
のみを提供し、クラスには自動的に演算子==
を提供したいと想像してください。
次のようにできます:
template<class Derived>
class Equality
{
};
template <class Derived>
bool operator == (Equality<Derived> const& op1, Equality<Derived> const & op2)
{
Derived const& d1 = static_cast<Derived const&>(op1);//you assume this works
//because you know that the dynamic type will actually be your template parameter.
//wonderful, isn't it?
Derived const& d2 = static_cast<Derived const&>(op2);
return !(d1 < d2) && !(d2 < d1);//assuming derived has operator <
}
これで次のように使用できます
struct Apple:public Equality<Apple>
{
int size;
};
bool operator < (Apple const & a1, Apple const& a2)
{
return a1.size < a2.size;
}
さて、Apple
に明示的に演算子==
を提供していませんか?しかし、あなたはそれを持っています!あなたは書ける
int main()
{
Apple a1;
Apple a2;
a1.size = 10;
a2.size = 10;
if(a1 == a2) //the compiler won't complain!
{
}
}
これは、Apple
に対して演算子==
を記述した場合は、書く量が少なくなるように思えるかもしれませんが、Equality
テンプレートは==
だけでなく>
、>=
、<=
など。これらの定義を複数クラスに使用して、コードを再利用できます。
CRTPは素晴らしいことです:) HTH
ここで素晴らしい例を見ることができます。仮想メソッドを使用する場合、プログラムは実行時に実行されるものを認識します。 CRTPの実装は、コンパイル時に決定するコンパイラです!!!これは素晴らしいパフォーマンスです!
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は、コンパイル時ポリモーフィズムを実装する手法です。これは非常に簡単な例です。以下の例では、ProcessFoo()
はBase
クラスインターフェイスで動作し、_Base::Foo
_は派生オブジェクトのfoo()
メソッドを呼び出します。仮想メソッド。
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;
}
_
出力:
_derived foo
AnotherDerived foo
_
ちょうど注意:
CRTPを使用して、静的なポリモーフィズムを実装できます(動的なポリモーフィズムに似ていますが、仮想関数ポインタテーブルはありません)。
#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;
}
出力は次のようになります。
Derived1 method
Derived2 method
これは直接的な答えではなく、[〜#〜] crtp [〜#〜]がどのように役立つかの例です。
[〜#〜] crtp [〜#〜]の適切な具体例は、C++ 11の_std::enable_shared_from_this
_です。
クラス
T
は_enable_shared_from_this<T>
_を継承して、_shared_from_this
_を指す_shared_ptr
_インスタンスを取得する_*this
_メンバー関数を継承できます。
つまり、_std::enable_shared_from_this
_から継承すると、インスタンスにアクセスせずにインスタンスへの共有(または弱い)ポインターを取得できます(たとえば、_*this
_のみを知っているメンバー関数から)。
_std::shared_ptr
_を与える必要があるが、_*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));
}
};
_
shared_from_this()
の代わりにthis
を直接渡すことができないのは、所有権メカニズムが壊れるからです:
_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);
_