Почему enable_if_t в аргументах шаблона жалуется на переопределение?

Удалим немного кода.

template<
  class T,
  class U/* = std::enable_if_t<std::is_same<int, T>::value>*/
 >
void g() { }

template<
  class T,
  class U/* = std::enable_if_t<std::is_same<double, T>::value>*/
 >
void g() { }

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

Обе они являются шаблонными функциями "типа" template<class,class>void(). Тот факт, что аргумент 2-го типа имеет другое значение по умолчанию, не имеет значения. Это было бы похоже на ожидание перегрузки двух разных функций print(string, int) с разными значениями int по умолчанию. ;)

В первом случае имеем:

template<
  typename T,
  typename std::enable_if<std::is_same<int, T>::value>::type* = nullptr
>
void f() { }

template<
  typename T,
  typename std::enable_if<std::is_same<double, T>::value>::type* = nullptr
>
void f() { }

здесь мы не можем удалить пункт enable_if. Обновление до enable_if_t:

template<
  class T,
  std::enable_if_t<std::is_same<int, T>::value, int>* = nullptr
>
void f() { }

template<
  class T,
  std::enable_if_t<std::is_same<double, T>::value, int>* = nullptr
>
void f() { }

Я также заменил использование typename на class. Я подозреваю, что вы запутались, потому что typename имеет два значения: одно как маркер для своего рода аргумента template, а другое как средство устранения неоднозначности для зависимого типа.

Здесь второй аргумент — это указатель, тип которого зависит от первого. Компилятор не может определить, конфликтуют ли эти два типа, без предварительной замены типа T, и вы заметите, что на самом деле они никогда не будут конфликтовать.

enable_if_t<B> — это просто псевдоним для typename enable_if<B>::type. Давайте подставим это в g, чтобы увидеть реальную разницу между f и g:

template<typename T,
         typename std::enable_if<std::is_same<int, T>::value>::type* = nullptr>
void f() { }

template<typename T,
         typename std::enable_if<std::is_same<double, T>::value>::type* = nullptr>
void f() { }

template<typename T,
         typename = typename std::enable_if<std::is_same<int, T>::value>::type>
void g() { }

template<typename T,
         typename = typename std::enable_if<std::is_same<double, T>::value>::type>
void g() { }

В случае f у нас есть два шаблона функций, оба с параметрами шаблона <typename, X*>, где тип X зависит от типа аргумента первого шаблона. В случае g у нас есть два шаблона функций с параметрами шаблона <typename, typename>, и зависит только аргумент шаблона по умолчанию, поэтому C++ считает, что они оба объявляют одну и ту же сущность.

Любой стиль можно использовать с псевдонимом enable_if_t:

template<typename T,
         std::enable_if_t<std::is_same<int, T>::value>* = nullptr>
void f() { }

template<typename T,
         std::enable_if_t<std::is_same<double, T>::value>* = nullptr>
void f() { }

template<typename T,
         typename = std::enable_if_t<std::is_same<int, T>::value>>
void g() { }

template<typename T,
         typename = std::enable_if_t<std::is_same<double, T>::value>>
void g() { }

Для возвращаемого типа функции вы ищете следующее:

template<typename T> std::enable_if_t< conditional, instantiation result > foo();

Пример:

#include <iostream>

// when T is "int", replace with 'void foo()'   
template<typename T>
std::enable_if_t<std::is_same<int, T>::value, void> foo() {
    std::cout << "foo int\n";
}

template<typename T>
std::enable_if_t<std::is_same<float, T>::value, void> foo() {
    std::cout << "foo float\n";
}

int main() {
    foo<int>();
    foo<float>();
}

http://ideone.com/TB36gH

смотрите также

http://ideone.com/EfLkQy

Вам не хватает "::type" ..

 template<typename T,
             typename = std::enable_if_t<std::is_same<int, T>::value>::type>
    void g() { }

    template<typename T,
             typename = std::enable_if_t<std::is_same<double, T>::value>::type>
    void g() { }