CRTP para evitar el polimorfismo dinámico

Question

¿Cómo puedo usar CRTP en C++ para evitar la sobrecarga de las funciones de miembros virtuales?

Answer 1

Tuve que buscar CRTP. Sin embargo, al haber hecho eso, encontré algunas cosas sobre Static Polymorphism. Sospecho que esta es la respuesta a tu pregunta.

Resulta que ATL usa este patrón bastante extensamente.

Answer 2

This La respuesta de Wikipedia tiene todo lo que necesita. A saber:

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

Aunque no sé cuánto esto realmente te compra. La sobrecarga de una llamada de función virtual es (compilador depende, por supuesto):

• memoria: Una puntero de función por función virtual
• Duración: Una función llamada puntero

Mientras que la sobrecarga de CRTP polimorfismo estático es:

• memoria: Duplicación de Base por instancias de plantilla
• Duración: Una func Llamada de puntero a la llamada + lo que está haciendo static_cast

Answer 3

He estado buscando conversaciones decentes sobre CRTP. Todd Veldhuizen's Techniques for Scientific C++ es un gran recurso para esto (1.3) y muchas otras técnicas avanzadas como plantillas de expresión.

Además, descubrí que se podía leer la mayor parte del artículo original de C++ Gems de Coplien en los libros de Google. Tal vez ese sigue siendo el caso.

Answer 4

Hay dos formas.

El primero es mediante la especificación de la interfaz de forma estática para la estructura de tipos:

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

El segundo es al evitar el uso de la referencia-a-base o idioma-puntero a la base y hacer el cableado en tiempo de compilación. Usando la definición anterior, se puede tener funciones de plantilla que se parecen a éstas:

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 

Así que la combinación de la definición de estructura/interfaz y el tipo de deducción en tiempo de compilación en sus funciones le permite hacer el envío estática en lugar de envío dinámico. Esta es la esencia del polimorfismo estático.