à l'aide de SFINAE pour la classe template de la spécialisation

Puisque vous avez dit que vous étiez toujours en attente d'une meilleure réponse, voici mon prendre sur elle. Il n'est pas parfait, mais je pense qu'il vous permet de vous autant que possible à l'aide de SFINAE et partielle de spécialisations. (Je suppose que les Concepts fournira un ensemble complet et solution élégante, mais nous allons devoir attendre un peu plus longtemps pour que.)

La solution repose sur une fonctionnalité d'alias modèles qui a été spécifié que récemment, dans la norme des documents de travail après la dernière version de C++14, mais a été pris en charge par des implémentations pour un certain temps. Pertinentes libellé dans le projet de N4527 [14.5.7p3] est:

Toutefois, si le modèle-id est dépendante, à la suite argument de modèle de substitution s'applique toujours au modèle-id. [ Exemple:

template<typename...> using void_t = void;
template<typename T> void_t<typename T::foo> f();
f<int>(); //error, int does not have a nested type foo

la fin de l'exemple ]

Voici un exemple complet de mise en œuvre de cette idée:

#include <iostream>
#include <type_traits>
#include <utility>
template<typename> struct User { static void f() { std::cout << "primary\n"; } };
template<typename> struct Data { };
template<typename T, typename U> struct Derived1 : Data<T*> { };
template<typename> struct Derived2 : Data<double> { };
struct DD : Data<int> { };
template<typename T> void take_data(Data<T>&&);
template<typename T, typename = decltype(take_data(std::declval<T>()))> 
using enable_if_data = T;
template<template<typename...> class TT, typename... Ts> 
struct User<enable_if_data<TT<Ts...>>> 
{ 
static void f() { std::cout << "partial specialization for Data\n"; } 
};
template<typename> struct Other { };
template<typename T> struct User<Other<T>> 
{ 
static void f() { std::cout << "partial specialization for Other\n"; } 
};
int main()
{
User<int>::f();
User<Data<int>>::f();
User<Derived1<int, long>>::f();
User<Derived2<char>>::f();
User<DD>::f();
User<Other<int>>::f();
}

L'exécution de l'impression:

primary
partial specialization for Data
partial specialization for Data
partial specialization for Data
primary
partial specialization for Other

Comme vous pouvez le voir, il y a une ride: la spécialisation partielle n'est pas sélectionné pour DD, et il ne peut pas être, parce que de la façon dont nous l'a déclaré. Alors, pourquoi ne pas simplement dire

template<typename T> struct User<enable_if_data<T>> 

et lui permettre de match DD ainsi? Cela fonctionne dans GCC, mais il est rejeté à juste titre par Clang et MSVC à cause de [14.5.5p8.3, 8.4] ([p8.3] peuvent disparaître dans le futur, comme c'est redondant - GTC 2033):

• La liste des arguments de la spécialisation ne doit pas être identique à
  l'implicite de la liste d'arguments de la primaire modèle.
• La spécialisation est plus spécialisé que le principal modèle (14.5.5.2).

User<enable_if_data<T>> est équivalent à User<T> (modulo la substitution dans cet argument par défaut, qui est géré séparément, comme l'a expliqué la première citation ci-dessus), ainsi qu'un formulaire non valide partielle de la spécialisation. Malheureusement, correspondant à des choses comme DD nécessiterait, en général, une spécialisation partielle argument de la forme T - il n'y a pas d'autre forme qu'il peut avoir et toujours correspondre à chaque cas. Donc, je crains que nous pouvons dire avec certitude que cette pièce ne peut pas être résolu au sein de la compte tenu de ses contraintes. (Il y a Question centrale 1980, qui fait allusion à un possible avenir règles concernant l'utilisation du modèle des alias, mais je doute qu'ils vont faire de notre cas valable.)

Tant que les classes dérivées de Data<T> sont eux-mêmes spécialisations de modèle, plus contraignant eux en utilisant la technique ci-dessus fonctionne, donc j'espère que ce sera de quelque utilité pour vous.

Prise en charge du compilateur (c'est ce que j'ai testé, d'autres versions peuvent travailler en tant que bien):

• Clang 3.3 - 3.6.0, avec -Wall -Wextra -std=c++11 -pedantic - fonctionne comme décrit ci-dessus.
• GCC 4.7.3 - 4.9.2 les mêmes options - mêmes que ci-dessus. Curieusement, GCC 5.1.0 - 5.2.0 ne sélectionne plus les partiels de spécialisation à l'aide de la version correcte du code. Cela ressemble à une régression. Je n'ai pas le temps de mettre ensemble un bon rapport de bug, n'hésitez pas à le faire si vous le souhaitez. Le problème semble être lié à l'utilisation du paramètre de packs avec un modèle de paramètre du modèle. De toute façon, GCC accepte la version incorrecte à l'aide de enable_if_data<T>, de sorte que peut être une solution temporaire.
• MSVC: Visual C++ 2015, avec /W4, fonctionne comme décrit ci-dessus. Les anciennes versions n'aime pas le decltype dans l'argument par défaut, mais la technique elle-même fonctionne encore - de remplacer l'argument par défaut avec une autre façon d'exprimer la contrainte permet de travailler sur 2013 mise à Jour 4.

Que vous ne voulez à mettre en œuvre lorsqu'une seule condition est vraie, la solution la plus simple est d'utiliser un statique affirmation. Il ne nécessite pas de SFINAE, donne clairement une erreur de compilation si mal utilisés et la déclaration de User<> n'a pas besoin d'être adaptées:

template<typename T> class User {
static_assert(is_Data<T>::value, "T is not (a subclass of) Data<>");
/** Implementation. **/
};

Voir aussi: Lors de l'utilisation de static_assert au lieu de SFINAE?. Le static_assert est un c++11 construire, cependant, il existe de nombreuses solutions disponibles en pré-c++11 compilateurs, comme:

#define STATIC_ASSERT(consdition,name) \
typedef char[(condition)?1:-1] STATIC_ASSERT_ ## name

Si la déclaration de user<> peut être changé et que vous souhaitez deux implémentations en fonction de la valeur de is_Data, puis il y a aussi une solution qui n'utilise pas SFINAE:

template<typename T, bool D=is_Data<T>::value> class User;
template<typename T> class User<T, true> {
static_assert(is_Data<T>::value, "T is not (a subclass of) Data<>"); //Optional
/* Data implementation */
};
template<typename T> class User<T, false> {
static_assert(!is_Data<T>::value, "T is (a subclass of) Data<>"); //Optional
/* Non-data implementation */
};

La statique des assertions vérifie uniquement si l'utilisateur n'a pas de spécifiez le modèle argument D de manière incorrecte. Si D n'est pas explicitement spécifié, alors la statique des assertions peuvent être omis.