Вау, они такие же! Итак, T(Floating) на самом деле является переопределением версии T(Integer) While Right, объявляющей два шаблона с разными параметрами:

template
<
     typename FirstParamName
,    typename SecondParamName
>
T(FirstParamName)

template
<
    typename FirstParamName
,   typename SecondParamName
>
T(FirstParamName)

Также обратите внимание, что нет необходимости использовать typename перед std::enable_if_t<std::is_floating_point<Floating>::value, int> в объявлении шаблона «Right», потому что там нет имен зависимых типов.

template
<
     typename FirstParamName
,    std::enable_if_t<std::is_integral<FirstParamName>::value, int> SecondParamName
> 
T(FirstParamName)

template
<
    typename FirstParamName
,   std::enable_if_t<std::is_floating_point<FirstParamName>::value, int> SecondParamName
>
T(FirstParamName)

Дело не в типе или отсутствии типа

Дело в том, проходит ли он первый шаг двухэтапного поиска.

Почему ? Поскольку SFINAE работает на втором этапе поиска, когда шаблон вызывается (как сказал @cpplearner)

Это не работает (случай 1):

So :

И эта работа, а также ваш случай без типа (случай 2):

 template <
        typename Integer,
        typename = std::enable_if_t<std::is_integral<Integer>::value>
    >

В первом случае компилятор видит: то же имя, такое же количество аргументов шаблона и аргумент не зависит от шаблона, те же параметры => это то же самое => ОШИБКА

template <
        typename Integer,
        typename = std::enable_if_t<std::is_integral<Integer>::value>,  
        typename = void
    >

В случае с двумя, а не с одинаковым количеством аргументов, давайте посмотрим, сработает ли это позже => SFINAE => ОК

В вашем ПРАВИЛЬНОМ случае: компилятор видит: то же имя, такое же количество аргументов шаблона и аргумент зависит от шаблона (со значением по умолчанию, но сейчас ему все равно) => давайте посмотрим, когда это звонок => СФИНАЭ => ОК

Кстати, а как вы вызываете конструктор?

Из этого сообщения

Невозможно явно указать шаблоны для конструктора, так как вы не можете назвать конструктор.

И вы действительно не можете:

ошибка: невозможно вызвать конструктор 'T :: T' напрямую [-fpermissive]

T t =T::T<int,void>(1);

Вы все еще можете заставить его работать со специализацией и SFINAE:

Это стиль C ++ 14, в 17 вы можете придумать версию, которая компилируется только с T t(1), но я не эксперт по Вывод аргументов шаблона класса

#include <iostream>
#include <type_traits>
using namespace std;


template <
        typename Type,
        typename = void
    >
struct T {
};

template < typename Type>
struct T<
    Type,
    std::enable_if_t<std::is_integral<Type>::value>
>  {
    float m_type;

    T(Type t) : m_type(t) { cout << __PRETTY_FUNCTION__ << endl; }
};

template < typename Type>
struct T<
    Type,
    std::enable_if_t<std::is_floating_point<Type>::value>
>  {
    int m_type;

    T(Type t) : m_type(t) { cout << __PRETTY_FUNCTION__ << endl; }

};

int main(){

    T<int> t(1); // T<Type, typename std::enable_if<std::is_integral<_Tp>::value, void>::type>::T(Type) [with Type = int; typename std::enable_if<std::is_integral<_Tp>::value, void>::type = void]
    cout << endl;
    T<float> t2(1.f);// T<Type, typename std::enable_if<std::is_floating_point<_Tp>::value, void>::type>::T(Type) [with Type = float; typename std::enable_if<std::is_floating_point<_Tp>::value, void>::type = void]

    return 0;
}

Я собираюсь немного переписать неправильную версию, чтобы помочь поговорить о том, что происходит.

Все, что я сделал, это присвоил ранее анонимному второму параметру имя - U.

struct T {
    enum { int_t,float_t } m_type;
    template <
        typename Integer,
        typename U = std::enable_if_t<std::is_integral<Integer>::value>
    >
    T(Integer) : m_type(int_t) {}

    template <
        typename Floating,
        typename U = std::enable_if_t<std::is_floating_point<Floating>::value>
    >
    T(Floating) : m_type(float_t) {} // error: cannot overload
};

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

К какой функции это следует вывести? Если это целочисленная версия, это, конечно, работает, но как насчет версии с плавающей запятой. У него есть T = int, но как насчет U? Ну, мы только что дали ему тип bool, так что у нас есть U = bool. Таким образом, в этом случае нет возможности выбрать между ними, они идентичны. (Обратите внимание, что в целочисленной версии у нас все еще есть U = bool).

f<int,void>(1);

Поэтому, если мы явно назовем второй параметр шаблона, вывод не удастся. И что? В реальном случае этого не должно происходить. Мы собираемся использовать что-то вроде

где возможен вычет. Вы заметите, что компилятор выдает ошибку даже без объявления. Это означает, что он решил, что не может сделать вывод, даже не предоставив ему тип для вывода, поскольку он обнаружил проблему, о которой я упоминал выше. Итак, из intro.defs у нас есть подпись как

f(1.f);

Шаблон функции-члена класса⟩ имя, список-типов-параметров, класс, членом которого является функция, cv-квалификаторы (если есть), ref-qualifier (если есть), тип возвращаемого значения (если есть) и список параметров шаблона

А из temp.over.link мы знаем, что два шаблона определения функций не могут иметь одинаковую сигнатуру.

К сожалению, стандарт кажется довольно расплывчатым относительно того, что именно означает «список параметров шаблона». Я просмотрел пару разных версий стандарта, и ни одна из них не дала четкого определения, которое я мог найти. Неясно, является ли «список параметров шаблона» таким же, если параметр типа a с другим значением по умолчанию считается уникальным или нет. Учитывая, что я собираюсь сказать, что это на самом деле неопределенное поведение, и ошибка компилятора - приемлемый способ справиться с этим.

Вердикт еще не вынесен, и если кто-то сможет найти явное определение в стандарте для «списка параметров шаблона», я был бы рад добавить его для более удовлетворительного ответа.

Как заметил xskxkr, самый обновленный черновик на самом деле дает более конкретное определение. Шаблоны имеют шаблон-заголовок, который содержит список-параметров-шаблона, который представляет собой серию параметров-шаблона. В определение не входят аргументы по умолчанию. Итак, согласно текущему черновику, наличие двух одинаковых шаблонов, но с разными аргументами по умолчанию, однозначно неверно, но вы можете «обмануть» его, думая, что у вас есть две отдельные головки шаблона, делая тип второго параметра зависимым от результата enable_if.

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

¹ В качестве примечания, я не мог придумать способ явно создать экземпляр конструктора шаблона не-шаблонного класса. Это странная конструкция. Я использовал f в своих примерах, так как действительно мог заставить его работать с бесплатной функцией. Может еще кто-нибудь сможет разобраться в синтаксисе?

Редактировать: