🧬 CRTP (Curiously Recurring Template Pattern)

Как использовать шаблоны, а не виртуальность, чтобы дать базовому классу знать о потомке?

CRTP — это шаблон, где класс-наследник передаёт себя в качестве параметра шаблона базовому классу.

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

А наследник выглядит так:

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

⚙️ Как это работает

Когда ты вызываешь:

Derived d;
d.interface();

Базовый класс вызывает метод implementation() у конкретного типа Derived,
при этом без виртуальных функций — всё статически известно на этапе компиляции.

🚀 Где это полезно:

— Mixin — добавление поведения к классам без виртуальности.

— Policy-based design — подмена стратегий через шаблонные параметры.

— Статический полиморфизм — альтернатива virtual, но без runtime overhead.

— Ограничение интерфейса наследников — например, через enable_if и SFINAE.


🧠 Пример Mixin с CRTP

template <typename Derived>
class Printable
{
public:
    void print() const
    {
        std::cout << 
        static_cast<const Derived*>
        (this)->toString();
    }
};

class Point : public Printable<Point>
{
public:
    Point(int x, int y) : x_(x), y_(y) {}
    std::string toString() const 
    { 
       return std::to_string(x_) + ","
            + std::to_string(y_);
    }
private:
    int x_, y_;
};

Point p(2, 3);
p.print(); // 2,3

— Без virtual
— Без динамической памяти
— Гибко и эффективно

В итоге имеем:
CRTP — способ реализовать полиморфизм, заменив виртуальные вызовы статическим связыванием на этапе компиляции.

#cpp_tips

🧩 Тест 1 — Как работает вывод типов шаблона

⚙️ Тест 2 — Передача по ссылке и вывод типов

🧩 Тест 3 — Как работает частичная специализация

⚙️ Type Traits: когда типы становятся логикой

Примеры Type Traits

template<typename T>
struct is_pointer 
{
  static constexpr bool value = false;
};

template<typename T>
struct is_pointer<T*> 
{
  static constexpr bool value = true; 
};

assert(is_pointer<int*>::value);

🧠 Type Traits — шаблонные конструкции, которые предоставляют информацию о свойствах типов во время компиляции
Используются в std::enable_if, concepts, std::move.

🎯 Policy-based Design: шаблонная настройка поведения

Пример реализации:

template<typename ThreadPolicy, typename LogPolicy>
class Engine : private ThreadPolicy, private LogPolicy
{
public:
    void run()
    {
        this->log("Starting...");
        this->lock();
        this->unlock();
    }
};

✅ Вместо наследования от суперкласса составляем объект из политик, что позволяет легко менять поведение без лишнего кода.

Expression Templates

Или магия ленивых выражений

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

Таким образом, шаблоны выражений позволяют программистам обойти обычный порядок вычисления на языке C++ и добиться оптимизации, такой как объединение циклов.

Пример:

template<typename L, typename R>
struct Add
{
    L const& l; R const& r;
    auto eval() const
    { 
      return l.eval() + r.eval();
    }
};

struct Value
{
    double v;
    auto eval() const
    {
      return v;
    }
};

🧠 Такие паттерны лежат в основе библиотек Eigen, Blitz++, Armadillo. Они предотвращают создание временных объектов — всё оптимизируется на этапе компиляции.

Static Interface (Concepts)

Static Interface: контракты времени компиляции

template<typename T>
concept Drawable = requires(T obj)
{
  obj.draw();
};

template<Drawable T>
void render(T obj) 
{ 
  obj.draw();
}

🧠 Concepts — это compile-time контракты.
Компилятор гарантирует, что тип соответствует интерфейсу.
Это безопасный и быстрый способ добавления ограничений к создаваемым объектам