Шаблоны

Шаблон — заготовка, параметризованная типами или значениями: шаблонная функция порождает семейство функций, шаблонный класс — семейство классов. Компилятор инстанциирует конкретную версию при использовании — явно или через вывод.

Инстанциация шаблона — генерация компилятором конкретного класса или функции подстановкой аргументов. Неявная происходит автоматически при первом использовании; явная форсит её в выбранном TU и с extern template подавляет неявную в других.

Вывод типов в шаблонах в трёх случаях: по значению (top-level квалификаторы отбрасываются), по ссылке (квалификаторы сохраняются), по универсальной ссылке T&& (lvalue-ссылка через свёртку). Массивы и функции «распадаются» в указатели при выводе по значению.

Компилятору нужно полное определение шаблона в каждой точке инстанциации. Реализация в .cpp видна только своему TU, остальные TU получают ошибки компоновщика. Решение — определение в заголовке; альтернатива — явная инстанциация плюс extern template.

Специализация шаблона даёт альтернативную реализацию для конкретных аргументов. Полная фиксирует все параметры и пишется через template<>; частичная фиксирует часть или добавляет ограничения и доступна только для классов — не функций.

Fold expressions (C++17) сворачивают parameter pack бинарным оператором в четырёх формах: unary right (args op ...), left (... op args), binary right (args op ... op init), left (init op ... op args). Identity пустого pack — для &&, ||, ,.

if constexpr (C++17) отбрасывает невыбранную ветку на этапе компиляции — она не обязана компилироваться для текущей инстанциации, что позволяет одной шаблонной функции обрабатывать пути по типу. Обычный if требует компиляции обеих веток.

Non-type-параметр принимает значение, не тип (template<size_t N> struct Array {T data[N];}). До C++20: integral, enum, указатели/ссылки с linkage, nullptr_t. C++17 добавил auto; C++20 — structural class types вроде строк фиксированного размера.

Паттерн с ... повторяется для каждого элемента pack: f(args)... вызывает f для каждого arg, Ts... раскрывает type pack, (args + ...) — fold. Допустимы трансформации вроде f(g(args)...); std::index_sequence распаковывает tuple.

Когда ссылки накладываются, они сворачиваются: любая комбинация с lvalue-ссылкой даёт T&, и только T&& && даёт T&&. Forwarding-ссылка T&& выводит T как U& для lvalue, так что U& && сворачивается в U&; для rvalue T = U, давая U&&. Так сохраняется категория значения.

SFINAE (Substitution Failure Is Not An Error): если подстановка аргументов шаблона в immediate context даёт некорректный тип или выражение, компилятор молча убирает перегрузку. Лежит в основе std::enable_if для условного выбора перегрузок.

Концепт — именованный compile-time предикат над параметрами шаблона (template<Number T> T add(T,T);). Ошибки становятся читаемыми — вместо страниц SFINAE-фейла «T не удовлетворяет Number». Концепты ранжируют перегрузки по subsumption.

requires-clause ограничивает шаблон (requires Number<T>); requires-expression — compile-time проверка валидности операций (requires (T t) { t+t; }). Комбинируются как requires requires (T t) { ... } — внешний clause, внутренний expression.

Статический полиморфизм выбирает поведение по типам, известным на compile time, с нулевой стоимостью диспетчеризации. Реализуется через перегрузку, специализацию шаблонов, CRTP, if constexpr и концепты. Не работает с гетерогенными коллекциями.

Вариадические шаблоны принимают любое число типовых или нетиповых параметров через parameter pack (typename... Ts), раскрываемый через .... Рекурсия — классический способ обработки; fold expressions C++17 покрывают большинство случаев.

Да — конструктор может быть шаблоном функции-члена, что позволяет создавать объект из разных типов аргументов. Но шаблонный конструктор никогда не выбирается как конструктор копирования: компилятор всегда предпочитает неявно сгенерированный.

Нет — виртуальные функции не могут быть шаблонами. Vtable требует фиксированного compile-time размера, а шаблон функции может порождать неограниченное число инстанциаций, известных лишь на этапе компоновки.

Префикс концепта перед auto ограничивает его: void f(Sortable auto& c) делает параметр сокращённым шаблоном, чей выведенный тип обязан удовлетворять Sortable. То же для возвращаемых типов: Number auto g();. Несовпадение убирает функцию из overload resolution, а не даёт жёсткую ошибку.

