Est-il possible d'écrire un modèle pour vérifier la fonction de l'existence?

Oui, avec SFINAE vous pouvez vérifier si une classe donnée ne fournir une certaine méthode. Voici le code de travail:

#include <iostream>

struct Hello
{
    int helloworld() { return 0; }
};

struct Generic {};    

//SFINAE test
template <typename T>
class has_helloworld
{
    typedef char one;
    struct two { char x[2]; };

    template <typename C> static one test( typeof(&C::helloworld) ) ;
    template <typename C> static two test(...);    

public:
    enum { value = sizeof(test<T>(0)) == sizeof(char) };
};

int main(int argc, char *argv[])
{
    std::cout << has_helloworld<Hello>::value << std::endl;
    std::cout << has_helloworld<Generic>::value << std::endl;
    return 0;
}

J'ai juste testé avec Linux et gcc 4.1/4.3. Je ne sais pas si c'est portable sur les autres plates-formes d'exécution des compilateurs différents.

OriginalL'auteur Nicola Bonelli

C++ permet SFINAE être utilisé pour cette (remarquez qu'avec C++11 caractéristiques c'est plus simple, car il prend en charge étendue SFINAE sur presque arbitraire expressions - le ci-dessous a été conçu pour fonctionner avec le C++03 compilateurs):

#define HAS_MEM_FUNC(func, name)                                        \
    template<typename T, typename Sign>                                 \
    struct name {                                                       \
        typedef char yes[1];                                            \
        typedef char no [2];                                            \
        template <typename U, U> struct type_check;                     \
        template <typename _1> static yes &chk(type_check<Sign, &_1::func > *); \
        template <typename   > static no  &chk(...);                    \
        static bool const value = sizeof(chk<T>(0)) == sizeof(yes);     \
    }

le modèle ci-dessus et macro tente d'instancier un modèle, en lui donnant une fonction de membre de type pointeur, et le véritable membre de pointeur de fonction. Si les types de pas, SFINAE cause le modèle pour être ignoré. Utilisation comme ceci:

HAS_MEM_FUNC(toString, has_to_string);

template<typename T> void
doSomething() {
   if(has_to_string<T, std::string(T::*)()>::value) {
      ...
   } else {
      ...
   }
}

Mais notez que vous ne peut pas simplement appeler que toString fonction que si la branche. depuis le compilateur de vérifier la validité dans les deux branches, qui serait un échec pour les cas, la fonction n'existent pas. Une façon est d'utiliser SFINAE une fois de plus (enable_if peut être obtenu à partir de boost trop):

template<bool C, typename T = void>
struct enable_if {
  typedef T type;
};

template<typename T>
struct enable_if<false, T> { };

HAS_MEM_FUNC(toString, has_to_string);

template<typename T> 
typename enable_if<has_to_string<T, 
                   std::string(T::*)()>::value, std::string>::type
doSomething(T * t) {
   /* something when T has toString ... */
   return t->toString();
}

template<typename T> 
typename enable_if<!has_to_string<T, 
                   std::string(T::*)()>::value, std::string>::type
doSomething(T * t) {
   /* something when T doesnt have toString ... */
   return "T::toString() does not exist.";
}

Avoir du plaisir à l'utiliser. L'avantage de cela est qu'il fonctionne aussi pour la surcharge de fonctions membres, et aussi pour les fonctions membres const (rappelez-vous à l'aide de std::string(T::*)() const que la fonction de membre de type pointeur à l'époque!).

OriginalL'auteur Johannes Schaub - litb

C++20 - requires expressions

Avec C++20 venir des concepts et des outils tels que demande expressions qui sont un moyen intégré pour vérifier la fonction de l'existence. Avec tehm vous pouvez réécrire votre optionalToString fonction comme suit:

template<class T>
std::string optionalToString(T* obj)
{
    constexpr bool has_toString = requires(const T& t) {
        t.toString();
    };

    if constexpr (has_toString)
        return obj->toString();
    else
        return "toString not defined";
}

Pré-C++20 - Détection toolkit

