Comment détecter si il y a une variable membre de la classe?

Ici est une solution plus simple que
Johannes Schaub - litb's un. Il nécessite de C++11.

#include <type_traits>

template <typename T, typename = int>
struct HasX : std::false_type { };

template <typename T>
struct HasX <T, decltype((void) T::x, 0)> : std::true_type { };

Mise à jour: Un exemple rapide et l'explication sur la façon dont cela fonctionne.

Pour ces types:

struct A { int x; };
struct B { int y; };

nous avons HasX<A>::value == true et HasX<B>::value == false. Nous allons voir pourquoi.

Rappelons tout d'abord que std::false_type et std::true_type ont un static constexpr bool membre nommé value qui est fixé à false et true, respectivement. Par conséquent, les deux modèles HasX au-dessus de l'héritage de ce membre. (Le premier modèle de std::false_type et la seconde de std::true_type.)

Commençons simple et, ensuite, de procéder étape par étape jusqu'à ce que nous obtenir le code ci-dessus.

1) point de Départ:

template <typename T, typename U>
struct HasX : std::false_type { };

Dans ce cas, il n'y a pas de surprise: HasX dérive de std::false_type et donc HasX<bool, double>::value == false et HasX<bool, int>::value == false.

2) Défaut U:

//Primary template
template <typename T, typename U = int>
struct HasX : std::false_type { };

Étant donné que U par défaut int, Has<bool> signifie en fait HasX<bool, int> et donc, HasX<bool>::value == HasX<bool, int>::value == false.

3) l'Ajout d'une spécialisation:

//Primary template
template <typename T, typename U = int>
struct HasX : std::false_type { };

//Specialization for U = int
template <typename T>
struct HasX<T, int> : std::true_type { };

En général, grâce à la primaire modèle, HasX<T, U> dérive de std::false_type. Cependant, il existe une spécialisation pour les U = int qui dérive de std::true_type. Par conséquent, HasX<bool, double>::value == false mais HasX<bool, int>::value == true.

Grâce à la valeur par défaut pour U, HasX<bool>::value == HasX<bool, int>::value == true.

4) decltype et une façon élégante de dire int:

Une petite parenthèse ici, mais, s'il vous plaît, pardonnez-moi.

De coeur (ce n'est pas tout à fait correct), decltype(expression) donne le type de expression. Par exemple, 0 a type int ainsi, decltype(0) signifie int. De la même façon, 1.2 a type double et donc, decltype(1.2) signifie double.

Considérer une fonction avec cette déclaration:

char func(foo, int);

où foo est un certain type de classe. Si f est un objet de type foo, puis decltype(func(f, 0)) signifie char (le type retourné par func(f, 0)).

Maintenant, l'expression (1.2, 0) utilise le (built-in) opérateur virgule qui évalue les deux sous-expressions dans l'ordre (c'est, d'abord 1.2 et puis 0), les rejets de la première valeur et les résultats de la deuxième. Par conséquent,

int x = (1.2, 0);

est équivalent à

int x = 0;

Mettre cela ensemble avec decltype donne que decltype(1.2, 0) signifie int. Il n'y a rien de vraiment spécial à propos de 1.2 ou double ici. Par exemple, true a type bool et decltype(true, 0) signifie int ainsi.

Que sur un type de classe? Pour instace, ce qui ne decltype(f, 0) veux dire? Il est naturel de s'attendre à ce que cela signifie que int mais il pourrait ne pas être le cas. En effet, il pourrait y avoir une surcharge de l'opérateur virgule similaire à la fonction func ci-dessus qui prend un foo et un int et renvoie un char. Dans ce cas, decltype(foo, 0) est char.

Comment pouvons-nous éviter l'utilisation d'une surcharge de l'opérateur virgule? Eh bien, il n'y a aucun moyen de la surcharge de l'opérateur virgule pour un void opérande et nous pouvons jeter ce à void. Par conséquent, decltype((void) f, 0) signifie int. En effet, (void) f jette f de foo à void qui ne fait rien mais en disant que l'expression doit être considéré comme ayant le type void. Ensuite, l'opérateur virgule est utilisée et ((void) f, 0) résultats dans 0 de type int. Par conséquent, decltype((void) f, 0) signifie int.

Est-ce cast-elle vraiment nécessaire? Eh bien, si il n'y a pas de surcharge de l'opérateur virgule en prenant foo et int puis ce n'est pas nécessaire. Nous pouvons toujours inspecter le code source pour voir si il y a un tel opérateur ou non. Toutefois, si cela apparaît dans un modèle et f a type V qui est un paramètre du modèle, il est alors plus claire (ou même impossible de savoir) si une telle surcharge de l'opérateur virgule existe ou pas. Pour être générique nous jette de toute façon.

Ligne du bas: decltype((void) f, 0) est une façon élégante de dire int.

5) SFINAE:

C'est toute une science 😉 OK je suis exagerating mais ce n'est pas très simple non plus. Donc je vais garder l'explication pour le strict minimum.

SFINAE signifie la Substitution de l'Échec n'est Pas Une Erreur. Cela signifie que lorsqu'un paramètre du modèle est remplacé par un type, illégale d'un code C++ peut apparaître, dans certaines conditions,, au lieu de l'abandon de la compilation, le compilateur ignore simplement le code malveillant comme si il n'était pas là. Nous allons voir comment il s'applique à notre cas:

//Primary template
template <typename T, typename U = int>
struct HasX : std::false_type { };

//Specialization for U = int
template <typename T>
struct HasX <T, decltype((void) T::x, 0)> : std::true_type { };

Ici, de nouveau, decltype((void) T::x, 0) est une façon élégante de dire int mais avec l'avantage de SFINAE.

Quand T est substitué avec un type, une défaillance de construire peut apparaître. Par exemple, bool::x n'est pas valide en C++, donc la substitution T avec bool dans T::x donne un invalide de construire. En vertu de la SFINAE principe, le compilateur ne rejette pas le code, il ignore simplement des (parties de), il. Plus précisément, comme nous l'avons vuHasX<bool> signifie en fait HasX<bool, int>. La spécialisation pour U = int doit être sélectionné, mais, tandis que de son instanciation, le compilateur trouve bool::x et ignore le modèle de la spécialisation tout à fait comme si elle n'existait pas.

À ce point, le code est essentiellement la même que dans le cas (2) ci-dessus où le principal modèle existe. Par conséquent, HasX<bool, int>::value == false.

Le même argument utilisé pour bool détient pour B depuis B::x est une défaillance de construire (B n'a pas de membre x). Cependant, A::x est OK et que le compilateur ne voit pas de problème dans l'instanciation de la spécialisation pour U = int (ou, plus précisément, pour U = decltype((void) A::x, 0)). Par conséquent, HasX<A>::value == true.

6) Unnaming U:

Bien, en regardant le code dans (5) encore une fois, nous voyons que le nom U n'est pas utilisé n'importe où, mais dans sa déclaration (typename U). Nous pouvons alors unname le deuxième argument de modèle et de nous obtenir le code affiché en haut de ce post.

Mise à JOUR: j'ai récemment fait un peu plus avec le code que j'ai posté dans ma réponse, donc je suis à jour de ce compte pour des changements et des ajouts.

Ici sont certains de l'utilisation des extraits de:
*Le courage pour tous ce sont plus bas

Vérifier membre x dans une classe donnée. Pourrait être var, func, de classe, de l'union, ou enum:

CREATE_MEMBER_CHECK(x);
bool has_x = has_member_x<class_to_check_for_x>::value;

Vérifier la fonction de membre de void x():

//Func signature MUST have T as template variable here... simpler this way :\
CREATE_MEMBER_FUNC_SIG_CHECK(x, void (T::*)(), void__x);
bool has_func_sig_void__x = has_member_func_void__x<class_to_check_for_x>::value;

Vérifier la variable de membre x:

CREATE_MEMBER_VAR_CHECK(x);
bool has_var_x = has_member_var_x<class_to_check_for_x>::value;

Vérifier membre de la classe x:

CREATE_MEMBER_CLASS_CHECK(x);
bool has_class_x = has_member_class_x<class_to_check_for_x>::value;

Vérifier membre de l'union x:

CREATE_MEMBER_UNION_CHECK(x);
bool has_union_x = has_member_union_x<class_to_check_for_x>::value;

Vérifier membre enum x:

CREATE_MEMBER_ENUM_CHECK(x);
bool has_enum_x = has_member_enum_x<class_to_check_for_x>::value;

Vérifier pour toute fonction membre x indépendamment de la signature:

CREATE_MEMBER_CHECK(x);
CREATE_MEMBER_VAR_CHECK(x);
CREATE_MEMBER_CLASS_CHECK(x);
CREATE_MEMBER_UNION_CHECK(x);
CREATE_MEMBER_ENUM_CHECK(x);
CREATE_MEMBER_FUNC_CHECK(x);
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

OU

CREATE_MEMBER_CHECKS(x);  //Just stamps out the same macro calls as above.
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

De détails et de base:

/*
    - Multiple inheritance forces ambiguity of member names.
    - SFINAE is used to make aliases to member names.
    - Expression SFINAE is used in just one generic has_member that can accept
      any alias we pass it.
*/

template <typename... Args> struct ambiguate : public Args... {};

template<typename A, typename = void>
struct got_type : std::false_type {};

template<typename A>
struct got_type<A> : std::true_type {
    typedef A type;
};

template<typename T, T>
struct sig_check : std::true_type {};

template<typename Alias, typename AmbiguitySeed>
struct has_member {
    template<typename C> static char ((&f(decltype(&C::value))))[1];
    template<typename C> static char ((&f(...)))[2];

    //Make sure the member name is consistently spelled the same.
    static_assert(
        (sizeof(f<AmbiguitySeed>(0)) == 1)
        , "Member name specified in AmbiguitySeed is different from member name specified in Alias, or wrong Alias/AmbiguitySeed has been specified."
    );

    static bool const value = sizeof(f<Alias>(0)) == 2;
};

Macros (El Diablo!):

CREATE_MEMBER_CHECK:

//Check for any member with given name, whether var, func, class, union, enum.
#define CREATE_MEMBER_CHECK(member)                                         \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct Alias_##member;                                                      \
                                                                            \
template<typename T>                                                        \
struct Alias_##member <                                                     \
    T, std::integral_constant<bool, got_type<decltype(&T::member)>::value>  \
> { static const decltype(&T::member) value; };                             \
                                                                            \
struct AmbiguitySeed_##member { char member; };                             \
                                                                            \
template<typename T>                                                        \
struct has_member_##member {                                                \
    static const bool value                                                 \
        = has_member<                                                       \
            Alias_##member<ambiguate<T, AmbiguitySeed_##member>>            \
            , Alias_##member<AmbiguitySeed_##member>                        \
        >::value                                                            \
    ;                                                                       \
}

CREATE_MEMBER_VAR_CHECK:

//Check for member variable with given name.
#define CREATE_MEMBER_VAR_CHECK(var_name)                                   \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_var_##var_name : std::false_type {};                      \
                                                                            \
template<typename T>                                                        \
struct has_member_var_##var_name<                                           \
    T                                                                       \
    , std::integral_constant<                                               \
        bool                                                                \
        , !std::is_member_function_pointer<decltype(&T::var_name)>::value   \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_SIG_CHECK:

//Check for member function with given name AND signature.
#define CREATE_MEMBER_FUNC_SIG_CHECK(func_name, func_sig, templ_postfix)    \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_func_##templ_postfix : std::false_type {};                \
                                                                            \
template<typename T>                                                        \
struct has_member_func_##templ_postfix<                                     \
    T, std::integral_constant<                                              \
        bool                                                                \
        , sig_check<func_sig, &T::func_name>::value                         \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_CLASS_CHECK:

//Check for member class with given name.
#define CREATE_MEMBER_CLASS_CHECK(class_name)               \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_class_##class_name : std::false_type {};  \
                                                            \
template<typename T>                                        \
struct has_member_class_##class_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_class<                                    \
            typename got_type<typename T::class_name>::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_UNION_CHECK:

//Check for member union with given name.
#define CREATE_MEMBER_UNION_CHECK(union_name)               \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_union_##union_name : std::false_type {};  \
                                                            \
