Частичная специализация шаблона функции с ++?

Частичная специализация функции пока не разрешена стандартом. В этом примере вы на самом деле перегружаете и не специализируете функцию max<T1,T2>.
Ее синтаксис должен был выглядеть несколько, как показано ниже, если бы было разрешено:

// Partial specialization is not allowed by the spec, though!
template <typename T> 
inline T const& max<T,T> (T const& a, T const& b)
{                  ^^^^^ <--- [supposed] specializing here
  return 10;
}

В случае шаблонов функций стандартом C ++ разрешена только полная специализация, за исключением расширений компилятора!

Поскольку частичная специализация не допускается, как указывали другие ответы, вы можете обойти ее, используя std::is_same и std::enable_if, как показано ниже:

template <typename T, class F>
inline typename std::enable_if<std::is_same<T, int>::value, void>::type
typed_foo(const F& f) {
    std::cout << ">>> messing with ints! " << f << std::endl;
}

template <typename T, class F>
inline typename std::enable_if<std::is_same<T, float>::value, void>::type
typed_foo(const F& f) {
    std::cout << ">>> messing with floats! " << f << std::endl;
}

int main(int argc, char *argv[]) {
    typed_foo<int>("works");
    typed_foo<float>(2);
}

Выход:

$ ./a.out 
>>> messing with ints! works
>>> messing with floats! 2

Изменить: если вам нужно иметь возможность обрабатывать все остальные оставшиеся случаи, вы можете добавить определение, в котором говорится, что уже обработанные случаи не должны совпадать - в противном случае вы d попадут в двусмысленные определения. Определение могло быть таким:

template <typename T, class F>
inline typename std::enable_if<(not std::is_same<T, int>::value)
    and (not std::is_same<T, float>::value), void>::type
typed_foo(const F& f) {
    std::cout << ">>> messing with unknown stuff! " << f << std::endl;
}

int main(int argc, char *argv[]) {
    typed_foo<int>("works");
    typed_foo<float>(2);
    typed_foo<std::string>("either");
}

Что производит:

$ ./a.out 
>>> messing with ints! works
>>> messing with floats! 2
>>> messing with unknown stuff! either

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

Что такое специализация?

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

В функциональных языках выбор выполняется с помощью сопоставления с шаблоном:

-- An instance of Maybe is either nothing (None) or something (Just a)
-- where a is any type
data Maybe a = None | Just a

-- declare function isJust, which takes a Maybe
-- and checks whether it's None or Just
isJust :: Maybe a -> Bool

-- definition: two cases (_ is a wildcard)
isJust None = False
isJust Just _ = True

Как видите, мы перегружаем определение isJust.

Что ж, шаблоны классов C ++ работают точно так же. Вы предоставляете объявление main, в котором указывается количество и характер параметров. Это может быть просто объявление или также действовать как определение (по вашему выбору), а затем вы можете (если хотите) предоставить специализации шаблона и связать с ними другую (в противном случае было бы глупо) версию класса. .

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

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

(подробные сведения см. в GotW № 49)

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

Это специализация шаблона?

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

Неклассовая, неизменяемая частичная специализация не допускается, но, как сказано:

Все проблемы в информатике могут быть решены другим уровнем косвенного обращения. —— Дэвид Уиллер

Добавление класса для пересылки вызова функции может решить эту проблему, вот пример:

template <class Tag, class R, class... Ts>
struct enable_fun_partial_spec;

struct fun_tag {};

template <class R, class... Ts>
constexpr R fun(Ts&&... ts) {
  return enable_fun_partial_spec<fun_tag, R, Ts...>::call(
      std::forward<Ts>(ts)...);
}

template <class R, class... Ts>
struct enable_fun_partial_spec<fun_tag, R, Ts...> {
  constexpr static R call(Ts&&... ts) { return {0}; }
};

template <class R, class T>
struct enable_fun_partial_spec<fun_tag, R, T, T> {
  constexpr static R call(T, T) { return {1}; }
};

template <class R>
struct enable_fun_partial_spec<fun_tag, R, int, int> {
  constexpr static R call(int, int) { return {2}; }
};

template <class R>
struct enable_fun_partial_spec<fun_tag, R, int, char> {
  constexpr static R call(int, char) { return {3}; }
};

template <class R, class T2>
struct enable_fun_partial_spec<fun_tag, R, char, T2> {
  constexpr static R call(char, T2) { return {4}; }
};

static_assert(std::is_same_v<decltype(fun<int>(1, 1)), int>, "");
static_assert(fun<int>(1, 1) == 2, "");

static_assert(std::is_same_v<decltype(fun<char>(1, 1)), char>, "");
static_assert(fun<char>(1, 1) == 2, "");

static_assert(std::is_same_v<decltype(fun<long>(1L, 1L)), long>, "");
static_assert(fun<long>(1L, 1L) == 1, "");

static_assert(std::is_same_v<decltype(fun<double>(1L, 1L)), double>, "");
static_assert(fun<double>(1L, 1L) == 1, "");

static_assert(std::is_same_v<decltype(fun<int>(1u, 1)), int>, "");
static_assert(fun<int>(1u, 1) == 0, "");

static_assert(std::is_same_v<decltype(fun<char>(1, 'c')), char>, "");
static_assert(fun<char>(1, 'c') == 3, "");

static_assert(std::is_same_v<decltype(fun<unsigned>('c', 1)), unsigned>, "");
static_assert(fun<unsigned>('c', 1) == 4, "");

static_assert(std::is_same_v<decltype(fun<unsigned>(10.0, 1)), unsigned>, "");
static_assert(fun<unsigned>(10.0, 1) == 0, "");

static_assert(
    std::is_same_v<decltype(fun<double>(1, 2, 3, 'a', "bbb")), double>, "");
static_assert(fun<double>(1, 2, 3, 'a', "bbb") == 0, "");

static_assert(std::is_same_v<decltype(fun<unsigned>()), unsigned>, "");
static_assert(fun<unsigned>() == 0, "");

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

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

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

Итак, давайте представим, что мы пытались решить:

template <typename R, typename X, typename Y>
void function(X x, Y y)
{
    R* r = new R(x);
    f(r, y); // another template function?
}

// for some reason, we NEED the specialization:
template <typename R, typename Y>
void function<R, int, Y>(int x, Y y) 
{
    // unfortunately, Wrapper has no constructor accepting int:
    Wrapper* w = new Wrapper();
    w->setValue(x);
    f(w, y);
}

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

template <typename R, typename T>
R* create(T t)
{
    return new R(t);
}
template <>
Wrapper* create<Wrapper, int>(int n) // fully specialized now -> legal...
{
    Wrapper* w = new Wrapper();
    w->setValue(n);
    return w;
}

template <typename R, typename X, typename Y>
void function(X x, Y y)
{
    R* r = create<R>(x);
    f(r, y); // another template function?
}

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