C++ Academy · Lección

El patrón CRTP

Patrón de plantilla de recurrencia curiosa

El patrón CRTP es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué es CRTP?

El Curiously Recurring Template Pattern (CRTP) es un recurso idiomático de C++ en el que una clase Derived hereda de una clase base de plantilla instanciada con la propia clase Derived.

Forma: class Derived : public Base<Derived>
La clase base conoce su tipo derivado en tiempo de compilación

template <typename T>
class Base {};

class Derived : public Base<Derived> {};

El mecanismo central

Dentro de la clase base, puede aplicar static_cast al puntero this para convertirlo al tipo derivado. Como el tipo derivado es un parámetro de plantilla, esta conversión se resuelve completamente en tiempo de compilación y no tiene coste de ejecución.

#include <iostream>

template <typename T>
class Base {
public:
    void interface() {
        static_cast<T*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() { std::cout << "Derived impl\n"; }
};

int main() {
    Derived d;
    d.interface();
    return 0;
}

¿Por qué «Curiously Recurring»?

El nombre procede de la paradoja aparente: la clase base hace referencia a la clase derivada, que todavía no está completamente definida cuando se escribe la plantilla base.

Funciona porque las plantillas solo se instancian cuando se utilizan
Cuando llega el momento de instanciarlas, Derived es un tipo completo

Un primer uso real

CRTP permite que una clase base proporcione funcionalidad reutilizable que invoque a la clase derivada. En este caso, la clase base proporciona un print() que delega en name() de la clase derivada.

#include <iostream>
#include <string>

template <typename T>
struct Named {
    void print() {
        std::cout << static_cast<T*>(this)->name() << "\n";
    }
};

struct Cat : Named<Cat> {
    std::string name() { return "Cat"; }
};

int main() {
    Cat c;
    c.print();
    return 0;
}

Sin tablas virtuales

A diferencia del polimorfismo en tiempo de ejecución, CRTP no necesita la palabra clave virtual ni un puntero a una vtable en cada objeto. El despacho se resuelve completamente en tiempo de compilación.

Objetos más pequeños (sin vptr oculto)
Las llamadas pueden insertarse en línea

Recuento de instancias

Una aplicación clásica de CRTP es un contador de objetos. Cada clase derivada obtiene automáticamente su propio contador estático.

#include <iostream>

template <typename T>
struct Counter {
    static inline int count = 0;
    Counter() { ++count; }
    ~Counter() { --count; }
};

struct Widget : Counter<Widget> {};

int main() {
    Widget a, b;
    std::cout << Widget::count << "\n";
    return 0;
}

Cada clase derivada obtiene su propio estado

Como Counter<Widget> y Counter<Gadget> son instanciaciones de plantilla distintas, cada una tiene un count estático independiente. Esta separación es imposible con una única clase base que no sea una plantilla.

#include <iostream>

template <typename T>
struct Counter {
    static inline int count = 0;
    Counter() { ++count; }
};

struct A : Counter<A> {};
struct B : Counter<B> {};

int main() {
    A a1, a2;
    B b1;
    std::cout << A::count << " " << B::count << "\n";
    return 0;
}

Aquí static_cast es seguro

La conversión descendente dentro de la clase base es segura solo si cada objeto de tipo Base<T> es realmente un T. CRTP lo garantiza por construcción, ya que T es la clase que hereda.

Nunca instancie Base<Wrong> para una clase no relacionada

Operadores de comparación mediante CRTP

Puede generar un conjunto completo de operadores de comparación a partir de un único operator< mediante la herencia de un auxiliar de comparación.

#include <iostream>

template <typename T>
struct Comparable {
    friend bool operator>(const T& a, const T& b) { return b < a; }
    friend bool operator==(const T& a, const T& b) { return !(a < b) && !(b < a); }
};

struct Num : Comparable<Num> {
    int v;
    Num(int x) : v(x) {}
    friend bool operator<(const Num& a, const Num& b) { return a.v < b.v; }
};

int main() {
    std::cout << (Num(3) > Num(2)) << "\n";
    return 0;
}

Protección mediante un constructor protected

Para evitar el uso accidental de la clase base, asígnele un constructor protected para que solo las clases derivadas puedan crearla.

#include <iostream>

template <typename T>
class Base {
protected:
    Base() = default;
public:
    void run() { static_cast<T*>(this)->step(); }
};

class Job : public Base<Job> {
public:
    void step() { std::cout << "step\n"; }
};

int main() {
    Job j;
    j.run();
    return 0;
}

CRTP en las bibliotecas estándar

CRTP aparece en numerosas bibliotecas reales de C++.

std::enable_shared_from_this<T> lo utiliza
Muchas bibliotecas matemáticas de plantillas de expresiones (como Eigen) se basan en él
Ranges y los auxiliares de iteradores utilizan patrones similares

Reconocer la forma X : Base<X> le ayuda a leer código avanzado.

Comprobación rápida

Compruebe su comprensión de la forma de CRTP.

Resumen

Ha aprendido el recurso idiomático CRTP.

Derived : Base<Derived> proporciona a la clase base su tipo concreto
Un static_cast<T*>(this) permite el despacho en tiempo de compilación
No hay vtable, los objetos son más pequeños y las llamadas pueden insertarse en línea
Se utiliza para contadores, mixins de comparación y auxiliares de bibliotecas

Preguntas frecuentes

¿La lección «El patrón CRTP» es gratis?

Sí — el texto completo de «El patrón CRTP» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «El patrón CRTP»?

Patrón de plantilla de recurrencia curiosa Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «El patrón CRTP»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy