SFINAE pour vérifier hérité des fonctions de membre du

À l'aide de SFINAE, je peut détecter si une classe donnée a une certaine fonction de membre. Mais que faire si je veux tester hérité des fonctions de membre?

Le code suivant ne fonctionne pas dans VC8 et GCC4 (c'est à dire détecte que A a une fonction membre foo(), mais pas que B hérite de la):

#include <iostream>

template<typename T, typename Sig>                                 
struct has_foo {                     
    template <typename U, U> struct type_check;
    template <typename V> static char (& chk(type_check<Sig, &V::foo>*))[1];
    template <typename  > static char (& chk(...))[2]; 
    static bool const value = (sizeof(chk<T>(0)) == 1);
};

struct A {
    void foo();
};

struct B : A {};

int main()
{
    using namespace std;
    cout << boolalpha << has_foo<A, void (A::*)()>::value << endl; //true
    cout << boolalpha << has_foo<B, void (B::*)()>::value << endl; //false
}

Alors, est-il un moyen de tester hérité des fonctions de membre?

Je ne pense pas que ce soit possible en général. Jusqu'à présent, de toutes façons je l'ai vu avoir certains cas où ils ne parviennent pas.

InformationsquelleAutor Georg Fritzsche | 2009-12-27

c++metaprogramming sfinae templates

28

Prendre un coup d'oeil à ce fil:

http://lists.boost.org/boost-users/2009/01/44538.php

Dérivé du code lié à cette discussion:
```
#include <iostream>

template <typename Type> 
class has_foo
{ 
   class yes { char m;}; 
   class no { yes m[2];}; 
   struct BaseMixin 
   { 
     void foo(){} 
   }; 
   struct Base : public Type, public BaseMixin {}; 
   template <typename T, T t>  class Helper{}; 
   template <typename U> 
   static no deduce(U*, Helper<void (BaseMixin::*)(), &U::foo>* = 0); 
   static yes deduce(...); 
public: 
   static const bool result = sizeof(yes) == sizeof(deduce((Base*)(0))); 
}; 

struct A {
    void foo();
};

struct B : A {};

struct C {};

int main()
{
    using namespace std;
    cout << boolalpha << has_foo<A>::result << endl;
    cout << boolalpha << has_foo<B>::result << endl;
    cout << boolalpha << has_foo<C>::result;
}
```
Résultat:
```
true
true
false
```
- C'est celui-ci: stackoverflow.com/questions/1005476/... et expliqué ici: cplusplus.co.il/2009/09/11/... . Gardez à l'esprit qu'il sera le signal qu'il y a un membre de ce nom même si le membre n'est pas une fonction ou la fonction a une autre signature, donc c'est quelque chose de différent. Il a besoin de l'autre les codes indiqués dans la discussion usenet, de faire des vérifications plus poussées.
- N'ai pas noté le manque de contrôle de type, un bon point. Tu veux sans doute dire à l'aide de is_call_possible<> à partir d'ici, groups.google.com/group/comp.lang.c++.modéré/msg/... ? Semble intéressant, aura pour tester plus tard.
- Ce code ne peut pas compiler avec struct Cpp11 final : A {}; parce qu'il essaie d'hériter d'une classe finale. Aucune solution de contournement?
- voir mon post ci-dessous comme une solution possible
InformationsquelleAutor joshperry
23

joshperry la réponse est très intelligent et élégant, mais (comme il est indiqué ci-dessous le post) qu'il n'a pas vérifier la signature de foo() correctement et ne fonctionne pas avec les fondamentaux de types (type int): il provoque une erreur de compilation.
Je vous propose une technique qui gère les membres hérités correctement et vérifie la signature de la fonction membre. Au lieu de rentrer dans les détails, je vais vous donner deux exampes et de l'espoir que le code parle de lui-même.

Exemple1:

Nous sommes à la recherche d'une membre avec la signature suivante:
T::const_iterator begin() const
```
template<class T> struct has_const_begin
{
    typedef char (&Yes)[1];
    typedef char (&No)[2];

    template<class U> 
    static Yes test(U const * data, 
                    typename std::enable_if<std::is_same<
                             typename U::const_iterator, 
                             decltype(data->begin())
                    >::value>::type * = 0);
    static No test(...);
    static const bool value = sizeof(Yes) == sizeof(has_const_begin::test((typename std::remove_reference<T>::type*)0));
};
```
Veuillez noter qu'il vérifie bien que la constness de la méthode, et fonctionne avec les types primitifs, ainsi. (Je veux dire has_const_begin<int>::value est faux et ne pas provoquer une erreur de compilation.)

Exemple 2

Maintenant, nous sommes à la recherche de la signature: void foo(MyClass&, unsigned)
```
template<class T> struct has_foo
{
    typedef char (&Yes)[1];
    typedef char (&No)[2];

    template<class U>
    static Yes test(U * data, MyClass* arg1 = 0,
                    typename std::enable_if<std::is_void<
                             decltype(data->foo(*arg1, 1u))
                    >::value>::type * = 0);
    static No test(...);
    static const bool value = sizeof(Yes) == sizeof(has_foo::test((typename std::remove_reference<T>::type*)0));
};
```
Veuillez noter que MyClass n'a pas a être par défaut constructible ou pour satisfaire n'importe quel concept particulier. La technique fonctionne avec le modèle de membres.

Je suis avec impatience d'attente des opinions à ce sujet.
- +1 j'étais à la recherche d'une solution pour un problème de mine, et c'est exactement ce dont j'avais besoin 🙂
- Je ne peux pas pour la vie de me dire si cette classe (ou quelque chose d'équivalent) est actuellement en Boost... le savez-vous?
- Non, je ne le pense pas.
- Bien que cela semble être le meilleur moyen, je n'arrive pas à le transformer en une macro. Quand vous faites des tests pour de nombreuses fonctions, une macro est un must-have et dans ce cas particulier, il est impossible. J'aimerais avoir tort tho.
- Je suis également curieux de savoir si cela peut être en quelque sorte évalué dans une macro. Quelque chose dans la forme de CREATE_HAS_METHOD(Type, ReturnType, (Arg1Type, Arg2Type, Arg3Type) const)
- Je ne pense pas que cette méthode fait la distinction entre héréditaire et non les méthodes héritées bien. il sera de retour true dans les deux cas, parce que data->foo(*arg1, 1u) est une expression valide dans les deux cas
InformationsquelleAutor kispaljr

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;

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.
*/

//Variadic to force ambiguity of class members.  C++11 and up.
template <typename... Args> struct ambiguate : public Args... {};

//Non-variadic version of the line above.
//template <typename A, typename B> struct ambiguate : public A, public B {};

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)

savez-vous si il est possible de faire un trait à vérifier la fonction de l'existence ? et pas un membre ? parce que chaque fois que j'essaie j'ai "invalide paramètre de modèle" ou "checked_func n'a pas été déclarée dans ce cadre". absolument comme si SFINAE était une erreur soudainement.
Je suppose que pas parce qu'une fonction libre n'est pas une classe ou structure. Cette technique de déduire la présence d'un membre est vraiment au centre sur le mécanisme d'héritage multiple en C++ forcer l'ambiguïté entre un stub de classe qui n'existe que dans le but d'accueillir le membre que vous vérifiez pour vs la classe que vous soyez à vérifier effectivement pour le membre. C'est une question intéressante mais, n'y avais pas pensé. Vous pouvez vérifier autour pour les autres C++11/14 états-vérifiez techniques, j'ai vu des choses intelligentes à la nouvelle norme. 🙂

InformationsquelleAutor Brett Rossier

Que toutes les réponses ont l'air trop compliqué pour moi, j'aimerais vous présenter ma propre solution à l'aide de `std::declval` et `std::enable_if` (GCC 4.8.3)

#define MEMBER_FUNC_CHECKER(name, fn, ret, args) \
template<class C, typename=void> struct name : std::false_type {}; \
template<class C> struct name<C, typename std::enable_if< \
  std::is_convertible<decltype(std::declval<C>().fn args), ret \
  >::value>::type> : std::true_type {};

REMARQUE: Il n'est pas exact de vérifier pour la signature, mais pour la fonction appelable avec convertible type de retour. (edit: modifié à partir de is_same à is_convertible)

Test

struct One {
int get() { return 0; }
int add(int x, int y) { return x+y; }
};
struct Two: One {};
struct Not {};
MEMBER_FUNC_CHECKER(has_get, get, int, ())
MEMBER_FUNC_CHECKER(has_add, add, int, (1,2))
int main() {
cout << "One " << (has_get<One>() ? "has" : "does not have")
<< " int get()" << endl;
cout << "Two " << (has_get<Two>() ? "has" : "does not have")
<< " int get()" << endl;
cout << "Not " << (has_get<Not>() ? "has" : "does not have")
<< " int get()" << endl;
cout << "One " << (has_add<One>() ? "has" : "does not have")
<< " int add(int, int)" << endl;
cout << "Two " << (has_add<Two>() ? "has" : "does not have")
<< " int add(int, int)" << endl;
cout << "Not " << (has_add<Not>() ? "has" : "does not have")
<< " int add(int, int)" << endl;
cout << "int " << (has_get<int>() ? "has" : "does not have")
<< " int get()" << endl;
}

Sortie

Un int get() 
Deux int get() 
Pas n'a pas int get() 
On a int add(int, int) 
Deux int add(int, int) 
Pas n'a pas int add(int, int) 
int n'a pas int get()

Mise à JOUR: Mon pions

///Checker for typedef with given name and convertible type
#define TYPEDEF_CHECKER(checker, name) \
template<class C, typename T, typename = void> struct checker : std::false_type {}; \
template<class C, typename T> struct checker<C, T, typename std::enable_if< \
std::is_convertible<typename C::name, T>::value>::type> : std::true_type {}
///Checker for typedef with given name and exact type
#define TYPEDEF_CHECKER_STRICT(checker, name) \
template<class C, typename T, typename = void> struct checker : std::false_type {}; \
template<class C, typename T> struct checker<C, T, typename std::enable_if< \
std::is_same<typename C::name, T>::value>::type> : std::true_type {}
///Checker for typedef with given name and any type
#define TYPEDEF_CHECKER_ANY(checker, name) \
template<class C, typename = void> struct checker : std::false_type {}; \
template<class C> struct checker<C, typename std::enable_if< \
!std::is_same<typename C::name*, void>::value>::type> : std::true_type {}
///Checker for member with given name and convertible type
#define MTYPE_CHECKER(checker, name) \
template<class C, typename T, typename = void> struct checker : std::false_type {}; \
template<class C, typename T> struct checker<C, T, typename std::enable_if< \
std::is_convertible<decltype(C::name), T>::value>::type> : std::true_type {}
///Checker for member with given name and exact type
#define MTYPE_CHECKER_STRICT(checker, name) \
template<class C, typename T, typename = void> struct checker : std::false_type {}; \
template<class C, typename T> struct checker<C, T, typename std::enable_if< \
std::is_same<decltype(C::name), T>::value>::type> : std::true_type {}
///Checker for member with given name and any type
#define MTYPE_CHECKER_ANY(checker, name) \
template<class C, typename = void> struct checker : std::false_type {}; \
template<class C> struct checker<C, typename std::enable_if< \
!std::is_same<decltype(C::name)*, void>::value>::type> : std::true_type {}
///Checker for static const variable with given name and value
#define MVALUE_CHECKER(checker, name, val) \
template<class C, typename = void> struct checker : std::false_type {}; \
template<class C> struct checker<C, typename std::enable_if< \
std::is_convertible<decltype(C::name), const decltype(val)>::value && C::name == val>::type> : std::true_type {}
///Checker for static const variable with given name, value and type
#define MVALUE_CHECKER_STRICT(checker, name, val) \
template<class C, typename = void> struct checker : std::false_type {}; \
template<class C> struct checker<C, typename std::enable_if< \
std::is_same<decltype(C::name), const decltype(val)>::value && C::name == val>::type> : std::true_type {}
///Checker for member function with convertible return type and accepting given arguments
#define METHOD_CHECKER(checker, name, ret, args) \
template<class C, typename=void> struct checker : std::false_type {}; \
template<class C> struct checker<C, typename std::enable_if< \
std::is_convertible<decltype(std::declval<C>().name args), ret>::value>::type> : std::true_type {};
///Checker for member function with exact retutn type and accepting given arguments
#define METHOD_CHECKER_STRICT_RET(name, fn, ret, args) \
template<class C, typename=void> struct name : std::false_type {}; \
template<class C> struct name<C, typename std::enable_if< \
std::is_same<decltype(std::declval<C>().fn args), ret>::value>::type> : std::true_type {};
///Checker for member function accepting given arguments
#define METHOD_CHECKER_ANY(name, fn, args) \
template<class C, typename=void> struct name : std::false_type {}; \
template<class C> struct name<C, typename std::enable_if< \
!std::is_same<decltype(std::declval<C>().fn args)*, void>::value>::type> : std::true_type {};

Code De Test

struct One {
typedef int type;
static constexpr bool v = true;
type x;
One(type x = 0): x(x) {}
~One() {}
type get() { return x; }
type add(type x, type y) { return x+y; }
};
struct Two: One {};
struct Not {};
TYPEDEF_CHECKER(has_type, type);
TYPEDEF_CHECKER_ANY(any_type, type);
TYPEDEF_CHECKER_STRICT(exact_type, type);
MTYPE_CHECKER(has_x, x);
MTYPE_CHECKER_ANY(any_x, x);
MTYPE_CHECKER_STRICT(exact_x, x);
MVALUE_CHECKER(true_v, v, true);
MVALUE_CHECKER(true_z, z, true);
MVALUE_CHECKER(false_v, v, false);
MVALUE_CHECKER(one_v, v, 1);
MVALUE_CHECKER_STRICT(exact_v, v, 1);
METHOD_CHECKER(has_get, get, long, ());
METHOD_CHECKER(has_add, add, long, (1,2))
METHOD_CHECKER_ANY(any_get, get, ());
METHOD_CHECKER_STRICT_RET(int_get, get, int, ())
METHOD_CHECKER_STRICT_RET(long_get, get, long, ())
int main() {
#define CHECK(name, desc, ...) cout << endl; \
cout << "One " << (name<One, ##__VA_ARGS__>() ? "has " : "does not have ") << desc << endl; \
cout << "Two " << (name<Two, ##__VA_ARGS__>() ? "has " : "does not have ") << desc << endl; \
cout << "Not " << (name<Not, ##__VA_ARGS__>() ? "has " : "does not have ") << desc << endl; \
cout << "int " << (name<int, ##__VA_ARGS__>() ? "has " : "does not have ") << desc << endl
string sep = string(60, '-');
cout << sep;
CHECK(any_type, "typedef type");
CHECK(has_type, "typedef type convertible to long", long);
CHECK(exact_type, "typedef type = int", int);
CHECK(exact_type, "typedef type = long", long);
cout << sep;
CHECK(any_x, "var x");
CHECK(has_x, "var x of type convertible to long", long);
CHECK(exact_x, "var x of type int", int);
CHECK(exact_x, "var x of type long", long);
cout << sep;
CHECK(true_v, "var v with value equal to true");
CHECK(true_z, "var z with value equal to true");
CHECK(false_v, "var v with value equal to false");
CHECK(one_v, "var v with value equal to 1");
CHECK(exact_v, "var v with value equal to 1 of type int");
cout << sep;
CHECK(has_get, "get()");
CHECK(has_get, "get() with return type covertible to long");
CHECK(has_add, "add() accepting two ints and returning ~ long");
CHECK(int_get, "int get()");
CHECK(long_get, "long get()");
}

Sortie

On a typedef type 
Deux a typedef type 
Pas n'a pas de définition de type de type 
int n'a pas de définition de type de type 
On a typedef type cabriolet à long 
Deux a typedef type cabriolet à long 
Pas n'a pas de définition de type de type cabriolet à long 
int n'a pas de définition de type de type cabriolet à long 
On a typedef type = int 
Deux a typedef type = int 
Pas n'a pas de typedef type = int 
int n'a pas de typedef type = int 
On n'a pas de typedef type = long 
Deux n'ont pas de typedef type = long 
Pas n'a pas de typedef type = long 
int n'a pas de typedef type = long 
------------------------------------------------------------ 
On a var x 
Deux a var x 
Pas n'a pas var x 
int n'a pas var x 
On a var x de type cabriolet à long 
Deux a var x de type cabriolet à long 
Pas n'a pas var x de type cabriolet à long 
int n'a pas var x de type cabriolet à long 
On a var x de type int 
Deux a var x de type int 
Pas n'a pas var x de type int 
int n'a pas var x de type int 
On n'a pas var x de type long 
Deux n'ont pas de var x de type long 
Pas n'a pas var x de type long 
int n'a pas var x de type long 
------------------------------------------------------------ 
On a var v avec une valeur égale à true 
Deux a var v avec une valeur égale à true 
Pas n'a pas var v avec une valeur égale à true 
int n'a pas var v avec une valeur égale à true 
On n'a pas var z avec une valeur égale à true 
Deux n'ont pas de var z avec une valeur égale à true 
Pas n'a pas var z avec une valeur égale à true 
int n'a pas var z avec une valeur égale à true 
On n'a pas var v dont la valeur est égale à false 
Deux n'ont pas de var v dont la valeur est égale à false 
Pas n'a pas var v dont la valeur est égale à false 
int n'a pas var v dont la valeur est égale à false 
On a var v avec une valeur égale à 1 
Deux a var v avec une valeur égale à 1 
Pas n'a pas var v avec une valeur égale à 1 
int n'a pas var v avec une valeur égale à 1 
On n'a pas var v avec une valeur égale à 1 de type int 
Deux n'ont pas de var v avec une valeur égale à 1 de type int 
Pas n'a pas var v avec une valeur égale à 1 de type int 
int n'a pas var v avec une valeur égale à 1 de type int 
------------------------------------------------------------ 
On a get() 
Deux a get() 
Pas n'a pas de get() 
int n'a pas de get() 
On a get() avec un type de retour covertible à long 
Deux a get() avec un type de retour covertible à long 
Pas n'a pas de get() avec un type de retour covertible à long 
int n'a pas de get() avec un type de retour covertible à long 
A ajouter() acceptant deux ints et le retour ~ long 
Deux a ajouter() acceptant deux ints et le retour ~ long 
Pas de ne pas avoir ajouter() acceptant deux ints et le retour ~ long 
int ne pas avoir ajouter() acceptant deux ints et le retour ~ long 
On a int get() 
Deux int get() 
Pas n'a pas int get() 
int n'a pas int get() 
On n'a pas de longues get() 
Deux n'a pas de longues get() 
Pas ne pas avoir de longues get() 
int n'a pas de longues get()

InformationsquelleAutor firda

Vous devez vous connecter pour publier un commentaire.

Exemple1:

Exemple 2

Que toutes les réponses ont l'air trop compliqué pour moi, j'aimerais vous présenter ma propre solution à l'aide de std::declval et std::enable_if (GCC 4.8.3)

Test

Sortie

Mise à JOUR: Mon pions

Code De Test

Sortie

Que toutes les réponses ont l'air trop compliqué pour moi, j'aimerais vous présenter ma propre solution à l'aide de `std::declval` et `std::enable_if` (GCC 4.8.3)