Menu
CoddyTech

Миксины через CRTP

Часть раздела Объектно-ориентированное программирование путешествия по C++ на Coddy. Урок 77 из 104.

Техника Curiously Recurring Template Pattern (CRTP) заключается в том, что класс наследуется от базового класса-шаблона, передавая сам себя в качестве аргумента шаблона. Это обеспечивает полиморфизм на этапе компиляции и позволяет базовым классам обращаться к членам производного класса без виртуальных функций.

Базовая структура CRTP выглядит так:

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 особенно эффективен для создания примесей — многократно используемых функциональных возможностей, которые можно «примешивать» к классам. В отличие от традиционного наследования, примеси добавляют возможности, не создавая глубоких иерархий:

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

// Использование:
Person p("Alice");
p.print();  // Вывод: Person: Alice

Ключевое преимущество заключается в том, что все вызовы методов разрешаются во время компиляции, что устраняет накладные расходы на виртуальные функции. Вы можете комбинировать несколько примесей CRTP для составления функциональности, что делает этот подход гибкой альтернативой полиморфизму времени выполнения, когда типы известны во время компиляции.

challenge icon

Задание

Легко

Давайте создадим систему журналирования, в которой миксины CRTP добавляют повторно используемые возможности разным классам без накладных расходов на виртуальные функции. Вы создадите два миксина, которые можно «подмешать» в любой класс: один для подсчёта экземпляров, а другой для формирования строковых представлений.

Вы распределите код по трём файлам:

  • Mixins.h: определите два шаблона миксинов CRTP, предоставляющих повторно используемые возможности.

    Создайте шаблон миксина Countable, который отслеживает количество существующих экземпляров производного класса. В нём должен быть статический счётчик, который увеличивается в конструкторе и уменьшается в деструкторе. Добавьте статический метод getCount(), возвращающий текущее значение счётчика.

    Создайте шаблон миксина Describable, предоставляющий метод describe(). Этот метод должен использовать static_cast, чтобы получить доступ к производному классу и вызвать его метод getDescription(), а затем вывести результат и символ новой строки.

    Помните, что миксины CRTP используют static_cast<Derived*>(this), чтобы получить доступ к членам производного класса во время компиляции.

  • Entities.h: определите два класса сущностей, наследующиеся от обоих миксинов.

    Создайте класс Player, наследующийся от Countable<Player> и Describable<Player>. Он должен хранить имя и уровень, а также предоставлять метод getDescription(), который возвращает строку в формате: Player: [name] (Level [level])

    Создайте класс Enemy, который также наследуется от обоих миксинов. Он должен хранить тип и здоровье, а также предоставлять метод getDescription(), который возвращает: Enemy: [type] with [health] HP

    Не забудьте инициализировать статический счётчик для каждого класса.

  • main.cpp: считайте четыре значения (каждое с отдельной строки):
    1. Имя игрока (строка)
    2. Уровень игрока (целое число)
    3. Тип противника (строка)
    4. Здоровье противника (целое число)

    Создайте игрока и противника с заданными значениями. Затем продемонстрируйте работу миксинов:

    1. Выведите Player count: [count] с помощью статического метода getCount()
    2. Выведите Enemy count: [count]
    3. Вызовите describe() для игрока
    4. Вызовите describe() для противника
    5. Создайте второго игрока с именем "Guest" и уровнем 1
    6. Снова выведите Player count: [count], чтобы показать обновлённое значение счётчика
    7. Вызовите describe() для второго игрока

Например, при вводе Hero, 10, Dragon и 500:

Player count: 1
Enemy count: 1
Player: Hero (Level 10)
Enemy: Dragon with 500 HP
Player count: 2
Player: Guest (Level 1)

Это задание демонстрирует, как миксины CRTP добавляют возможности (подсчёт и описание) несвязанным классам без использования виртуальных функций. Классы Player и Enemy получают одинаковые возможности благодаря наследованию от одних и тех же шаблонов миксинов, но каждый из них ведёт собственный счётчик экземпляров, поскольку шаблон инстанцируется с разными типами.

Попробуйте сами

#include <iostream>
#include <string>
#include "Entities.h"

using namespace std;

int main() {
    // Считать входные данные
    string playerName;
    int playerLevel;
    string enemyType;
    int enemyHealth;
    
    cin >> playerName;
    cin >> playerLevel;
    cin >> enemyType;
    cin >> enemyHealth;
    
    // TODO: Создать объект Player с заданными именем и уровнем
    
    // TODO: Создать объект Enemy с заданными типом и здоровьем
    
    // TODO: Вывести "Player count: [count]" с помощью Player::getCount()
    
    // TODO: Вывести "Enemy count: [count]" с помощью Enemy::getCount()
    
    // TODO: Вызвать describe() для игрока
    
    // TODO: Вызвать describe() для врага
    
    // TODO: Создать второго игрока с именем "Guest" и уровнем 1
    
    // TODO: Снова вывести "Player count: [count]"
    
    // TODO: Вызвать describe() для второго игрока
    
    return 0;
}
quiz iconПроверьте себя

В этом уроке есть небольшой тест. Начните урок, чтобы ответить на вопросы и сохранить прогресс.

Все уроки раздела Объектно-ориентированное программирование

Потренируйтесь самостоятельно: Онлайн-компилятор C++