Использование std::enable_if с параметрами анонимного типа

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

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

Давайте упростим ваш пример:

template<typename = int>
void f() {}

template<typename = void>
void f() {}

int main() {
    f<>();
}

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

В вашем случае, если я вызываю foo как foo<void, void>, у меня почти такая же проблема.
Компилятор не может угадать мое намерение, и тот факт, что второй параметр имеет значение по умолчанию, не означает, что вы не можете передать в другом типе.

Из-за этого код имеет неправильный формат, и компилятор корректно выдает ошибку.

В качестве примечания, вы все еще можете работать без использования std::enable_if_t в возвращаемом типе.
В качестве примера:

#include <type_traits>
#include <iostream>

template <typename T, std::enable_if_t<!std::is_integral<T>::value>* = nullptr>
T foo() { std::cout << "non-integral" << std::endl; return T(); }

template <typename T, std::enable_if_t<std::is_integral<T>::value>* = nullptr>
T foo() { std::cout << "integral" << std::endl; return T(); }

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

Пока я пытался выяснить, что было (неправильным) предположением ОП, и объяснить, почему это может быть так, @T.C. правильно указал на фактическую причину в комментариях к этому ответу.
Стоит процитировать его комментарий, чтобы добавить больше деталей к ответу:

Это не разрешение перегрузки; это соответствие объявления. Во-первых, нет двух перегрузок, чтобы возникла какая-либо двусмысленность. Это две ошибки переопределения: шаблон функции и аргумент шаблона по умолчанию.

Вы можете поместить enable_if в возвращаемый тип:

template <typename T>
std::enable_if_t<!std::is_integral<T>::value,T>
foo() { std::cout << "non-integral" << std::endl; return T(); }

template <typename T>
std::enable_if_t<std::is_integral<T>::value, T>
foo() { std::cout << "integral" << std::endl; return T(); }

Кстати, enable_if_t доступно в C++14, так что вместо этого вы можете сказать typename std::enable_if<std::is_integral<T>::value, T>::type. Довольно много.

Но немного более идиоматично (и читабельно) было бы отправлять на основе типа:

template <typename T>
T foo_impl(std::false_type) { std::cout << "non-integral" << std::endl; return T(); }

template <typename T>
T foo_impl(std::true_type) { std::cout << "integral" << std::endl; return T(); }

template <typename T>
T foo(){
    return foo_impl<T>(typename std::is_integral<T>::type{});
}

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

template <typename T>
auto foo() -> std::enable_if_t<!std::is_integral<T>::value, T>
{ std::cout << "non-integral" << std::endl; return T(); }

template <typename T>
auto foo() -> std::enable_if_t<std::is_integral<T>::value, T>
{ std::cout << "integral" << std::endl; return T(); }

Ваша ошибка в том, что вы используете enable_if_t справа от знака равенства.

Вы должны использовать его слева

#include <iostream>
#include <type_traits>

template <typename T, std::enable_if_t<!std::is_integral<T>::value, int> = 0>
T foo() { std::cout << "non-integral" << std::endl; return T(); }

template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
T foo() { std::cout << "integral" << std::endl; return T(); }

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

Но эта работа с C++14.

В С++ 11 (ваш вопрос помечен как С++ 11) у вас нет enable_if_t.

Код становится

#include <iostream>
#include <type_traits>

template <typename T,
          typename std::enable_if<!std::is_integral<T>::value, int>::type = 0>
T foo() { std::cout << "non-integral" << std::endl; return T(); }

template <typename T,
          typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
T foo() { std::cout << "integral" << std::endl; return T(); }

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