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

Ответ 1

Вот что происходит, когда вы пишете f<0>().

• Компилятор просматривает f и находит две объявления шаблонов функций:

  template <int I>   void foo();
  template <short S> void foo();
  

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

  template <int I>   void foo(); // with I = 0
  template <short S> void foo(); // with S = 0
  

  Замена завершается в обоих случаях, потому что 0 является int и может быть преобразован в short, и преобразование является разрешенным преобразованием в этом контексте.

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

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

Ответ 2

Сообщение об ошибке компилятора *. Вы бы интуитивно считали, что это означает, что "вызов функции неоднозначен!", Но на самом деле компиляция не выполняется на более ранней стадии, определение специализированной функции даже не генерируется в этой точке.

На самом деле это означает: "Специализация функции неоднозначна!"

Давайте посмотрим, как это компилируется:

template <short S> void foo() { std::cout << "S: " << S << '\n'; }

int main(int argc, char* argv[])
{
    foo<0>();
    return 0;
}

Первым шагом компиляции является специализированная специализация.

Шаг 1. Компилятор понимает, что foo<0> является специализированным шаблоном и соответственно генерирует объявление функции:

template <short S> void foo() { std::cout << "S: " << S << '\n'; }

template<>
void foo<0>();

int main(int argc, char* argv[])
{
    foo<0>();
    return 0;
}

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

template <short S> void foo() { std::cout << "S: " << S << '\n'; }

template<>
void foo<0>();

int main(int argc, char* argv[])
{
    foo<0>();
    return 0;
}

template<>
void foo<0>(){
    std::cout << "S: " << 0 << '\n';
}

Шаг 3: Теперь у вас есть вызываемая функция, компиляция продолжается нормально.

Давайте попробуем выполнить те же шаги в вашем случае:

template <short S> void foo() { std::cout << "S: " << S << '\n'; }
template <int I>   void foo() { std::cout << "I: " << I << '\n'; }

int main(int argc, char* argv[])
{
    foo<0>();
    return 0;
}

Шаг 1: создание объявления функции:

template <short S> void foo() { std::cout << "S: " << S << '\n'; }
template <int I>   void foo() { std::cout << "I: " << I << '\n'; }

template<>
void foo<0>();

int main(int argc, char* argv[])
{
    foo<0>();
    return 0;
}

И на данный момент компиляция терпит неудачу, потому что специализированное объявление foo неоднозначно. Если вы хотите получить доказательство, попробуйте выполнить компиляцию этого кода:

template <short S> void foo() { std::cout << "S: " << S << '\n'; }
template <int I>   void foo() { std::cout << "I: " << I << '\n'; }

template<>
void foo<0>();

int main(int argc, char* argv[])
{
    return 0;
}

Вы получите то же сообщение об ошибке без вызова функции!

Обновление

Таким образом, выгода заключается в том, что все переводится в специализированные объявления функций. Поэтому независимо от того, пишете ли вы foo<int{0}> из foo<short{0}>, компилятор будет генерировать template<> void foo<0>(); для обоих. Явные типы будут проигнорированы. (Вот почему его действительно важно, чтобы они были constexpr -s.)

Обновление Как T.C. в своем комментарии, в стандарте (413-я страница в формате PDF) есть очень похожий пример:

[Пример: В следующем примере предполагается, что подписанный char не может представляют значение 1000, сужение преобразования (8.5.4) будет требуется преобразовать шаблон-аргумент типа int в подписанный char, поэтому замена для второго шаблона (14.3.2) не выполняется.

 template <int> int f(int);
 template <signed char> int f(int);
 int i1 = f<1000>(0); // OK
 int i2 = f<1>(0); // ambiguous; not narrowing

-end пример]

* Сообщение об ошибке полностью верно. Не может быть особенно интуитивным, но он отражает процедуру, указанную в стандарте. - T.C.

Ответ 3

Функция шаблона здесь параметризована по значению и только по значению, а не по типу! обновление: теперь я не уверен. С другой стороны, не templated версия параметризуется по типу (и можно пользоваться полиморфными вызовами).

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