Comment `void_t travail

Lorsque vous écrivez has_member<A>::value, le compilateur recherche le nom has_member et trouve le primaire modèle de classe, qui est, cette déclaration:

template< class , class = void >
struct has_member;

(Dans l'OP, c'est écrit comme une définition.)

Le modèle de la liste d'arguments <A> est comparé au modèle de la liste des paramètres de ce modèle. Depuis la primaire modèle dispose de deux paramètres, mais vous ne fourni à un, les autres paramètre est défini par défaut pour le modèle par défaut de l'argument: void. C'est comme si vous aviez écrit has_member<A, void>::value.

Maintenant, le modèle de la liste des paramètres est comparée à toutes les spécialisations du modèle has_member. Si aucune spécialisation correspond à la définition de la primaire modèle est utilisé comme une solution de repli. Donc la spécialisation partielle est prise en compte:

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

Le compilateur essaie de faire correspondre les arguments de modèle A, void avec les modèles définis dans la partielle de spécialisation: T et void_t<..> un par un. Tout d'abord, le modèle de l'argument de la déduction est effectuée. La spécialisation partielle ci-dessus est encore un modèle avec un modèle de paramètres qui doivent être "rempli" par des arguments.

Le premier modèle, T, permet au compilateur de déduire le modèle de paramètre T. C'est une simple déduction, mais envisager un modèle de type T const&, où l'on peut encore déduire T. Pour le modèle de la T et l'argument de modèle A, on en déduit T être A.

Dans le deuxième modèle void_t< decltype( T::member ) >, le modèle à paramètre T apparaît dans un contexte où il ne peut pas être déduite à partir de n'importe quel argument de modèle. Il y a deux raisons à cela:

• L'expression à l'intérieur de decltype est explicitement exclus de l'argument de modèle de déduction. Je suppose que c'est parce qu'il peut être arbitrairement complexe.

• Même si nous avons utilisé un modèle sans decltype comme void_t< T >, la déduction de T qui se passe sur l'résolu alias modèle. Qui est, résoudre les alias de modèle, puis essayez d'en déduire le type T à partir du modèle obtenu. Le modèle obtenu est cependant void, qui ne dépend pas de T et, par conséquent, ne nous autorise pas à trouver un type spécifique pour T. Ceci est similaire à la mathématique du problème d'essayer d'inverser une fonction constante (dans le sens mathématique de ces termes).

Argument de modèle déduction est fini^(*), maintenant la déduit modèle arguments sont substitués. Cela crée une spécialisation qui ressemble à ceci:

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

Le type void_t< decltype( A::member ) > > maintenant peut être évaluée. Il est bien-formé après la substitution, par conséquent, pas de Substitution Échec se produit. Nous obtenons:

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

Maintenant, nous pouvons comparer le paramètre de modèle de liste de cette spécialisation avec les arguments de modèle livré à l'origine has_member<A>::value. Les deux types correspondent exactement, de sorte que cette partielle de la spécialisation choisie.

D'autre part, lorsque nous définissons le modèle:

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
{ };

Nous nous retrouvons avec la même spécialisation:

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

mais notre modèle de liste d'arguments pour has_member<A>::value est maintenant <A, int>. Les arguments ne correspondent pas aux paramètres de la spécialisation, et le premier modèle est choisi comme un recul.

---

^(*) La Norme, à mon humble avis prêter à confusion, comprend le processus de substitution et la mise en correspondance des spécifié explicitement arguments de modèle dans le argument de modèle déduction processus. Par exemple (post-N4296) [temp.classe.spec.match]/2:

Une spécialisation partielle correspond à un modèle réel de la liste d'arguments
si les arguments de modèle de la spécialisation partielle peut être déduit
à partir du modèle réel de la liste d'arguments.

Mais ce n'est pas juste dire que tous les modèles-les paramètres de la spécialisation partielle doivent être déduites; cela signifie également que la substitution doit réussir, et, comme il semble?) les arguments de modèle correspondent au (substitué) paramètres du modèle de la spécialisation partielle. Notez que je ne suis pas complètement au courant de où la Norme spécifie la comparaison entre les substitué liste d'arguments et de l'argument fourni la liste.