N4502 propose une détection de boîte à outils pour l'inclusion dans le C++17 de la bibliothèque standard qui peut résoudre le problème en quelque sorte dans une élégante manière. En outre, il vient d'être accepté dans la bibliothèque fondamentaux TS v2. Elle introduit certains metafunctions, y compris std::is_detected qui peut être utilisée facilement pour écrire le type ou la fonction de détection de metafunctions sur le dessus de cela. Voici comment vous pourriez l'utiliser:

template<typename T>
using toString_t = decltype( std::declval<T&>().toString() );

template<typename T>
constexpr bool has_toString = std::is_detected_v<toString_t, T>;

Noter que l'exemple ci-dessus n'est pas testée. La détection de la trousse à outils n'est pas disponible dans les bibliothèques standard, mais encore la proposition contient une mise en œuvre complète qui vous permet de copier facilement si vous en avez vraiment besoin. Il joue bien avec le C++17 fonctionnalité if constexpr:

template<class T>
std::string optionalToString(T* obj)
{
    if constexpr (has_toString<T>)
        return obj->toString();
    else
        return "toString not defined";
}

Coup de pouce.TTI

Encore un peu idiomatiques trousse d'outils pour effectuer une telle vérification - même si moins élégant - est Coup de pouce.TTI, introduit en Boost 1.54.0. Pour votre exemple, vous devez utiliser la macro BOOST_TTI_HAS_MEMBER_FUNCTION. Voici comment vous pourriez l'utiliser:

#include <boost/tti/has_member_function.hpp>

//Generate the metafunction
BOOST_TTI_HAS_MEMBER_FUNCTION(toString)

//Check whether T has a member function toString
//which takes no parameter and returns a std::string
constexpr bool foo = has_member_function_toString<T, std::string>::value;

Ensuite, vous pouvez utiliser le bool pour créer un SFINAE vérifier.

Explication

La macro BOOST_TTI_HAS_MEMBER_FUNCTION génère le metafunction has_member_function_toString qui prend les bagages de type comme premier paramètre du modèle. Le deuxième paramètre du modèle correspond au type de retour de la fonction membre, et les paramètres suivants correspondent aux types de la fonction paramètres. Le membre value contient true si la classe T a une fonction membre std::string toString().

Sinon, has_member_function_toString peut prendre un membre de pointeur de fonction en tant que paramètre du modèle. Par conséquent, il est possible de remplacer has_member_function_toString<T, std::string>::value par has_member_function_toString<std::string T::* ()>::value.

OriginalL'auteur Morwenn

Une solution simple pour le C++11:

template<class T>
auto optionalToString(T* obj)
 -> decltype(  obj->toString()  )
{
    return     obj->toString();
}
auto optionalToString(...) -> string
{
    return "toString not defined";
}