CTAD (C++17) позволяет писать std::vector v{1,2,3}; и компилятор сам выводит std::vector<int>. Guides синтезируются из конструкторов; если мало — пользовательские: template<class It> Container(It,It) -> Container<typename It::value_type>;.

Ошибки рождаются глубоко в цепочке инстанциаций — компилятор печатает каждый шаг. Что помогает: C++20 концепты дают однострочное «не удовлетворяет X», ранний static_assert в точке вызова даёт понятное сообщение, и помогает cppinsights.io.

Alias template (template<class T> using Vec = std::vector<T, MyAlloc>;) — параметризованное имя типа; typedef не принимает параметров шаблона. Алиасы также избавляют от typename dependent-name проблем. C++20 добавил CTAD для alias.

Variable template (C++14) — параметризованная константа: template<class T> constexpr T pi = T(3.14159);. Каждое использование с типом инстанциирует отдельный объект. В отличие от шаблона функции он не вызывается; в отличие от шаблона класса он именует значение, а не тип.

CRTP (Curiously Recurring Template Pattern): Derived наследуется от Base<Derived>, чтобы Base вызывал методы производного через static_cast<Derived*>(this) без виртуальной диспетчеризации. Применения: статический полиморфизм, mixins.

При поиске фазы 1 компилятор не просматривает зависимые базы, ведь специализация могла бы изменить содержимое Base<T>. Поэтому неквалифицированное value трактуется как не-член и не находится. Сделав его зависимым — this->value или Base<T>::value — мы откладываем поиск до инстанциации, когда база известна.

Detection idiom проверяет на этапе компиляции, корректно ли выражение вроде T::member для конкретного типа, не порождая жёсткой ошибки компиляции. std::void_t<...> отображает любые валидные типы в void, а частичная специализация по void_t<expr> матчится только когда expr компилируется — иначе выбирается запасной первичный шаблон.

template class Foo<int>; форсит инстанциацию шаблона здесь, генерируя объектный код. Парно с extern template в заголовке, чтобы потребители не инстанциировали. Ускоряет сборку, когда много TU делят одну инстанциацию.

Шаблоны обрабатываются в две фазы. Фаза 1 при определении: проверяется синтаксис, ищутся независимые имена. Фаза 2 при инстанциации: зависимые имена ищутся в контекстах определения и инстанциации.

TMP использует систему шаблонов C++ как движок compile-time вычислений — типы и значения через рекурсивные инстанциации (классический) или constexpr (современный). <type_traits> — лицо TMP в STL; концепты C++20 упрощают паттерны.

Tag dispatch выбирает перегрузку через пустую тег-структуру категории — классический пример STL: std::distance диспетчеризуется по iterator_category. Современный C++ заменяет это на if constexpr или constraint-based перегрузки.

Классический TMP использовал рекурсивную инстанциацию: основной шаблон плюс специализация base case, Factorial<N>::value = N * Factorial<N-1>::value; с Factorial<0>::value = 1. Современный C++ заменяет это if constexpr и consteval.

Внутри шаблона компилятор не различает, dependent-имя — тип, значение или шаблон; по умолчанию считает значением. typename T::nested объявляет тип; t.template foo<int>() объявляет шаблон. C++20 сделал typename опциональным.

extern template class Foo<int>; в заголовке подавляет неявную инстанциацию во всех включающих TU; один .cpp предоставляет тело через template class Foo<int>;. Избавляет от повторного парсинга и кодогенерации в каждом TU.

Partial ordering ранжирует шаблоны по специфичности: A специфичнее B, если любой набор аргументов, подходящий A, подходит и B, но не наоборот. Компилятор проверяет это, выводя параметры каждого кандидата из другого, и побеждает односторонне выводимый кандидат. Правило применяется и к частичным специализациям классов, и к перегрузкам шаблонных функций.

Три формы: (1) одна инстанциация — friend void f<int>(MyClass&);; (2) весь шаблон — template<class T> friend void f(MyClass&);; (3) определить нешаблонную friend внутри тела класса — паттерн для operator<<, чтобы ADL её находил.

Template template parameter принимает шаблон, а не тип: template<template<typename> class C> struct Wrap { C<int> v; };. Полезен в коде, переинстанциирующем generic-контейнер с разными типами элементов — например, политики аллокатора.