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

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

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

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

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

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

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

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

Это особенно опасно при развитии API: добавление специализации не обязательно изменит вызовы, которые начали выбирать другую перегрузку. Кроме того, специализация должна быть объявлена до использования, которое могло вызвать неявное создание первичного шаблона; нарушение этого правила может сделать программу некорректной, а диагностика в некоторых случаях не гарантируется.

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

Процесс можно представить в два этапа:

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

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

#include <iostream>

template<class T>
void show(T) { std::cout << "primary
"; }

template<>
void show<int>(int) { std::cout << "specialization
"; }

template<class T>
void show(T*) { std::cout << "pointer overload
"; }

int main() {
    show(1);
    show(static_cast<int*>(nullptr));
}

Для целого числа выбирается первичный шаблон, после чего используется его специализация для int. Для указателя выбирается перегрузка с параметром-указателем: специализация show<int>(int) вообще не является кандидатом для такого вызова.

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

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

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

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

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

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

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

1. Может ли явная специализация изменить результат, если первичный шаблон проиграл обычной перегрузке?

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

2. Чем в этом отношении отличается специализация функции от частичной специализации класса?

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

3. Что произойдёт, если специализацию объявить после вызова функции?

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