Различия между шаблонной специализацией и перегружающийся для функций?

Один из таких примеров:

#include <cstdio>

template <class T>
void foo(T )
{
    puts("T");
}

//template <>
void foo(int*)
{
    puts("int*");
}

template <class T>
void foo(T*)
{
    puts("T*");
}

int main()
{
    int* a;
    foo(a);
}

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

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

ОБНОВЛЕНИЕ: Чтобы уточнить, в комментариях AraK, вы действительно сравниваете яблоки и апельсины здесь. Перегрузка функций используется для предоставления возможности иметь разные функции с одним именем, если они имеют разные подписи. Специализация шаблона используется для определения определенного фрагмента кода для конкретного параметра типа. У вас не может быть специализации шаблона, если у вас нет шаблона. Если вы удалите первый фрагмент кода, который объявляет универсальный шаблон, вы получите ошибку времени компиляции, если попытаетесь использовать специализацию шаблона.

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

Если вы предоставляете перегрузку, вы объявляете независимый метод с тем же именем. Вы не запрещаете использовать шаблон с определенным параметром типа. Чтобы продемонстрировать этот факт, попробуйте:

template <typename T>
T inc(const T& t)
{
    return t + 1;
}

int inc(const int& t)
{
    return t + 42;
}

#include <iostream>
int main() {
   int x = 0;
   x = inc<int>(x);
   std::cout << "Template: " << x << std::endl; // prints 1.

   x = 0;
   x = inc(x);
   std::cout << "Overload: " << x << std::endl; // prints 42.
}

Как видите, в этом примере есть две различные функции inc для значений int : inc (const int &) и inc (const int &) . Вы не смогли бы расширить общий шаблон с помощью int , если бы вы использовали специализацию шаблона.

Если вы предоставляете перегрузку, вы объявляете независимый метод с тем же именем. Вы не запрещаете использовать шаблон с определенным параметром типа. Чтобы продемонстрировать этот факт, попробуйте:

template <typename T>
T inc(const T& t)
{
    return t + 1;
}

int inc(const int& t)
{
    return t + 42;
}

#include <iostream>
int main() {
   int x = 0;
   x = inc<int>(x);
   std::cout << "Template: " << x << std::endl; // prints 1.

   x = 0;
   x = inc(x);
   std::cout << "Overload: " << x << std::endl; // prints 42.
}

Как видите, в этом примере есть две различные функции inc для значений int : inc (const int &) и inc (const int &) . Вы не смогли бы расширить общий шаблон с помощью int , если бы вы использовали специализацию шаблона.

Если вы предоставляете перегрузку, вы объявляете независимый метод с тем же именем. Вы не запрещаете использовать шаблон с определенным параметром типа. Чтобы продемонстрировать этот факт, попробуйте:

template <typename T>
T inc(const T& t)
{
    return t + 1;
}

int inc(const int& t)
{
    return t + 42;
}

#include <iostream>
int main() {
   int x = 0;
   x = inc<int>(x);
   std::cout << "Template: " << x << std::endl; // prints 1.

   x = 0;
   x = inc(x);
   std::cout << "Overload: " << x << std::endl; // prints 42.
}

Как видите, в этом примере есть две различные функции inc для значений int : inc (const int &) и inc (const int &) . Вы не смогли бы расширить общий шаблон с помощью int , если бы вы использовали специализацию шаблона.

существуют две различные функции inc для значений int : inc (const int &) и inc (const int &) . Вы не смогли бы расширить общий шаблон с помощью int , если бы вы использовали специализацию шаблона.

существуют две различные функции inc для значений int : inc (const int &) и inc (const int &) . Вы не смогли бы расширить общий шаблон с помощью int , если бы вы использовали специализацию шаблона.

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

Just to elaborate on the first point mentioned by litb in his answer. Specializations are only checked once overload resolution has actually selected a primary template. The result can lead to some surprises where a function is overloaded and has explicit specializations:

template <typename T> void foo (T);  // Primary #1
template <> void foo<int*> (int*);   // Specialization of #1

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

void bar (int * i)
{
  foo(i);
}

When choosing which function to call, the following steps take place:

1. Name lookup finds both primary templates.
2. Each template is specialized and overload resolution attempts to select a best function based on conversions between the arguments and parameters.
3. In thise case, there is no difference in the quality of the conversions.
4. Partial ordering rules are then used to select the most specialized template. In this case that is the second parimary "foo(T*)".

Only after these steps, when the best function has been selected will explicit specializations of the selected function be considered. (In this case primary #2 has none so none are considered).

The only way to call the above explicit specialization here, is to actually use explicit template arguments in the call:

void bar (int * i)
{
  foo<int*> (i);  // expliit template argument forces use of primary #1
}

A good rule of thumb is to try to avoid having overloads that are also explicily specialized, as the resulting rules are pretty complex.