Mise à jour, 3 ans plus tard: (et ce n'est pas testée). Pour tester l'existence, je pense que cela va fonctionner:

template<class T>
constexpr auto test_has_toString_method(T* obj)
 -> decltype(  obj->toString() , std::true_type{} )
{
    return     obj->toString();
}
constexpr auto test_has_toString_method(...) -> std::false_type
{
    return "toString not defined";
}

OriginalL'auteur Aaron McDaid

C'est un C++11 solution pour le problème général si "Si j'ai fait X, serait-il compiler?"

template<class> struct type_sink { typedef void type; }; //consumes a type, and makes it `void`
template<class T> using type_sink_t = typename type_sink<T>::type;
template<class T, class=void> struct has_to_string : std::false_type {}; \
template<class T> struct has_to_string<
  T,
  type_sink_t< decltype( std::declval<T>().toString() ) >
>: std::true_type {};

Trait has_to_string tels que has_to_string<T>::value est true si et seulement si T a une méthode .toString qui peuvent être invoquées avec 0 arguments dans ce contexte.

Prochaine, j'aimerais utiliser la balise expédition:

namespace details {
  template<class T>
  std::string optionalToString_helper(T* obj, std::true_type /*has_to_string*/) {
    return obj->toString();
  }
  template<class T>
  std::string optionalToString_helper(T* obj, std::false_type /*has_to_string*/) {
    return "toString not defined";
  }
}
template<class T>
std::string optionalToString(T* obj) {
  return details::optionalToString_helper( obj, has_to_string<T>{} );
}

qui tend à être plus facile à gérer que le complexe SFINAE expressions.

Vous pouvez écrire ces traits avec une macro si vous vous retrouver à faire beaucoup, mais ils sont relativement simples (quelques lignes) donc peut-être pas la peine:

#define MAKE_CODE_TRAIT( TRAIT_NAME, ... ) \
template<class T, class=void> struct TRAIT_NAME : std::false_type {}; \
template<class T> struct TRAIT_NAME< T, type_sink_t< decltype( __VA_ARGS__ ) > >: std::true_type {};

ce que le ci-dessus n'est de créer une macro MAKE_CODE_TRAIT. Vous transmettre le nom de la caractéristique que vous voulez, et du code qui peut tester le type T. Donc:

MAKE_CODE_TRAIT( has_to_string, std::declval<T>().toString() )

crée la au-dessus de traits de classe.

Que d'un côté, la technique ci-dessus est une partie de ce que MS appelle "expression SFINAE", et leur 2013 compilateur échoue assez dur.

Noter qu'en C++1y la syntaxe suivante est possible:

template<class T>
std::string optionalToString(T* obj) {
  return compiled_if< has_to_string >(*obj, [&](auto&& obj) {
    return obj.toString();
  }) *compiled_else ([&]{ 
    return "toString not defined";
  });
}

qui est une ligne de compilation conditionnelle branche d'abus de beaucoup de fonctionnalités C++. Cela est probablement pas la peine, que le bénéfice (de code inline) ne vaut pas le coût (de la prochaine à personne de comprendre comment ça fonctionne), mais l'existence de cette solution ci-dessus peuvent être d'intérêt.

OriginalL'auteur Yakk - Adam Nevraumont

La norme C++ solution présentée ici par litb ne fonctionnera pas comme prévu si la méthode se trouve être définie dans une classe de base.

Pour une solution qui gère cette situation se référer à :

En Russe :
http://www.rsdn.ru/forum/message/2759773.1.aspx

De Traduction de l'anglais par Romain.Perepelitsa :
http://groups.google.com/group/comp.lang.c++.moderated/tree/browse_frm/thread/4f7c7a96f9afbe44/c95a7b4c645e449f?pli=1

Il est incroyablement intelligent. Cependant un problème avec ce solutiion est-ce que donne les erreurs de compilation si le type testée est celle qui ne peut pas être utilisée comme classe de base (par exemple, les types primitifs)

Dans Visual Studio, j'ai remarqué que si l'on travaille avec la méthode ayant pas d'arguments, d'une paire supplémentaire de licenciés ( ) doit être insérée à travers le argments à déduire( ) dans l'expression sizeof.

OriginalL'auteur

J'ai écrit une réponse à cette question dans un autre thread que (contrairement aux solutions ci-dessus) vérifie également hérité des fonctions de membre:

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

Voici quelques exemple de cette solution:

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 travaille avec des types primitifs. (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.

OriginalL'auteur kispaljr

J'ai modifié la solution fournie dans https://stackoverflow.com/a/264088/2712152 pour le rendre un peu plus général. Aussi, puisqu'il n'utilise pas du tout de le nouveau C++11 fonctionnalités que l'on peut utiliser avec les anciens compilateurs et devrait également travailler avec msvc. Mais les compilateurs doivent permettre C99 pour utiliser cette car il utilise variadic macros.

La macro suivante peut être utilisée pour vérifier si une classe a un particulier typedef ou pas.

/** 
 * @class      : HAS_TYPEDEF
 * @brief      : This macro will be used to check if a class has a particular
 * typedef or not.
 * @param typedef_name : Name of Typedef
 * @param name  : Name of struct which is going to be run the test for
 * the given particular typedef specified in typedef_name
 */
#define HAS_TYPEDEF(typedef_name, name)                           \
   template <typename T>                                          \
   struct name {                                                  \
      typedef char yes[1];                                        \
      typedef char no[2];                                         \
      template <typename U>                                       \
      struct type_check;                                          \
      template <typename _1>                                      \
      static yes& chk(type_check<typename _1::typedef_name>*);    \
      template <typename>                                         \
      static no& chk(...);                                        \
      static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
   }

La macro suivante peut être utilisée pour vérifier si une classe a un membre en particulier ou non la fonction avec un nombre donné d'arguments.

/** 
 * @class      : HAS_MEM_FUNC
 * @brief      : This macro will be used to check if a class has a particular
 * member function implemented in the public section or not. 
 * @param func : Name of Member Function
 * @param name : Name of struct which is going to be run the test for
 * the given particular member function name specified in func
 * @param return_type: Return type of the member function
 * @param ellipsis(...) : Since this is macro should provide test case for every
 * possible member function we use variadic macros to cover all possibilities
 */
#define HAS_MEM_FUNC(func, name, return_type, ...)                \
   template <typename T>                                          \
   struct name {                                                  \
      typedef return_type (T::*Sign)(__VA_ARGS__);                \
      typedef char yes[1];                                        \
      typedef char no[2];                                         \
      template <typename U, U>                                    \
      struct type_check;                                          \
      template <typename _1>                                      \
      static yes& chk(type_check<Sign, &_1::func>*);              \
      template <typename>                                         \
      static no& chk(...);                                        \
      static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
   }

Nous pouvons utiliser le ci-dessus 2 macros pour effectuer les contrôles pour has_typedef et has_mem_func:

class A {
public:
  typedef int check;
  void check_function() {}
};

class B {
public:
  void hello(int a, double b) {}
  void hello() {}
};

HAS_MEM_FUNC(check_function, has_check_function, void, void);
HAS_MEM_FUNC(hello, hello_check, void, int, double);
HAS_MEM_FUNC(hello, hello_void_check, void, void);
HAS_TYPEDEF(check, has_typedef_check);

int main() {
  std::cout << "Check Function A:" << has_check_function<A>::value << std::endl;
  std::cout << "Check Function B:" << has_check_function<B>::value << std::endl;
  std::cout << "Hello Function A:" << hello_check<A>::value << std::endl;
  std::cout << "Hello Function B:" << hello_check<B>::value << std::endl;
  std::cout << "Hello void Function A:" << hello_void_check<A>::value << std::endl;
  std::cout << "Hello void Function B:" << hello_void_check<B>::value << std::endl;
  std::cout << "Check Typedef A:" << has_typedef_check<A>::value << std::endl;
  std::cout << "Check Typedef B:" << has_typedef_check<B>::value << std::endl;
}

OriginalL'auteur Shubham

Étrange, personne n'a suggéré ce qui suit tour de nice, j'ai vu une fois sur ce site :

template <class T>
struct has_foo
{
    struct S { void foo(...); };
    struct derived : S, T {};

    template <typename V, V> struct W {};

    template <typename X>
    char (&test(W<void (X::*)(), &X::foo> *))[1];

    template <typename>
    char (&test(...))[2];

    static const bool value = sizeof(test<derived>(0)) == 1;
};

Vous devez vous assurer que T est une classe. Il semble que l'ambiguïté dans la recherche de foo est une substitution de l'échec. Je l'ai fait travailler sur gcc, vous ne savez pas si c'est standard.

OriginalL'auteur Alexandre C.

Il y a beaucoup de réponses ici, mais je n'ai pas réussi, à trouver une version, qui effectue réel méthode de résolution de la commande, lorsque vous n'utilisez pas toutes les nouvelles fonctionnalités c++ (uniquement à l'aide de c++98).

Note: Cette version est testée et fonctionne avec vc++2013, g++ 5.2.0 et la onlline compilateur.

Alors je suis venu avec une version, qui utilise uniquement sizeof():

template<typename T> T declval(void);
struct fake_void { };
template<typename T> T &operator,(T &,fake_void);
template<typename T> T const &operator,(T const &,fake_void);
template<typename T> T volatile &operator,(T volatile &,fake_void);
template<typename T> T const volatile &operator,(T const volatile &,fake_void);
struct yes { char v[1]; };
struct no  { char v[2]; };
template<bool> struct yes_no:yes{};
template<> struct yes_no<false>:no{};
template<typename T>
struct has_awesome_member {
template<typename U> static yes_no<(sizeof((
declval<U>().awesome_member(),fake_void()
))!=0)> check(int);
template<typename> static no check(...);
enum{value=sizeof(check<T>(0)) == sizeof(yes)};
};
struct foo { int awesome_member(void); };
struct bar { };
struct foo_void { void awesome_member(void); };
struct wrong_params { void awesome_member(int); };
static_assert(has_awesome_member<foo>::value,"");
static_assert(!has_awesome_member<bar>::value,"");
static_assert(has_awesome_member<foo_void>::value,"");
static_assert(!has_awesome_member<wrong_params>::value,"");

Démo en Live (avec extension de type de retour de la vérification et de la vc++2010 solution de contournement): http://cpp.sh/5b2vs

Pas de source, comme je suis venu avec moi-même.

Lors de l'exécution de la démonstration en Direct sur le compilateur g++, veuillez noter que la taille des matrices de 0 sont autorisés, ce qui signifie que le static_assert utilisés ne déclenche pas une erreur de compilation, même quand il échoue.

Couramment utilisée pour la solution de contournement consiste à remplacer la "typedef" dans la macro avec 'extern'.

OriginalL'auteur user3296587

Voici ma version qui gère tous les possibles de la fonction membre surcharges arbitraire arité, y compris les fonctions membres de modèle, éventuellement avec des arguments par défaut. Il distingue 3 mutuellement exclusifs scénarios lors d'un appel de fonction membre pour certains type de classe, avec arg types: (1) valide, ou (2) ambigu, ou (3) non-viable. Exemple d'utilisation:

#include <string>
#include <vector>
HAS_MEM(bar)
HAS_MEM_FUN_CALL(bar)
struct test
{
void bar(int);
void bar(double);
void bar(int,double);
template < typename T >
typename std::enable_if< not std::is_integral<T>::value >::type
bar(const T&, int=0){}
template < typename T >
typename std::enable_if< std::is_integral<T>::value >::type
bar(const std::vector<T>&, T*){}
template < typename T >
int bar(const std::string&, int){}
};

Maintenant, vous pouvez l'utiliser comme ceci:

int main(int argc, const char * argv[])
{
static_assert( has_mem_bar<test>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(char const*,long)>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(std::string&,long)>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(std::vector<int>, int*)>::value , "");
static_assert( has_no_viable_mem_fun_call_bar<test(std::vector<double>, double*)>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(int)>::value , "");
static_assert( std::is_same<void,result_of_mem_fun_call_bar<test(int)>::type>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(int,double)>::value , "");
static_assert( not has_valid_mem_fun_call_bar<test(int,double,int)>::value , "");
static_assert( not has_ambiguous_mem_fun_call_bar<test(double)>::value , "");
static_assert( has_ambiguous_mem_fun_call_bar<test(unsigned)>::value , "");
static_assert( has_viable_mem_fun_call_bar<test(unsigned)>::value , "");
static_assert( has_viable_mem_fun_call_bar<test(int)>::value , "");
static_assert( has_no_viable_mem_fun_call_bar<test(void)>::value , "");
return 0;
}

Voici le code, écrit en c++11, cependant, vous pouvez facilement le porter (avec des modifications mineures) non c++11 qui a typeof extensions (par exemple gcc). Vous pouvez remplacer le HAS_MEM macro avec votre propre.

#pragma once
#if __cplusplus >= 201103
#include <utility>
#include <type_traits>
#define HAS_MEM(mem)                                                                                     \
\
template < typename T >                                                                               \
struct has_mem_##mem                                                                                  \
{                                                                                                     \
struct yes {};                                                                                     \
struct no  {};                                                                                     \
\
struct ambiguate_seed { char mem; };                                                               \
template < typename U > struct ambiguate : U, ambiguate_seed {};                                   \
\
template < typename U, typename = decltype(&U::mem) > static constexpr no  test(int);              \
template < typename                                 > static constexpr yes test(...);              \
\
static bool constexpr value = std::is_same<decltype(test< ambiguate<T> >(0)),yes>::value ;         \
typedef std::integral_constant<bool,value>    type;                                                \
};
#define HAS_MEM_FUN_CALL(memfun)                                                                         \
\
template < typename Signature >                                                                       \
struct has_valid_mem_fun_call_##memfun;                                                               \
\
template < typename T, typename... Args >                                                             \
struct has_valid_mem_fun_call_##memfun< T(Args...) >                                                  \
{                                                                                                     \
struct yes {};                                                                                     \
struct no  {};                                                                                     \
\
template < typename U, bool = has_mem_##memfun<U>::value >                                         \
struct impl                                                                                        \
{                                                                                                  \
template < typename V, typename = decltype(std::declval<V>().memfun(std::declval<Args>()...)) > \
struct test_result { using type = yes; };                                                       \
\
template < typename V > static constexpr typename test_result<V>::type test(int);               \
template < typename   > static constexpr                            no test(...);               \
\
static constexpr bool value = std::is_same<decltype(test<U>(0)),yes>::value;                    \
using type = std::integral_constant<bool, value>;                                               \
};                                                                                                 \
\
template < typename U >                                                                            \
struct impl<U,false> : std::false_type {};                                                         \
\
static constexpr bool value = impl<T>::value;                                                      \
using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
\
template < typename Signature >                                                                       \
struct has_ambiguous_mem_fun_call_##memfun;                                                           \
\
template < typename T, typename... Args >                                                             \
struct has_ambiguous_mem_fun_call_##memfun< T(Args...) >                                              \
{                                                                                                     \
struct ambiguate_seed { void memfun(...); };                                                       \
\
template < class U, bool = has_mem_##memfun<U>::value >                                            \
struct ambiguate : U, ambiguate_seed                                                               \
{                                                                                                  \
using ambiguate_seed::memfun;                                                                    \
using U::memfun;                                                                                 \
};                                                                                                 \
\
template < class U >                                                                               \
struct ambiguate<U,false> : ambiguate_seed {};                                                     \
\
static constexpr bool value = not has_valid_mem_fun_call_##memfun< ambiguate<T>(Args...) >::value; \
using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
\
template < typename Signature >                                                                       \
struct has_viable_mem_fun_call_##memfun;                                                              \
\
template < typename T, typename... Args >                                                             \
struct has_viable_mem_fun_call_##memfun< T(Args...) >                                                 \
{                                                                                                     \
static constexpr bool value = has_valid_mem_fun_call_##memfun<T(Args...)>::value                   \
or has_ambiguous_mem_fun_call_##memfun<T(Args...)>::value;              \
using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
\
template < typename Signature >                                                                       \
struct has_no_viable_mem_fun_call_##memfun;                                                           \
\
template < typename T, typename... Args >                                                             \
struct has_no_viable_mem_fun_call_##memfun < T(Args...) >                                             \
{                                                                                                     \
static constexpr bool value = not has_viable_mem_fun_call_##memfun<T(Args...)>::value;             \
using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
\
template < typename Signature >                                                                       \
struct result_of_mem_fun_call_##memfun;                                                               \
\
template < typename T, typename... Args >                                                             \
struct result_of_mem_fun_call_##memfun< T(Args...) >                                                  \
{                                                                                                     \
using type = decltype(std::declval<T>().memfun(std::declval<Args>()...));                          \
};
#endif

OriginalL'auteur Hui

Voici un exemple du code de travail.

template<typename T>
using toStringFn = decltype(std::declval<const T>().toString());
template <class T, toStringFn<T>* = nullptr>
std::string optionalToString(const T* obj, int)
{
return obj->toString();
}
template <class T>
std::string optionalToString(const T* obj, long)
{
return "toString not defined";
}
int main()
{
A* a;
B* b;
std::cout << optionalToString(a, 0) << std::endl; //This is A
std::cout << optionalToString(b, 0) << std::endl; //toString not defined
}

toStringFn<T>* = nullptr permettra à la fonction qui prend supplémentaire int argument qui a priorité sur la fonction qui prend long lorsqu'il est appelé avec 0.

Vous pouvez utiliser le même principe pour les fonctions qui retourne true si la fonction est mise en œuvre.

template <typename T>
constexpr bool toStringExists(long)
{
return false;
}
template <typename T, toStringFn<T>* = nullptr>
constexpr bool toStringExists(int)
{
return true;
}
int main()
{
A* a;
B* b;
std::cout << toStringExists<A>(0) << std::endl; //true
std::cout << toStringExists<B>(0) << std::endl; //false
}

OriginalL'auteur tereshkd

template<class T>
auto optionalToString(T* obj)
->decltype( obj->toString(), std::string() )
{
return obj->toString();
}
template<class T>
auto optionalToString(T* obj)
->decltype( std::string() )
{
throw "Error!";
}

OriginalL'auteur Abhishek