Шаблоны

Заготовки, по которым компилятор создаёт отдельную функцию или класс для каждого используемого типа

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

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

Не скомпилируется: T не может быть одновременно int и double

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

iT

Специализация даёт шаблону другую реализацию для конкретных аргументов. Полная фиксирует все параметры и пишется через 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 и концепты. Не работает с гетерогенными коллекциями.

Вариативные шаблоны принимают любое число типовых или нетиповых параметров через пакет параметров (typename... Ts), раскрываемый через .... Раньше пакет обрабатывали рекурсией, с C++17 обычно хватает выражений свёртки.

Да — конструктор может быть шаблоном функции-члена для разных типов аргументов. Шаблон не бывает конструктором копирования, неявный всё равно объявляется, но template<class T> X(T&&) побеждает его при копировании неконстантного lvalue.

3 0

Нет — виртуальные функции не могут быть шаблонами. 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-контейнер с разными типами элементов — например, политики аллокатора.