Все действительные шаблоны созданы?

Question

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

template <typename T> void foo(T*);
template <typename T> void foo(T**);

template void foo(int**);

template <typename T> void foo(T*) { printf("called foo(T*)\n"); }
template <typename T> void foo(T**){ printf("called foo(T**)\n"); }

Когда нам нужно создать экземпляр foo (int **), любой из экземпляров будет работать, один с T = int* а другой с T = int **.На практике объектный файл содержит только один, T ** один.С другой стороны, если я добавлю static_assert(false) в неиспользуемую, компиляция не удастсяОзначает ли это, что является экземпляром?

Получается, что T ** - это то, что я хочу использовать в этом случае.Но даже если бы оба экземпляра были созданы, разрешение перегрузки выбрало бы T **, так что это работает для меня в любом случае.

Теперь в моем реальном коде я запрашиваю два экземпляра:

template void foo(int*);
template void foo(int**);

Это создает экземпляры foo<int>(int**) и foo<int>(int*), поэтому я получаю оба шаблона.Последнее является принудительным, поскольку template <typename T> foo(T**) не совпадает.Но я не понимаю правил, чтобы знать, почему я не получаю foo<int*>(int**) за первое.Или и foo<int*>(int**), и foo<int>(int**).

И да, я понимаю, что мог бы сделать template void foo<int*>(int**), если бы мне нужно было его форсировать.

Все это заставляет меня понять, что я недействительно не понимаю, что происходит, когда компилятор видит вызов, требующий создания шаблона.Сканирует ли он шаблоны, пока не находит работающий, а затем останавливается?Или он создает все допустимые параметры (а затем что-то отбрасывает ненужные из объектного файла)?

Answer 1

, если я положу static_assert(false) в неиспользованный, компиляция не удастся.Означает ли это, что он создан?

Нет.Компилятор выполняет некоторые базовые проверки определения шаблона.Все в определении должно быть допустимым C ++, но некоторые вещи, которые зависят от параметра шаблона, не могут быть проверены до фактической реализации, когда известны аргументы шаблона.Так как static_assert(false); не зависит от каких-либо параметров шаблона, он всегда вызывает ошибку, и компилятору разрешено замечать ошибку, даже если шаблон никогда не создается.

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

Но я не понимаю правил, чтобы знать, почему я не получаю foo<int*>(int**) для первого.

В большинстве контекстов, которые называют специализацию шаблона функции, есть правило, что любой шаблон, который "более специализирован", чем все другие жизнеспособные перегрузки, является тем, который используется,Точное определение «более специализированного» является немного хитрым, но основная идея состоит в том, что если любой список аргументов, который может быть взят шаблоном функции «A», мог бы также быть взят шаблоном функции «B», но не наоборот,тогда «А» является более специализированным.В вашем примере

template <typename T> void foo(T*);  // #1
template <typename T> void foo(T**); // #2

, если аргумент arg имеет тип U** для любого типа U, так что вывод аргумента шаблона для шаблона # 2 для foo(arg) может быть успешным с T=U, мыможно увидеть, что вывод аргумента шаблона для шаблона # 1 для foo(arg) также может быть успешным с T=U*.С другой стороны, вполне возможно, что другой аргумент arg2 может означать, что аргумент шаблона для foo(arg2) может быть успешным для шаблона # 1, но не для шаблона # 2, например, если arg2 имеет тип int*.Таким образом, шаблон функции # 2 более специализирован, чем шаблон функции # 1.Это означает, что выражение типа foo(arg) всякий раз, когда вычитание типа для обоих завершается успешно (и нет никаких других задействованных перегрузок), означает использование шаблона # 2.

То же самое "более специализированное" правило применяется в вашемявное создание

template void foo(int**);

Как и в случае выражения вызова функции, компилятор будет использовать дедукцию аргумента шаблона, чтобы увидеть, соответствует ли данное объявление каждому шаблону функции.В этом случае оба успешны, но поскольку шаблон №2 более специализирован, объявление интерпретируется как специализация №2, а не №1.

Все это заставляет меня понять, что я не совсем понимаючто происходит, когда компилятор видит вызов, который требует создания шаблона.Сканирует ли он шаблоны, пока не находит работающий, а затем останавливается?Или он создает все допустимые параметры (а затем что-то отбрасывает ненужные из объектного файла)?

Грубая последовательность для большинства случаев использования имени перегруженного шаблона функции:

1. Выполните поиск по имени, чтобы определить список шаблонов функций и функций, которые необходимо рассмотреть.

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

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

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

Answer 2

Вычисление аргумента шаблона выполняется, чтобы выяснить, какая специализация шаблона функции названа template void foo(int**);;он выбирает T** один после рассмотрения частичного заказа.См. [temp.deduct.decl] и связанные с ним разделы.Это примерно тот же процесс, который используется для выбора шаблона функции для вызова во время разрешения перегрузки (с некоторыми незначительными отличиями).

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

С другой стороны, если я добавлю static_assert(false) в неиспользуемую, компиляция завершится неудачно.,Означает ли это, что он создан?

Это просто [temp.res] / 8 на работе, как обычно.Неправильный код, не зависящий от параметра шаблона, может быть немедленно диагностирован без создания экземпляра.