CRTP, um dynamischen Polymorphismus zu vermeiden

Question

Wie kann ich CRTP in C++ verwenden, um den Overhead von virtuellen Elementfunktionen zu vermeiden?

Answer 1

Ich musste CRTP nachschlagen. Nachdem ich das getan hatte, fand ich etwas über Static Polymorphism. Ich vermute, dass dies die Antwort auf Ihre Frage ist.

Es stellt sich heraus, dass ATL dieses Muster recht umfangreich verwendet.

Answer 2

This Wikipedia Antwort hat alles was Sie brauchen. Nämlich:

template <class Derived> struct Base 
{ 
    void interface() 
    { 
     // ... 
     static_cast<Derived*>(this)->implementation(); 
     // ... 
    } 

    static void static_func() 
    { 
     // ... 
     Derived::static_sub_func(); 
     // ... 
    } 
}; 

struct Derived : Base<Derived> 
{ 
    void implementation(); 
    static void static_sub_func(); 
}; 

Obwohl ich nicht weiß, wie viel das tatsächlich kauft Sie. Der Overhead eines virtuellen Funktionsaufruf (Compiler abhängig, natürlich):

• Speicher: Ein Funktionszeiger pro virtuelle Funktion
• Laufzeit: Ein Funktionszeiger Anruf

Während der Aufwand für CRTP statische Polymorphismus ist:

• Speicher: Duplication of Base pro Vorlage Instanziierung
• Laufzeit: Eine func tionszeigerruf + was auch immer static_cast macht

Answer 3

Ich habe nach anständigen Diskussionen über CRTP selbst gesucht. Todd Veldhuizens Techniques for Scientific C++ ist eine großartige Ressource für dieses (1.3) und viele andere fortgeschrittene Techniken wie Expression-Templates.

Auch fand ich, dass Sie die meisten von Coplien ursprünglichen C++ Gems Artikel bei Google Bücher lesen konnten. Vielleicht ist das immer noch so.

Answer 4

Es gibt zwei Möglichkeiten.

Die erste ist durch die Schnittstelle statisch für die Struktur von Typen spezifizieren:

template <class Derived> 
struct base { 
    void foo() { 
    static_cast<Derived *>(this)->foo(); 
    }; 
}; 

struct my_type : base<my_type> { 
    void foo(); // required to compile. 
}; 

struct your_type : base<your_type> { 
    void foo(); // required to compile. 
}; 

Die zweite wird durch die Verwendung der Referenz-to-Base oder pointer-to-Base-Idiom zu vermeiden und zu tun die Verkabelung zur Kompilierzeit. Unter Verwendung der obigen Definition können Sie Template-Funktionen haben, wie diese aussehen:

template <class T> // T is deduced at compile-time 
void bar(base<T> & obj) { 
    obj.foo(); // will do static dispatch 
} 

struct not_derived_from_base { }; // notice, not derived from base 

// ... 
my_type my_instance; 
your_type your_instance; 
not_derived_from_base invalid_instance; 
bar(my_instance); // will call my_instance.foo() 
bar(your_instance); // will call your_instance.foo() 
bar(invalid_instance); // compile error, cannot deduce correct overload 

So die Struktur/Interface-Definition kombiniert und die Kompilierung-Typ Abzug in Ihre Funktionen können Sie statische Versand statt dynamischen Dispatch tun. Dies ist die Essenz des statischen Polymorphismus.