template<typename T>                                        \
struct has_member_union_##union_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_union<                                    \
            typename got_type<typename T::union_name>::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_ENUM_CHECK:

//Check for member enum with given name.
#define CREATE_MEMBER_ENUM_CHECK(enum_name)                 \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_enum_##enum_name : std::false_type {};    \
                                                            \
template<typename T>                                        \
struct has_member_enum_##enum_name<                         \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_enum<                                     \
            typename got_type<typename T::enum_name>::type  \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_CHECK:

//Check for function with given name, any signature.
#define CREATE_MEMBER_FUNC_CHECK(func)          \
template<typename T>                            \
struct has_member_func_##func {                 \
    static const bool value                     \
        = has_member_##func<T>::value           \
        && !has_member_var_##func<T>::value     \
        && !has_member_class_##func<T>::value   \
        && !has_member_union_##func<T>::value   \
        && !has_member_enum_##func<T>::value    \
    ;                                           \
}

CREATE_MEMBER_CHECKS:

//Create all the checks for one member.  Does NOT include func sig checks.
#define CREATE_MEMBER_CHECKS(member)    \
CREATE_MEMBER_CHECK(member);            \
CREATE_MEMBER_VAR_CHECK(member);        \
CREATE_MEMBER_CLASS_CHECK(member);      \
CREATE_MEMBER_UNION_CHECK(member);      \
CREATE_MEMBER_ENUM_CHECK(member);       \
CREATE_MEMBER_FUNC_CHECK(member)

Pourquoi n'utilisez-vous pas la spécialisation comme ceci:

struct P1 {int x; };
struct P2 {int X; };

template<class P> 
bool Check_x(P p) { return true; }

template<> 
bool Check_x<P2>(P2 p) { return false; }

Pourquoi ne pas simplement créer des spécialisations de modèle de Check_x ?

template<> bool Check_x(P1 p) { return true; }
template<> bool Check_x(P2 p) { return false; }

Diable, quand je pense à elle. Si vous ne disposez que de deux types, pourquoi avez-vous encore besoin de modèles pour cela?

Nous pouvons obtenir au moment de la compilation: 0 - not_member, 1 - is_object, 2 - is_function de chaque membre et de classe - objet ou de la fonction: http://ideone.com/Fjm9u5

#include <iostream>
#include <type_traits>
#define IS_MEMBER(T1, M)    \
struct {        \
struct verystrangename1 { bool M; };    \
template<typename T> struct verystrangename2 : verystrangename1, public T { }; \
\
enum return_t { not_member, is_object, is_function }; \
template<typename T, typename = decltype(verystrangename2<T>::M)> constexpr return_t what_member() { return not_member;  }  \
template<typename T> typename std::enable_if<std::is_member_object_pointer<decltype(&T::M)>::value, return_t>::type constexpr what_member() { return is_object; }   \
template<typename T> typename std::enable_if<std::is_member_function_pointer<decltype(&T::M)>::value, return_t>::type constexpr what_member() { return is_function; }   \
constexpr operator return_t() { return what_member<T1>(); } \
}
struct t {
int aaa;
float bbb;
void func() {}
};
//Can't be in function
IS_MEMBER(t, aaa) is_aaa_member_of_t;
IS_MEMBER(t, ccc) is_ccc_member_of_t;
IS_MEMBER(t, func) is_func_member_of_t;
//known at compile time
enum { const_is_aaa_member_of_t = (int)is_aaa_member_of_t };
static constexpr int const_is_func_member_of_t = is_func_member_of_t;
int main() {        
std::cout << std::boolalpha << "0 - not_member, 1 - is_object, 2 - is_function \n\n" <<
"is aaa member of t = " << is_aaa_member_of_t << std::endl << 
"is ccc member of t = " << is_ccc_member_of_t << std::endl << 
"is func member of t = " << is_func_member_of_t << std::endl << 
std::endl;
return 0;
}

Résultat:

0 - not_member, 1 - is_object, 2 - is_function 
is aaa member of t = 1
is ccc member of t = 0
is func member of t = 2

Pour class/struct:

struct t {
int aaa;
float bbb;
void func() {}
};