Mixins mediante CRTP
Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 77 de 104.
El patrón de plantilla curiosamente recurrente (Curiously Recurring Template Pattern, CRTP) es una técnica en la que una clase hereda de una clase base de plantilla y se pasa a sí misma como argumento de plantilla. Esto permite el polimorfismo en tiempo de compilación y permite que las clases base accedan a los miembros de las clases derivadas sin funciones virtuales.
La estructura básica de CRTP tiene este aspecto:
template <typename Derived>
class Base {
public:
void interface() {
static_cast<Derived*>(this)->implementation();
}
};
class MyClass : public Base<MyClass> {
public:
void implementation() {
std::cout << "MyClass implementation\n";
}
};CRTP es particularmente potente para crear mixins: funcionalidad reutilizable que se puede «mezclar» en clases. A diferencia de la herencia tradicional, los mixins añaden capacidades sin crear jerarquías profundas:
template <typename Derived>
class Printable {
public:
void print() const {
const Derived& self = static_cast<const Derived&>(*this);
std::cout << self.toString() << "\n";
}
};
class Person : public Printable<Person> {
std::string name;
public:
Person(const std::string& n) : name(n) {}
std::string toString() const { return "Person: " + name; }
};
// Uso:
Person p("Alice");
p.print(); // Salida: Person: AliceLa principal ventaja es que todas las llamadas a métodos se resuelven en tiempo de compilación, lo que elimina la sobrecarga de las funciones virtuales. Puedes combinar varios mixins de CRTP para componer funcionalidades, lo que lo convierte en una alternativa flexible al polimorfismo en tiempo de ejecución cuando los tipos se conocen en tiempo de compilación.
Desafío
FácilVamos a crear un sistema de registro que utiliza mixins CRTP para añadir funcionalidad reutilizable a diferentes clases sin la sobrecarga de las funciones virtuales. Crearás dos mixins que se pueden «incluir» en cualquier clase: uno para contar instancias y otro para generar representaciones de cadenas.
Organizarás el código en tres archivos:
Mixins.h: Define dos plantillas de mixin CRTP que proporcionan funcionalidad reutilizable.Crea una plantilla de mixin
Countableque registre cuántas instancias de una clase derivada existen. Debe tener un contador estático que se incremente en el constructor y se reduzca en el destructor. Proporciona un método estáticogetCount()que devuelva el recuento actual.Crea una plantilla de mixin
Describableque proporcione un métododescribe(). Este método debe usarstatic_castpara acceder a la clase derivada y llamar a su métodogetDescription(); después, debe imprimir el resultado seguido de un salto de línea.Recuerda que los mixins CRTP usan
static_cast<Derived*>(this)para acceder en tiempo de compilación a los miembros de la clase derivada.Entities.h: Define dos clases de entidad que hereden de ambos mixins.Crea una clase
Playerque herede tanto deCountable<Player>como deDescribable<Player>. Debe almacenar un nombre y un nivel, y proporcionar un métodogetDescription()que devuelva una cadena con el formato:Player: [name] (Level [level])Crea una clase
Enemyque también herede de ambos mixins. Debe almacenar un tipo y la salud, y proporcionar un métodogetDescription()que devuelva:Enemy: [type] with [health] HPNo olvides inicializar el contador estático de cada clase.
main.cpp: Lee cuatro entradas (cada una en una línea aparte):- Nombre del jugador (cadena)
- Nivel del jugador (entero)
- Tipo de enemigo (cadena)
- Salud del enemigo (entero)
Crea un Player y un Enemy con los valores proporcionados. Después, muestra los mixins en funcionamiento:
- Imprime
Player count: [count]usando el método estáticogetCount() - Imprime
Enemy count: [count] - Llama a
describe()para el jugador - Llama a
describe()para el enemigo - Crea un segundo jugador con el nombre "Guest" y el nivel 1
- Imprime de nuevo
Player count: [count]para mostrar el recuento actualizado - Llama a
describe()para el segundo jugador
Por ejemplo, con las entradas Hero, 10, Dragon y 500:
Player count: 1
Enemy count: 1
Player: Hero (Level 10)
Enemy: Dragon with 500 HP
Player count: 2
Player: Guest (Level 1)Este desafío demuestra cómo los mixins CRTP añaden funcionalidad (contar y describir) a clases no relacionadas sin usar funciones virtuales. Tanto Player como Enemy obtienen las mismas capacidades al heredar de las mismas plantillas de mixin, pero cada una mantiene su propio contador de instancias independiente porque la plantilla se instancia con tipos diferentes.
Pruébalo tú mismo
#include <iostream>
#include <string>
#include "Entities.h"
using namespace std;
int main() {
// Lee los datos de entrada
string playerName;
int playerLevel;
string enemyType;
int enemyHealth;
cin >> playerName;
cin >> playerLevel;
cin >> enemyType;
cin >> enemyHealth;
// TODO: Crea un Player con el nombre y el nivel dados
// TODO: Crea un Enemy con el tipo y la salud dados
// TODO: Imprime "Player count: [count]" usando Player::getCount()
// TODO: Imprime "Enemy count: [count]" usando Enemy::getCount()
// TODO: Llama a describe() para el jugador
// TODO: Llama a describe() para el enemigo
// TODO: Crea un segundo jugador con el nombre "Guest" y el nivel 1
// TODO: Imprime "Player count: [count]" de nuevo
// TODO: Llama a describe() para el segundo jugador
return 0;
}
Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.
Todas las lecciones de Programación Orientada a Objetos
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genéricoPractica por tu cuenta: Compilador de C++ online