Краткий ответ

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

Например, при вызове accept<double>(1) тип T фиксирован как double, а значение типа int преобразуется к double. При вызове accept(1) тип выводится из аргумента и становится int, поэтому такое преобразование не требуется.

Исторический контекст

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

Поэтому язык разделяет два механизма: явную передачу шаблонных аргументов для управления инстанцированием и автоматический вывод для удобства вызова. После фиксации типа шаблона дальнейшая проверка аргументов выполняется по обычным правилам вызова функции.

Постановка проблемы

Разница особенно важна в числовых, адаптерных и библиотечных интерфейсах. Разработчик может ожидать, что передача int в функцию, явно параметризованную double, будет запрещена, хотя для параметра по значению это корректное стандартное преобразование.

Обратная ошибка тоже возможна: попытка рассчитывать на преобразование при ссылочном параметре может привести к отказу компиляции. Нельзя переносить правила для параметров по значению на указатели и неконстантные lvalue-ссылки.

Подробное решение

Рассмотрим минимальный пример:

#include <iostream>
#include <typeinfo>

template<class T>
void accept(T value) {
    std::cout << typeid(T).name() << '\
';
}

int main() {
    accept<double>(1);
    accept(1);
}

В первом вызове T явно равен double. Параметр функции после подстановки имеет тип double, а аргумент 1 имеет тип int; стандартное преобразование int в double проверяется на этапе сопоставления обычных параметров функции.

Во втором вызове T выводится из аргумента и становится int. Здесь значение не преобразуется к заранее выбранному типу, потому что тип параметра определяется самим аргументом.

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

Правило зависит от формы параметра. Для T& аргумент должен соответствовать ссылке после подстановки; временный результат преобразования нельзя привязать к неконстантной lvalue-ссылке. Для const T& временный объект обычно может быть создан и привязан, а для параметра по значению преобразованное значение передаётся как копия или перемещение.

Таким образом, явный шаблонный аргумент не является приведением типа в общем смысле. Он только задаёт значение параметра шаблона, после чего остаются обычные требования к совместимости типов, перегрузке, доступности конструктора и другим правилам языка.

Ситуация из практики

В библиотеке есть обобщённая функция, принимающая числовое значение и записывающая его в формат с фиксированной точностью. Для вызова с accept<double>(count) выбранный тип интерфейса явно обозначает, что расчёт должен выполняться в double, а целочисленный счётчик может быть преобразован автоматически.

Вариант полагаться только на вывод проще: accept(count) сохраняет исходный тип и не создаёт неявного перехода к double. Его недостаток — алгоритм может инстанцироваться с неподходящим типом или выбрать другую перегрузку.

Вариант явно писать static_cast<double>(count) делает преобразование заметным в месте вызова, но дублирует информацию о типе и может быть неудобен в сложном шаблонном интерфейсе. Выбранный вариант с accept<double>(count) оправдан, когда тип является частью контракта API; при этом для потенциально опасных преобразований нужно добавить ограничения или явную проверку диапазона.

Что кандидаты часто упускают

Останавливается ли вывод всех шаблонных параметров после явного указания одного типа?

Нет. Явно заданные параметры перестают выводиться, но остальные параметры могут быть выведены из аргументов функции. Например, у шаблона с параметрами T и U явное указание T не мешает вывести U, если U встречается в типе параметра функции.

Это позволяет комбинировать управление интерфейсом и автоматический вывод. Однако если явно заданный параметр влияет на форму другого параметра, он может изменить сам набор допустимых преобразований и перегрузок.

Всегда ли явное указание типа разрешает преобразование аргумента к этому типу?

Нет. Разрешённость зависит от итогового типа параметра и категории аргумента. Параметр по значению обычно допускает стандартные преобразования, но неконстантная lvalue-ссылка не может привязаться к временному объекту, созданному таким преобразованием.

Кроме того, пользовательские преобразования, narrowing-преобразования в списочной инициализации, ограничения концептов и удалённые функции могут сделать вызов некорректным. Явный шаблонный аргумент не отменяет эти правила.

Чем отличается явное указание шаблонного типа от явного приведения аргумента?

accept<double>(x) фиксирует параметр шаблона T как double, но само преобразование x выполняется по правилам передачи аргумента функции. accept(static_cast<double>(x)) сначала явно преобразует выражение, а затем выводит T из уже преобразованного значения.

Эти записи могут инстанцировать один и тот же шаблон, но выражают разное намерение. Первая управляет выбором шаблонного параметра, тогда как вторая управляет типом конкретного выражения и может влиять на перегрузку, категорию значения и диагностику ошибок.