Как работает " void t

когда вы пишите has_member<A>::value, компилятор ищет имя has_member и находит первичный шаблон класса, то есть, это объявление:

template< class , class = void >
struct has_member;

(в OP это написано как определение.)

список аргументов шаблона <A> сравнивается со списком параметров шаблона этого основного шаблона. Поскольку основной шаблон имеет два параметра, но вы указали только один, оставшийся параметр по умолчанию используется в шаблоне по умолчанию аргумент: void. Это как если бы вы написали has_member<A, void>::value.

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

template< class T >
struct has_member< T , void_t< decltype( T::member ) > > : true_type
{ };

компилятор пытается сопоставить аргументы шаблона A, void с шаблонами, определенными в частичной специализации:T и void_t<..> по одиночке. Во-первых, выполняется вывод аргумента шаблона. Частичная специализация выше по-прежнему является шаблоном с шаблоном-параметрами, которые должны быть "заполнены" аргументами.

первая модель,T, позволяет компилятору вывести шаблон-параметр T. Это тривиальный вывод, но рассмотрим такой шаблон, как T const&, где мы еще могли вывести T. По шаблону T и аргумент шаблона A, то вывести T будет A.

во втором паттерне void_t< decltype( T::member ) > шаблон-параметр T появляется в контексте, где он не может быть выведен из любого аргумента шаблона. Для этого есть две причины:

• выражение внутри decltype явно исключается из вычета аргумента шаблона. Я думаю, это потому, что он может быть сколь угодно сложной.

• даже если мы использовали шаблон без decltype как void_t< T >, тогда вычитание T происходит на разрешенном шаблоне псевдонима. То есть мы разрешаем шаблон псевдонима и затем пытаемся вывести тип T из полученного шаблона. Однако результирующий шаблон void, который не зависит от T и поэтому не позволяет нам найти конкретный тип для T. Это похоже на математическую задачу о попытке инвертировать постоянную функцию (в математическом смысле этих терминов).

шаблон вывод аргумента завершен^(*), теперь вывести аргументы шаблона подставляются. Это создает специализацию, которая выглядит следующим образом:

template<>
struct has_member< A, void_t< decltype( A::member ) > > : true_type
{ };

тип void_t< decltype( A::member ) > > теперь можно оценить. Он хорошо формируется после замены, следовательно, нет Замещение Отказ происходит. Получаем:

template<>
struct has_member<A, void> : true_type
{ };

теперь мы можем сравнить список параметров шаблона этой специализации с аргументами шаблона, предоставленными в оригинал has_member<A>::value. Оба типа точно совпадают, поэтому выбрана эта частичная специализация.

С другой стороны, когда мы определяем шаблон:

template< class , class = int > // <-- int here instead of void
struct has_member : false_type
{ };

template< class T >
struct has_member< T , void_t< decltype( T::member ) > > : true_type
{ };

мы в конечном итоге с той же специализации:

template<>
struct has_member<A, void> : true_type
{ };

но наш список аргументов шаблона для has_member<A>::value сейчас <A, int>. Аргументы не совпадают с параметрами специализации,и основной шаблон выбирается в качестве резервного.

---

^(*) Стандартный, IMHO путает, включает в себя процесс подстановки и сопоставления явно указанных аргументов шаблона в вычет аргумента шаблона