Шаблоны функций в C++: как делать правильно

Вы написали template<typename T> T max(T a, T b), вызвали max(1, 2.0) и получили страницу ошибок про «no matching function». Или хуже: шаблон подхватил тип, для которого не должен был, и код собрался, а упал в рантайме. Шаблон функции в C++ — это не «дженерик как в Java», а инструкция компилятору генерировать перегрузки. Проблема почти всегда одна: шаблон слишком жадный и берёт типы, которые обрабатывать не умеет. Ниже — четыре способа его ограничить и цена каждого.

Материал для C++17 и C++20 (GCC 11+, Clang 14+, MSVC 19.3+). Где поведение зависит от стандарта — это отмечено рядом с кодом. Специализацию шаблонов классов и вариативные шаблоны здесь не разбираем — только функции и их ограничения.

Почему «просто шаблон» ломается

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

Первая: шаблон принимает всё подряд. Функция template<typename T> void print(const T& x) будет пытаться инстанцироваться и для std::vector, и для указателя на функцию — а внутри вы рассчитывали на operator<<. Ошибка вылезет из глубины тела, а не из точки вызова, и текст её будет нечитаемым.

Вторая: неявные преобразования аргументов при выводе типа не работают так, как при обычной перегрузке. max(1, 2.0) не выведет общий тип — T противоречиво выводится как int и как double одновременно, и вы получите ошибку вывода, а не тихое приведение.

Термин: SFINAE

SFINAE (Substitution Failure Is Not An Error) — правило языка: если при подстановке типа в сигнатуру шаблона получается некорректная конструкция, это не ошибка компиляции, а сигнал «эта перегрузка не подходит, ищем дальше». На нём построены std::enable_if и большая часть трюков до C++20.

Четыре способа ограничить шаблон

1. Обычная перегрузка вместо шаблона

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

// C++17: явные перегрузки, никакого вывода типов
std::string describe(int value) {
    return "целое: " + std::to_string(value);
}

std::string describe(double value) {
    return "дробное: " + std::to_string(value);
}

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

2. enable_if — рабочая лошадка C++17

Если проекту недоступен C++20, ограничение шаблона делается через std::enable_if_t. Идея: если условие ложно, подстановка проваливается по SFINAE, и перегрузка исчезает из кандидатов.

#include <type_traits>

// C++17: функция включается только для целочисленных типов
template<typename T,
         std::enable_if_t<std::is_integral_v<T>, int> = 0>
T half(T value) {
    return value / 2;   // целочисленное деление
}

// отдельная перегрузка для чисел с плавающей точкой
template<typename T,
         std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
T half(T value) {
    return value / 2.0;
}

Здесь half(4) вернёт 2, а half(4.0) — 2.0, и обе перегрузки не конфликтуют, потому что условия взаимоисключающие. Цена enable_if: синтаксис громоздкий, ошибки при промахе всё ещё длинные, а перепутать местоположение enable_if (в возвращаемом типе, в параметре шаблона, в аргументе) легко.

3. if constexpr — одна функция вместо нескольких

Появился в C++17. Позволяет ветвить тело шаблона на этапе компиляции: невыбранная ветка не компилируется для данного типа. Это заменяет пары перегрузок с enable_if, когда логика различается внутри, а не в сигнатуре.

#include <type_traits>
#include <string>

template<typename T>
std::string to_text(const T& value) {
    if constexpr (std::is_same_v<T, std::string>) {
        return value;                       // уже строка
    } else if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);       // число
    } else {
        static_assert(sizeof(T) == 0, "тип не поддержан");
    }
}

Обратите внимание на static_assert(sizeof(T) == 0, ...): голый static_assert(false, ...) в шаблоне сработает даже без инстанцирования на части компиляторов, поэтому условие привязывают к T. Цена if constexpr: шаблон по-прежнему принимает любой тип на вход — вы не отсекаете лишнее на этапе выбора перегрузки, а только ветвитесь внутри уже выбранного.

4. Концепты — как надо в C++20

Концепты (requires, concept) — то, ради чего стоит переходить на C++20. Ограничение пишется читаемо, а сообщение об ошибке при промахе указывает прямо на невыполненное требование, а не на глубину шаблона.

#include <concepts>

// C++20: функция доступна только для целочисленных типов
template<std::integral T>
T half(T value) {
    return value / 2;
}

// то же через requires-выражение, если нужен свой предикат
template<typename T>
requires requires(T a, T b) { a + b; }   // тип поддерживает сложение
T sum(T a, T b) {
    return a + b;
}

Стандартная библиотека C++20 приносит готовые концепты в заголовке <concepts>: std::integral, std::floating_point, std::same_as, std::convertible_to и другие. Их и стоит использовать до того, как писать свои requires.

Правило по умолчанию: не начинайте с шаблона. Начните с одной конкретной функции. Превращайте её в шаблон, только когда типов стало больше и дублирование начало мешать — тогда сразу ограничивайте его концептом или enable_if, а не оставляйте открытым.

Что выбрать

Практический критерий: если компилятор проекта поддерживает C++20 — берите концепты по умолчанию, if constexpr для ветвления внутри. Если застряли на C++17 — enable_if для отсечения типов, if constexpr для внутренней логики, перегрузки там, где типов мало.

Что ломается на практике

• Вывод типа против неявного приведения. max(1, 2.0) не соберётся: T не может быть одновременно int и double. Решение — два параметра шаблона и общий тип: template<typename A, typename B> с возвратом std::common_type_t<A, B> либо явное max<double>(1, 2.0).
• Универсальная ссылка перехватывает всё. template<typename T> void f(T&& x) — это forwarding reference, а не rvalue-ссылка. Он выигрывает разрешение перегрузки у ваших специализаций и «съедает» вызовы, которые вы рассчитывали направить в другую функцию. Ограничивайте его концептом или enable_if.
• Шаблонный конструктор ломает копирование. Шаблонный конструктор с forwarding reference может подменить конструктор копирования. Компилятор выберет шаблон вместо копирующего — классический источник тихих багов.
• Определение в .cpp. Шаблон функции инстанцируется в точке вызова, поэтому его определение должно быть видно вызывающему — то есть лежать в заголовке. Спрятали в .cpp — получите ошибку линковки «undefined reference» при сборке.

Что делать дальше

Проверьте флаг стандарта в сборке: -std=c++20 (GCC/Clang) или /std:c++20 (MSVC). Если он есть — переведите открытые шаблоны на концепты из <concepts> и посмотрите, как изменятся тексты ошибок при заведомо неверном вызове. Если проект на C++17 — соберите список мест, где шаблон принимает любой тип без ограничения, и добавьте enable_if или хотя бы static_assert в теле. Дальше стоит прочитать раздел про forwarding references и std::forward: именно там прячется большинство ошибок разрешения перегрузок в шаблонном коде.