Templated check for the existence of a class member function

Question

Is it possible to write a template that changes behavior depending on if a certain member function is defined on a class   Here s a simple example of what I would want to write   template lt class T gt  std  string optionalToString T  obj        if  FUNCTION EXISTS T- gt toString           return obj- gt toString        else         return  toString not defined       So  if class T has toString   defined  then it uses it  otherwise  it doesn t  The magical part that I don t know how to do is the  FUNCTION EXISTS  part

User · Answer

The standard C   solution presented here by litb will not work as expected if the method happens to be defined in a base class    For a solution that handles this situation refer to    In Russian   http   www rsdn ru forum message 2759773 1 aspx   English Translation by Roman Perepelitsa    http   groups google com group comp lang c   moderated tree browse frm thread 4f7c7a96f9afbe44 c95a7b4c645e449f pli 1   It is insanely clever  However one issue with this solutiion is that gives compiler errors if the type being tested is one that cannot be used as a base class  e g  primitive types   In Visual Studio  I noticed that if working with method having no arguments  an extra pair of redundant      needs to be inserted around the argments to deduce     in the sizeof expression

User · Answer

I know that this question is years old  but I think it would useful for people like me to have a more complete updated answer that also works for const overloaded methods such as std  vector lt  gt   begin  Based on that answer and that answer from my follow up question  here s a more complete answer  Note that this will only work with C  11 and higher   include  lt iostream gt   include  lt vector gt   class EmptyClass     template  lt typename T gt  class has begin       private      has begin     delete           struct one   char x 1          struct two   char x 2           template  lt typename C gt  static one test  decltype void std  declval lt C  amp  gt    begin               template  lt typename C gt  static two test            public      static constexpr bool value   sizeof test lt T gt  0      sizeof one           int main int argc  char  argv          std  cout  lt  lt  std  boolalpha      std  cout  lt  lt   quot vector lt int gt   begin   exists   quot   lt  lt  has begin lt std  vector lt int gt  gt   value  lt  lt  std  endl      std  cout  lt  lt   quot EmptyClass  begin   exists   quot   lt  lt  has begin lt EmptyClass gt   value  lt  lt  std  endl      return 0     Or the shorter version   include  lt iostream gt   include  lt vector gt   class EmptyClass     template  lt typename T  typename   void gt  struct has begin   std  false type      template  lt typename T gt  struct has begin lt T  decltype void std  declval lt T  amp  gt    begin     gt    std  true type      int main int argc  char  argv          std  cout  lt  lt  std  boolalpha      std  cout  lt  lt   quot vector lt int gt   begin   exists   quot   lt  lt  has begin lt std  vector lt int gt  gt   value  lt  lt  std  endl      std  cout  lt  lt   quot EmptyClass exists   quot   lt  lt  has begin lt EmptyClass gt   value  lt  lt  std  endl     Note that here a complete sample call must be provided  This means that if we tested for the resize method s existence then we would have put resize 0   Deep magic explanation  The first answer posted of this question used test  decltype  amp C  helloworld     however this is problematic when the method it is testing is ambiguous due const overloading  thus making the substitution attempt fail  To solve this ambiguity we use a void statement which can take any parameters because it is always translated into a noop and thus the ambiguity is nullified and the call is valid as long as the method exists  has begin lt T  decltype void std  declval lt T  amp  gt    begin     gt   Here s what s happening in order  We use std  declval lt T  amp  gt    to create a callable value for which begin can then be called  After that the value of begin is passed as a parameter to a void statement  We then retrieve the type of that void expression using the builtin decltype so that it can be used as a template type argument  If begin doesn t exist then the substitution is invalid and as per SFINAE the other declaration is used instead

User · Answer

Yes  with SFINAE you can check if a given class does provide a certain method  Here s the working code   include  lt iostream gt   struct Hello       int helloworld     return 0        struct Generic             SFINAE test template  lt typename T gt  class has helloworld       typedef char one      struct two   char x 2           template  lt typename C gt  static one test  decltype  amp C  helloworld          template  lt typename C gt  static two test            public      enum   value   sizeof test lt T gt  0      sizeof char             int main int argc  char  argv          std  cout  lt  lt  has helloworld lt Hello gt   value  lt  lt  std  endl      std  cout  lt  lt  has helloworld lt Generic gt   value  lt  lt  std  endl      return 0     I ve just tested it with Linux and gcc 4 1 4 3  I don t know if it s portable to other platforms running different compilers

User · Answer

This is a C  11 solution for the general problem if  If I did X  would it compile    template lt class gt  struct type sink   typedef void type        consumes a type  and makes it  void  template lt class T gt  using type sink t   typename type sink lt T gt   type  template lt class T  class void gt  struct has to string   std  false type       template lt class T gt  struct has to string lt    T    type sink t lt  decltype  std  declval lt T gt    toString      gt   gt   std  true type       Trait has to string such that has to string lt T gt   value is true if and only if T has a method  toString that can be invoked with 0 arguments in this context   Next  I d use tag dispatching   namespace details     template lt class T gt    std  string optionalToString helper T  obj  std  true type   has to string          return obj- gt toString          template lt class T gt    std  string optionalToString helper T  obj  std  false type   has to string          return  toString not defined         template lt class T gt  std  string optionalToString T  obj      return details  optionalToString helper  obj  has to string lt T gt           which tends to be more maintainable than complex SFINAE expressions   You can write these traits with a macro if you find yourself doing it alot  but they are relatively simple  a few lines each  so maybe not worth it    define MAKE CODE TRAIT  TRAIT NAME          template lt class T  class void gt  struct TRAIT NAME   std  false type       template lt class T gt  struct TRAIT NAME lt  T  type sink t lt  decltype    VA ARGS      gt   gt   std  true type       what the above does is create a macro MAKE CODE TRAIT   You pass it the name of the trait you want  and some code that can test the type T   Thus   MAKE CODE TRAIT  has to string  std  declval lt T gt    toString       creates the above traits class   As an aside  the above technique is part of what MS calls  expression SFINAE   and their 2013 compiler fails pretty hard   Note that in C  1y the following syntax is possible   template lt class T gt  std  string optionalToString T  obj      return compiled if lt  has to string  gt   obj    amp   auto amp  amp  obj        return obj toString          compiled else    amp         return  toString not defined             which is an inline compilation conditional branch that abuses lots of C   features   Doing so is probably not worth it  as the benefit  of code being inline  is not worth the cost  of next to nobody understanding how it works   but the existence of that above solution may be of interest

User · Answer

How about this solution    include  lt type traits gt   template  lt typename U  typename   void gt  struct hasToString   std  false type       template  lt typename U gt  struct hasToString lt U    typename std  enable if lt bool sizeof  amp U  toString   gt   type  gt    std  true type

User · Answer

My take  to universally determine if something is callable without making verbose type traits for each and every one  or using experimental features  or long code  template lt typename Callable  typename    Args  typename   decltype declval lt Callable gt    declval lt Args gt         gt  std  true type isCallableImpl Callable  Args       return        std  false type isCallableImpl        return        template lt typename    Args  typename Callable gt  constexpr bool isCallable Callable callable        return decltype isCallableImpl callable  declval lt Args gt               Usage  constexpr auto TO STRING TEST      auto in  - gt  decltype in toString      return        constexpr bool TO STRING WORKS   isCallable lt T gt  TO STRING TEST

User · Answer

There are a lot of answers here  but I failed  to find a version  that performs real method resolution ordering  while not using any of the newer c   features  only using c  98 features   Note  This version is tested and working with vc  2013  g   5 2 0 and the onlline compiler   So I came up with a version  that only uses sizeof     template lt typename T gt  T declval void    struct fake void      template lt typename T gt  T  amp operator  T  amp  fake void   template lt typename T gt  T const  amp operator  T const  amp  fake void   template lt typename T gt  T volatile  amp operator  T volatile  amp  fake void   template lt typename T gt  T const volatile  amp operator  T const volatile  amp  fake void    struct yes   char v 1      struct no    char v 2      template lt bool gt  struct yes no yes    template lt  gt  struct yes no lt false gt  no     template lt typename T gt  struct has awesome member    template lt typename U gt  static yes no lt  sizeof      declval lt U gt    awesome member   fake void         0  gt  check int    template lt typename gt  static no check        enum value sizeof check lt T gt  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 lt foo gt   value      static assert  has awesome member lt bar gt   value      static assert has awesome member lt foo void gt   value      static assert  has awesome member lt wrong params gt   value        Live demo  with extended return type checking and vc  2010 workaround   http   cpp sh 5b2vs  No source  as I came up with it myself   When running the Live demo on the g   compiler  please note that array sizes of 0 are allowed  meaning that the static assert used will not trigger a compiler error  even when it fails  A commonly used work-around is to replace the  typedef  in the macro with  extern

User · Answer

The generic template that can be used for checking if some  feature  is supported by the type    include  lt type traits gt   template  lt template  lt typename gt  class TypeChecker  typename Type gt  struct is supported          these structs are used to recognize which version        of the two functions was chosen during overload resolution     struct supported         struct not supported             this overload of chk will be ignored by SFINAE principle        if TypeChecker lt Type  gt  is invalid type     template  lt typename Type  gt      static supported chk typename std  decay lt TypeChecker lt Type  gt  gt   type             ellipsis has the lowest conversion rank  so this overload will be        chosen during overload resolution only if the template overload above is ignored     template  lt typename Type  gt      static not supported chk               if the template overload of chk is chosen during        overload resolution then the feature is supported        if the ellipses overload is chosen the the feature is not supported     static constexpr bool value   std  is same lt decltype chk lt Type gt  nullptr   supported gt   value       The template that checks whether there is a method foo that is compatible with signature double const char       if T doesn t have foo method with the signature that allows to compile the bellow    expression then instantiating this template is Substitution Failure  SF     which Is Not An Error  INAE  if this happens during overload resolution template  lt typename T gt  using has foo   decltype double std  declval lt T gt    foo std  declval lt const char  gt          Examples     types that support has foo struct struct1   double foo const char                     exact signature match struct struct2   int    foo const std  string  amp str         compatible signature struct struct3   float  foo                                compatible ellipsis signature struct struct4   template  lt typename T gt                   int    foo T t                            compatible template signature     types that do not support has foo struct struct5   void        foo const char          returns void struct struct6   std  string foo const char          std  string can t be converted to double struct struct7   double      foo       int           const char  can t be converted to int  struct struct8   double      bar const char          there is no foo method  int main         std  cout  lt  lt  std  boolalpha       std  cout  lt  lt  is supported lt has foo  int     gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  double  gt   value  lt  lt  std  endl     false      std  cout  lt  lt  is supported lt has foo  struct1 gt   value  lt  lt  std  endl     true     std  cout  lt  lt  is supported lt has foo  struct2 gt   value  lt  lt  std  endl     true     std  cout  lt  lt  is supported lt has foo  struct3 gt   value  lt  lt  std  endl     true     std  cout  lt  lt  is supported lt has foo  struct4 gt   value  lt  lt  std  endl     true      std  cout  lt  lt  is supported lt has foo  struct5 gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  struct6 gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  struct7 gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  struct8 gt   value  lt  lt  std  endl     false      return 0      http   coliru stacked-crooked com a 83c6a631ed42cea4

User · Answer

An example using SFINAE and template partial specialization  by writing a Has foo concept check     include  lt type traits gt  struct A     struct B  int foo int a  int b      struct C void foo int a  int b      struct D int foo       struct E  public B        available in C  17 onwards as part of  lt type traits gt  template lt typename    gt  using void t   void   template lt typename T  typename   void gt  struct Has foo  std  false type     template lt typename T gt   struct Has foo lt T  void t lt      std  enable if t lt          std  is same lt              int               decltype std  declval lt T gt    foo  int 0   int 0            gt   value      gt   gt  gt   std  true type      static assert not Has foo lt A gt   value   A does not have a foo    static assert Has foo lt B gt   value   B has a foo    static assert not Has foo lt C gt   value   C has a foo with the wrong return      static assert not Has foo lt D gt   value   D has a foo with the wrong arguments      static assert Has foo lt E gt   value   E has a foo since it inherits from B

User · Answer

Here is an example of the working code   template lt typename T gt  using toStringFn   decltype std  declval lt const T gt    toString      template  lt class T  toStringFn lt T gt     nullptr gt  std  string optionalToString const T  obj  int        return obj- gt toString       template  lt class T gt  std  string optionalToString const T  obj  long        return  toString not defined      int main         A  a      B  b       std  cout  lt  lt  optionalToString a  0   lt  lt  std  endl     This is A     std  cout  lt  lt  optionalToString b  0   lt  lt  std  endl     toString not defined     toStringFn lt T gt     nullptr will enable the function which takes extra int argument which has a priority over function which takes long when called with 0   You can use the same principle for the functions which returns true if function is implemented   template  lt typename T gt  constexpr bool toStringExists long        return false     template  lt typename T  toStringFn lt T gt     nullptr gt  constexpr bool toStringExists int        return true      int main         A  a      B  b       std  cout  lt  lt  toStringExists lt A gt  0   lt  lt  std  endl     true     std  cout  lt  lt  toStringExists lt B gt  0   lt  lt  std  endl     false

User · Answer

This is what type traits are there for  Unfortunately  they have to be defined manually  In your case  imagine the following   template  lt typename T gt  struct response trait       static bool const has tostring   false      template  lt  gt  struct response trait lt your type with tostring gt        static bool const has tostring   true

User · Answer

C   allows SFINAE to be used for this  notice that with C  11 features this is simplier because it supports extended SFINAE on nearly arbitrary expressions - the below was crafted to work with common C  03 compilers     define HAS MEM FUNC func  name                                               template lt typename T  typename Sign gt                                        struct name                                                                   typedef char yes 1                                                        typedef char no  2                                                        template  lt typename U  U gt  struct type check                                template  lt typename  1 gt  static yes  amp chk type check lt Sign   amp  1  func  gt                template  lt typename    gt  static no   amp chk                                    static bool const value   sizeof chk lt T gt  0      sizeof yes                 the above template and macro tries to instantiate a template  giving it a member function pointer type  and the actual member function pointer  If the types to not fit  SFINAE causes the template to be ignored  Usage like this   HAS MEM FUNC toString  has to string    template lt typename T gt  void doSomething        if has to string lt T  std  string T       gt   value                   else                      But note that you cannot just call that toString function in that if branch  since the compiler will check for validity in both branches  that would fail for cases the function doesnt exist  One way is to use SFINAE once again  enable if can be gotten from boost too    template lt bool C  typename T   void gt  struct enable if     typedef T type      template lt typename T gt  struct enable if lt false  T gt        HAS MEM FUNC toString  has to string    template lt typename T gt   typename enable if lt has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T has toString           return t- gt toString       template lt typename T gt   typename enable if lt  has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T doesnt have toString           return  T  toString   does not exist        Have fun using it  The advantage of it is that it also works for overloaded member functions  and also for const member functions  remember using  std  string T       const as the member function pointer type then

User · Answer

This is what type traits are there for  Unfortunately  they have to be defined manually  In your case  imagine the following   template  lt typename T gt  struct response trait       static bool const has tostring   false      template  lt  gt  struct response trait lt your type with tostring gt        static bool const has tostring   true

User · Answer

Now this was a nice little puzzle - great question   Here s an alternative to Nicola Bonelli s solution that does not rely on the non-standard typeof operator   Unfortunately  it does not work on GCC  MinGW  3 4 5 or Digital Mars 8 42n  but it does work on all versions of MSVC  including VC6  and on Comeau C     The longer comment block has the details on how it works  or is supposed to work    As it says  I m not sure which behavior is standards compliant - I d welcome commentary on that     update - 7 Nov 2008   It looks like while this code is syntactically correct  the behavior that MSVC and Comeau C   show does not follow the standard  thanks to Leon Timmermans and litb for pointing me in the right direction    The C  03 standard says the following      14 6 2 Dependent names  temp dep       Paragraph 3      In the definition of a class template   or a member of a class template  if a   base class of the class template   depends on a template-parameter  the   base class scope is not examined   during unqualified name lookup either   at the point of definition of the   class template or member or during an   instantiation of the class template or   member    So  it looks like that when MSVC or Comeau consider the toString   member function of T performing name lookup at the call site in doToString   when the template is instantiated  that is incorrect  even though it s actually the behavior I was looking for in this case    The behavior of GCC and Digital Mars looks to be correct - in both cases the non-member toString   function is bound to the call   Rats - I thought I might have found a clever solution  instead I uncovered a couple compiler bugs        include  lt iostream gt   include  lt string gt   struct Hello       std  string toString             return  Hello             struct Generic          the following namespace keeps the toString   method out of     most everything - except the other stuff in this     compilation unit  namespace       std  string toString                 return  toString not defined              template  lt typename T gt      class optionalToStringImpl   public T           public          std  string doToString                     in theory  the name lookup for this call to                  toString   should find the toString   in                  the base class T if one exists  but if one                  doesn t exist in the base class  it ll                  find the free toString   function in                  the private namespace                                This theory works for MSVC  all versions                 from VC6 to VC9  and Comeau C    but                 does not work with MinGW 3 4 5 or                  Digital Mars 8 42n                               I m honestly not sure what the standard says                  is the correct behavior here - it s sort                  of like ADL  Argument Dependent Lookup -                  also known as Koenig Lookup  but without                 arguments  except the implied  this  pointer               return toString                        template  lt typename T gt  std  string optionalToString T  amp  obj           ugly  hacky cast        optionalToStringImpl lt T gt   temp   reinterpret cast lt optionalToStringImpl lt T gt   gt    amp obj        return temp- gt doToString         int main int argc  char  argv          Hello helloObj      Generic genericObj       std  cout  lt  lt  optionalToString  helloObj   lt  lt  std  endl      std  cout  lt  lt  optionalToString  genericObj   lt  lt  std  endl      return 0

User · Answer

This is what type traits are there for  Unfortunately  they have to be defined manually  In your case  imagine the following   template  lt typename T gt  struct response trait       static bool const has tostring   false      template  lt  gt  struct response trait lt your type with tostring gt        static bool const has tostring   true

User · Answer

C   allows SFINAE to be used for this  notice that with C  11 features this is simplier because it supports extended SFINAE on nearly arbitrary expressions - the below was crafted to work with common C  03 compilers     define HAS MEM FUNC func  name                                               template lt typename T  typename Sign gt                                        struct name                                                                   typedef char yes 1                                                        typedef char no  2                                                        template  lt typename U  U gt  struct type check                                template  lt typename  1 gt  static yes  amp chk type check lt Sign   amp  1  func  gt                template  lt typename    gt  static no   amp chk                                    static bool const value   sizeof chk lt T gt  0      sizeof yes                 the above template and macro tries to instantiate a template  giving it a member function pointer type  and the actual member function pointer  If the types to not fit  SFINAE causes the template to be ignored  Usage like this   HAS MEM FUNC toString  has to string    template lt typename T gt  void doSomething        if has to string lt T  std  string T       gt   value                   else                      But note that you cannot just call that toString function in that if branch  since the compiler will check for validity in both branches  that would fail for cases the function doesnt exist  One way is to use SFINAE once again  enable if can be gotten from boost too    template lt bool C  typename T   void gt  struct enable if     typedef T type      template lt typename T gt  struct enable if lt false  T gt        HAS MEM FUNC toString  has to string    template lt typename T gt   typename enable if lt has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T has toString           return t- gt toString       template lt typename T gt   typename enable if lt  has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T doesnt have toString           return  T  toString   does not exist        Have fun using it  The advantage of it is that it also works for overloaded member functions  and also for const member functions  remember using  std  string T       const as the member function pointer type then

User · Answer

Probably not as good as other examples  but this is what I came up with for C  11  This works for picking overloaded methods  template  lt typename    Args gt  struct Pack       define Proxy T    T  amp     int    nullptr     template  lt typename Class  typename ArgPack  typename   nullptr t gt  struct HasFoo       enum   value   false        template  lt typename Class  typename    Args gt  struct HasFoo lt      Class      Pack lt Args    gt       decltype  void  Proxy Class  foo Proxy Args        nullptr  gt        enum   value   true        Example usage struct Object       int foo int n            return n     if SOME CONDITION     int foo int n  char c    return n   c     endif     template  lt bool has foo int char gt  struct Dispatcher   template  lt  gt  struct Dispatcher lt false gt        template  lt typename Object gt      static int exec Object  amp object  int n  char c                return object foo n    c            template  lt  gt  struct Dispatcher lt true gt        template  lt typename Object gt      static int exec Object  amp object  int n  char c                return object foo n  c             int runExample         using Args   Pack lt int  char gt       enum   has overload   HasFoo lt Object  Args gt   value        Object object      return Dispatcher lt has overload gt   exec object  100   a

User · Answer

Yet another way to do it in C  17  inspired by boost hana   Write it one time and use many times  It does not require has something lt T gt  SFINAE type traits classes                                                  is valid implementation                                                include  lt type traits gt   template lt typename T  typename F gt  constexpr auto is valid F amp  amp  f  - gt  decltype f std  declval lt T gt      true    return true     template lt typename gt  constexpr bool is valid        return false      define IS VALID T  EXPR  is valid lt T gt      auto amp  amp  obj - gt decltype obj EXPR                                                       Example                                                include  lt iostream gt   include  lt string gt   struct Example       int Foo      void Bar          std  string toString     return  quot Hello from toString    quot         struct Example2       int X      template lt class T gt  std  string optionalToString T  obj        if constexpr IS VALID T  toString             return obj- gt toString        else         return  quot toString not defined quot      int main         static assert IS VALID Example  Foo                       quot Example class must have Foo member quot        static assert IS VALID Example  Bar                         quot Example class must have Bar   member function quot        static assert  IS VALID Example  ZFoo                       quot Example class must not have ZFoo member  quot        static assert  IS VALID Example  ZBar                         quot Example class must not have ZBar   member function quot         Example e1      Example2 e2       std  cout  lt  lt   quot e1   quot   lt  lt  optionalToString  amp e1   lt  lt   quot  n quot       std  cout  lt  lt   quot e1   quot   lt  lt  optionalToString  amp e2   lt  lt   quot  n quot

User · Answer

I wrote an answer to this in another thread that  unlike the solutions above  also checks inherited member functions   SFINAE to check for inherited member functions  Here are some example from that solution   Example1   We are checking for a member with the following signature   T  const iterator begin   const  template lt class T gt  struct has const begin       typedef char   amp Yes  1       typedef char   amp No  2        template lt class U gt       static Yes test U const   data                       typename std  enable if lt std  is same lt                               typename U  const iterator                                decltype data- gt begin                         gt   value gt   type     0       static No test           static const bool value   sizeof Yes     sizeof has const begin  test  typename std  remove reference lt T gt   type  0         Please notice that it even checks the constness of the method  and works with primitive types  as well   I mean has const begin lt int gt   value is false and doesn t cause a compile-time error     Example 2  Now we are looking for the signature  void foo MyClass amp   unsigned   template lt class T gt  struct has foo       typedef char   amp Yes  1       typedef char   amp No  2        template lt class U gt      static Yes test U   data  MyClass  arg1   0                      typename std  enable if lt std  is void lt                               decltype data- gt foo  arg1  1u                        gt   value gt   type     0       static No test           static const bool value   sizeof Yes     sizeof has foo  test  typename std  remove reference lt T gt   type  0         Please notice that MyClass doesn t has to be default constructible or to satisfy any special concept  The technique works with template members  as well   I am eagerly waiting opinions regarding this

User · Answer

I modified the solution provided in https   stackoverflow com a 264088 2712152 to make it a bit more general  Also since it doesn t use any of the new C  11 features we can use it with old compilers and should also work with msvc  But the compilers should enable C99 to use this since it uses variadic macros   The following macro can be used to check if a particular class has a particular typedef or not            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  lt typename T gt                                                struct name                                                            typedef char yes 1                                                  typedef char no 2                                                   template  lt typename U gt                                                struct type check                                                   template  lt typename  1 gt                                               static yes amp  chk type check lt typename  1  typedef name gt                template  lt typename gt                                                  static no amp  chk                                                      static bool const value   sizeof chk lt T gt  0      sizeof yes            The following macro can be used to check if a particular class has a particular member function or not with any given number of 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  lt typename T gt                                                struct name                                                            typedef return type  T   Sign    VA ARGS                            typedef char yes 1                                                  typedef char no 2                                                   template  lt typename U  U gt                                             struct type check                                                   template  lt typename  1 gt                                               static yes amp  chk type check lt Sign   amp  1  func gt                          template  lt typename gt                                                  static no amp  chk                                                      static bool const value   sizeof chk lt T gt  0      sizeof yes            We can use the above 2 macros to perform the checks for has typedef and has mem func as   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  lt  lt   Check Function A    lt  lt  has check function lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Check Function B    lt  lt  has check function lt B gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello Function A    lt  lt  hello check lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello Function B    lt  lt  hello check lt B gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello void Function A    lt  lt  hello void check lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello void Function B    lt  lt  hello void check lt B gt   value  lt  lt  std  endl    std  cout  lt  lt   Check Typedef A    lt  lt  has typedef check lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Check Typedef B    lt  lt  has typedef check lt B gt   value  lt  lt  std  endl

User · Answer

Strange nobody suggested the following nice trick I saw once on this very site    template  lt class T gt  struct has foo       struct S   void foo              struct derived   S  T          template  lt typename V  V gt  struct W          template  lt typename X gt      char   amp test W lt void  X         amp X  foo gt      1        template  lt typename gt      char   amp test       2        static const bool value   sizeof test lt derived gt  0      1       You have to make sure T is a class  It seems that ambiguity in the lookup of foo is a substitution failure  I made it work on gcc  not sure if it is standard though

User · Answer

There are a lot of answers here  but I failed  to find a version  that performs real method resolution ordering  while not using any of the newer c   features  only using c  98 features   Note  This version is tested and working with vc  2013  g   5 2 0 and the onlline compiler   So I came up with a version  that only uses sizeof     template lt typename T gt  T declval void    struct fake void      template lt typename T gt  T  amp operator  T  amp  fake void   template lt typename T gt  T const  amp operator  T const  amp  fake void   template lt typename T gt  T volatile  amp operator  T volatile  amp  fake void   template lt typename T gt  T const volatile  amp operator  T const volatile  amp  fake void    struct yes   char v 1      struct no    char v 2      template lt bool gt  struct yes no yes    template lt  gt  struct yes no lt false gt  no     template lt typename T gt  struct has awesome member    template lt typename U gt  static yes no lt  sizeof      declval lt U gt    awesome member   fake void         0  gt  check int    template lt typename gt  static no check        enum value sizeof check lt T gt  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 lt foo gt   value      static assert  has awesome member lt bar gt   value      static assert has awesome member lt foo void gt   value      static assert  has awesome member lt wrong params gt   value        Live demo  with extended return type checking and vc  2010 workaround   http   cpp sh 5b2vs  No source  as I came up with it myself   When running the Live demo on the g   compiler  please note that array sizes of 0 are allowed  meaning that the static assert used will not trigger a compiler error  even when it fails  A commonly used work-around is to replace the  typedef  in the macro with  extern

User · Answer

Yet another way to do it in C  17  inspired by boost hana   Write it one time and use many times  It does not require has something lt T gt  SFINAE type traits classes                                                  is valid implementation                                                include  lt type traits gt   template lt typename T  typename F gt  constexpr auto is valid F amp  amp  f  - gt  decltype f std  declval lt T gt      true    return true     template lt typename gt  constexpr bool is valid        return false      define IS VALID T  EXPR  is valid lt T gt      auto amp  amp  obj - gt decltype obj EXPR                                                       Example                                                include  lt iostream gt   include  lt string gt   struct Example       int Foo      void Bar          std  string toString     return  quot Hello from toString    quot         struct Example2       int X      template lt class T gt  std  string optionalToString T  obj        if constexpr IS VALID T  toString             return obj- gt toString        else         return  quot toString not defined quot      int main         static assert IS VALID Example  Foo                       quot Example class must have Foo member quot        static assert IS VALID Example  Bar                         quot Example class must have Bar   member function quot        static assert  IS VALID Example  ZFoo                       quot Example class must not have ZFoo member  quot        static assert  IS VALID Example  ZBar                         quot Example class must not have ZBar   member function quot         Example e1      Example2 e2       std  cout  lt  lt   quot e1   quot   lt  lt  optionalToString  amp e1   lt  lt   quot  n quot       std  cout  lt  lt   quot e1   quot   lt  lt  optionalToString  amp e2   lt  lt   quot  n quot

User · Answer

The standard C   solution presented here by litb will not work as expected if the method happens to be defined in a base class    For a solution that handles this situation refer to    In Russian   http   www rsdn ru forum message 2759773 1 aspx   English Translation by Roman Perepelitsa    http   groups google com group comp lang c   moderated tree browse frm thread 4f7c7a96f9afbe44 c95a7b4c645e449f pli 1   It is insanely clever  However one issue with this solutiion is that gives compiler errors if the type being tested is one that cannot be used as a base class  e g  primitive types   In Visual Studio  I noticed that if working with method having no arguments  an extra pair of redundant      needs to be inserted around the argments to deduce     in the sizeof expression

User · Answer

With C   20 you can write the following   template lt typename T gt  concept has toString   requires const T amp  t        t toString        template lt typename T gt  std  string optionalToString const T amp  obj        if constexpr  has toString lt T gt           return obj toString        else         return  toString not defined

User · Answer

Yes  with SFINAE you can check if a given class does provide a certain method  Here s the working code   include  lt iostream gt   struct Hello       int helloworld     return 0        struct Generic             SFINAE test template  lt typename T gt  class has helloworld       typedef char one      struct two   char x 2           template  lt typename C gt  static one test  decltype  amp C  helloworld          template  lt typename C gt  static two test            public      enum   value   sizeof test lt T gt  0      sizeof char             int main int argc  char  argv          std  cout  lt  lt  has helloworld lt Hello gt   value  lt  lt  std  endl      std  cout  lt  lt  has helloworld lt Generic gt   value  lt  lt  std  endl      return 0     I ve just tested it with Linux and gcc 4 1 4 3  I don t know if it s portable to other platforms running different compilers

User · Answer

C  20 - requires expressions With C  20 come concepts and assorted tools such as requires expressions which are a built-in way to check for a function existence  With them you could rewrite your optionalToString function as follows  template lt class T gt  std  string optionalToString T  obj        constexpr bool has toString   requires const T amp  t            t toString                if constexpr  has toString          return obj- gt toString        else         return  quot toString not defined quot      Pre-C  20 - Detection toolkit N4502 proposes a detection toolkit for inclusion into the C  17 standard library that eventually made it into the library fundamentals TS v2  It most likely won t ever get into the standard because it has been subsumed by requires expressions since  but it still solves the problem in a somewhat elegant manner  The toolkit introduces some metafunctions  including std  is detected which can be used to easily write type or function detection metafunctions on the top of it  Here is how you could use it  template lt typename T gt  using toString t   decltype  std  declval lt T amp  gt    toString       template lt typename T gt  constexpr bool has toString   std  is detected v lt toString t  T gt    Note that the example above is untested  The detection toolkit is not available in standard libraries yet but the proposal contains a full implementation that you can easily copy if you really need it  It plays nice with the C  17 feature if constexpr  template lt class T gt  std  string optionalToString T  obj        if constexpr  has toString lt T gt           return obj- gt toString        else         return  quot toString not defined quot      C  14 - Boost Hana Boost Hana apparently builds upon this specific example and provides a solution for C  14 in its documentation  so I m going to quote it directly         Hana provides a is valid function that can be combined with C  14 generic lambdas to obtain a much cleaner implementation of the same thing  auto has toString   hana  is valid    auto amp  amp  obj  - gt  decltype obj toString           This leaves us with a function object has toString which returns whether the given expression is valid on the argument we pass to it  The result is returned as an IntegralConstant  so constexpr-ness is not an issue here because the result of the function is represented as a type anyway  Now  in addition to being less verbose  that s a one liner    the intent is much clearer  Other benefits are the fact that has toString can be passed to higher order algorithms and it can also be defined at function scope  so there is no need to pollute the namespace scope with implementation details   Boost TTI Another somewhat idiomatic toolkit to perform such a check - even though less elegant - is Boost TTI  introduced in Boost 1 54 0  For your example  you would have to use the macro BOOST TTI HAS MEMBER FUNCTION  Here is how you could use it   include  lt boost tti has member function hpp gt      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 lt T  std  string gt   value   Then  you could use the bool to create a SFINAE check  Explanation The macro BOOST TTI HAS MEMBER FUNCTION generates the metafunction has member function toString which takes the checked type as its first template parameter  The second template parameter corresponds to the return type of the member function  and the following parameters correspond to the types of the function s parameters  The member value contains true if the class T has a member function std  string toString    Alternatively  has member function toString can take a member function pointer as a template parameter  Therefore  it is possible to replace has member function toString lt T  std  string gt   value by has member function toString lt std  string T       gt   value

User · Answer

Yes  with SFINAE you can check if a given class does provide a certain method  Here s the working code   include  lt iostream gt   struct Hello       int helloworld     return 0        struct Generic             SFINAE test template  lt typename T gt  class has helloworld       typedef char one      struct two   char x 2           template  lt typename C gt  static one test  decltype  amp C  helloworld          template  lt typename C gt  static two test            public      enum   value   sizeof test lt T gt  0      sizeof char             int main int argc  char  argv          std  cout  lt  lt  has helloworld lt Hello gt   value  lt  lt  std  endl      std  cout  lt  lt  has helloworld lt Generic gt   value  lt  lt  std  endl      return 0     I ve just tested it with Linux and gcc 4 1 4 3  I don t know if it s portable to other platforms running different compilers

User · Answer

Here is an example of the working code   template lt typename T gt  using toStringFn   decltype std  declval lt const T gt    toString      template  lt class T  toStringFn lt T gt     nullptr gt  std  string optionalToString const T  obj  int        return obj- gt toString       template  lt class T gt  std  string optionalToString const T  obj  long        return  toString not defined      int main         A  a      B  b       std  cout  lt  lt  optionalToString a  0   lt  lt  std  endl     This is A     std  cout  lt  lt  optionalToString b  0   lt  lt  std  endl     toString not defined     toStringFn lt T gt     nullptr will enable the function which takes extra int argument which has a priority over function which takes long when called with 0   You can use the same principle for the functions which returns true if function is implemented   template  lt typename T gt  constexpr bool toStringExists long        return false     template  lt typename T  toStringFn lt T gt     nullptr gt  constexpr bool toStringExists int        return true      int main         A  a      B  b       std  cout  lt  lt  toStringExists lt A gt  0   lt  lt  std  endl     true     std  cout  lt  lt  toStringExists lt B gt  0   lt  lt  std  endl     false

User · Answer

Now this was a nice little puzzle - great question   Here s an alternative to Nicola Bonelli s solution that does not rely on the non-standard typeof operator   Unfortunately  it does not work on GCC  MinGW  3 4 5 or Digital Mars 8 42n  but it does work on all versions of MSVC  including VC6  and on Comeau C     The longer comment block has the details on how it works  or is supposed to work    As it says  I m not sure which behavior is standards compliant - I d welcome commentary on that     update - 7 Nov 2008   It looks like while this code is syntactically correct  the behavior that MSVC and Comeau C   show does not follow the standard  thanks to Leon Timmermans and litb for pointing me in the right direction    The C  03 standard says the following      14 6 2 Dependent names  temp dep       Paragraph 3      In the definition of a class template   or a member of a class template  if a   base class of the class template   depends on a template-parameter  the   base class scope is not examined   during unqualified name lookup either   at the point of definition of the   class template or member or during an   instantiation of the class template or   member    So  it looks like that when MSVC or Comeau consider the toString   member function of T performing name lookup at the call site in doToString   when the template is instantiated  that is incorrect  even though it s actually the behavior I was looking for in this case    The behavior of GCC and Digital Mars looks to be correct - in both cases the non-member toString   function is bound to the call   Rats - I thought I might have found a clever solution  instead I uncovered a couple compiler bugs        include  lt iostream gt   include  lt string gt   struct Hello       std  string toString             return  Hello             struct Generic          the following namespace keeps the toString   method out of     most everything - except the other stuff in this     compilation unit  namespace       std  string toString                 return  toString not defined              template  lt typename T gt      class optionalToStringImpl   public T           public          std  string doToString                     in theory  the name lookup for this call to                  toString   should find the toString   in                  the base class T if one exists  but if one                  doesn t exist in the base class  it ll                  find the free toString   function in                  the private namespace                                This theory works for MSVC  all versions                 from VC6 to VC9  and Comeau C    but                 does not work with MinGW 3 4 5 or                  Digital Mars 8 42n                               I m honestly not sure what the standard says                  is the correct behavior here - it s sort                  of like ADL  Argument Dependent Lookup -                  also known as Koenig Lookup  but without                 arguments  except the implied  this  pointer               return toString                        template  lt typename T gt  std  string optionalToString T  amp  obj           ugly  hacky cast        optionalToStringImpl lt T gt   temp   reinterpret cast lt optionalToStringImpl lt T gt   gt    amp obj        return temp- gt doToString         int main int argc  char  argv          Hello helloObj      Generic genericObj       std  cout  lt  lt  optionalToString  helloObj   lt  lt  std  endl      std  cout  lt  lt  optionalToString  genericObj   lt  lt  std  endl      return 0

User · Answer

Here are some usage snippets   The guts for all this are farther down  Check for member x in a given class   Could be var  func  class  union  or enum   CREATE MEMBER CHECK x   bool has x   has member x lt class to check for x gt   value    Check for member function 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 lt class to check for x gt   value    Check for member variable x   CREATE MEMBER VAR CHECK x   bool has var x   has member var x lt class to check for x gt   value    Check for member class x   CREATE MEMBER CLASS CHECK x   bool has class x   has member class x lt class to check for x gt   value    Check for member union x   CREATE MEMBER UNION CHECK x   bool has union x   has member union x lt class to check for x gt   value    Check for member enum x   CREATE MEMBER ENUM CHECK x   bool has enum x   has member enum x lt class to check for x gt   value    Check for any member function x regardless of 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 lt class to check for x gt   value    OR  CREATE MEMBER CHECKS x      Just stamps out the same macro calls as above  bool has any func x   has member func x lt class to check for x gt   value    Details and core          - 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  lt typename    Args gt  struct ambiguate   public Args           Non-variadic version of the line above    template  lt typename A  typename B gt  struct ambiguate   public A  public B      template lt typename A  typename   void gt  struct got type   std  false type      template lt typename A gt  struct got type lt A gt    std  true type       typedef A type      template lt typename T  T gt  struct sig check   std  true type      template lt typename Alias  typename AmbiguitySeed gt  struct has member       template lt typename C gt  static char    amp f decltype  amp C  value     1       template lt typename C gt  static char    amp f        2          Make sure the member name is consistently spelled the same      static assert           sizeof f lt AmbiguitySeed gt  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 lt Alias gt  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 lt typename T  typename   std  true type gt                                struct Alias   member                                                                                                                                       template lt typename T gt                                                           struct Alias   member  lt                                                            T  std  integral constant lt bool  got type lt decltype  amp T  member  gt   value gt      gt    static const decltype  amp T  member  value                                                                                                                 struct AmbiguitySeed   member   char member                                                                                                                 template lt typename T gt                                                           struct has member   member                                                        static const bool value                                                             has member lt                                                                      Alias   member lt ambiguate lt T  AmbiguitySeed   member gt  gt                             Alias   member lt AmbiguitySeed   member gt                                    gt   value                                                                                                                                                CREATE MEMBER VAR CHECK     Check for member variable with given name   define CREATE MEMBER VAR CHECK var name                                                                                                                    template lt typename T  typename   std  true type gt                                struct has member var   var name   std  false type                                                                                                          template lt typename T gt                                                           struct has member var   var name lt                                                  T                                                                               std  integral constant lt                                                          bool                                                                             std  is member function pointer lt decltype  amp T  var name  gt   value          gt                                                                           gt    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 lt typename T  typename   std  true type gt                                struct has member func   templ postfix   std  false type                                                                                                    template lt typename T gt                                                           struct has member func   templ postfix lt                                            T  std  integral constant lt                                                         bool                                                                            sig check lt func sig   amp T  func name gt   value                                gt                                                                           gt    std  true type      CREATE MEMBER CLASS CHECK     Check for member class with given name   define CREATE MEMBER CLASS CHECK class name                                                                                template lt typename T  typename   std  true type gt                struct has member class   class name   std  false type                                                                      template lt typename T gt                                           struct has member class   class name lt                              T                                                               std  integral constant lt                                          bool                                                            std  is class lt                                                   typename got type lt typename T  class name gt   type            gt   value                                                   gt                                                           gt    std  true type      CREATE MEMBER UNION CHECK     Check for member union with given name   define CREATE MEMBER UNION CHECK union name                                                                                template lt typename T  typename   std  true type gt                struct has member union   union name   std  false type                                                                      template lt typename T gt                                           struct has member union   union name lt                              T                                                               std  integral constant lt                                          bool                                                            std  is union lt                                                   typename got type lt typename T  union name gt   type            gt   value                                                   gt                                                           gt    std  true type      CREATE MEMBER ENUM CHECK     Check for member enum with given name   define CREATE MEMBER ENUM CHECK enum name                                                                                  template lt typename T  typename   std  true type gt                struct has member enum   enum name   std  false type                                                                        template lt typename T gt                                           struct has member enum   enum name lt                                T                                                               std  integral constant lt                                          bool                                                            std  is enum lt                                                    typename got type lt typename T  enum name gt   type             gt   value                                                   gt                                                           gt    std  true type      CREATE MEMBER FUNC CHECK     Check for function with given name  any signature   define CREATE MEMBER FUNC CHECK func             template lt typename T gt                               struct has member func   func                         static const bool value                                 has member   func lt T gt   value                      amp  amp   has member var   func lt T gt   value                amp  amp   has member class   func lt T gt   value              amp  amp   has member union   func lt T gt   value              amp  amp   has member enum   func lt T gt   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

User · Answer

Yes  with SFINAE you can check if a given class does provide a certain method  Here s the working code   include  lt iostream gt   struct Hello       int helloworld     return 0        struct Generic             SFINAE test template  lt typename T gt  class has helloworld       typedef char one      struct two   char x 2           template  lt typename C gt  static one test  decltype  amp C  helloworld          template  lt typename C gt  static two test            public      enum   value   sizeof test lt T gt  0      sizeof char             int main int argc  char  argv          std  cout  lt  lt  has helloworld lt Hello gt   value  lt  lt  std  endl      std  cout  lt  lt  has helloworld lt Generic gt   value  lt  lt  std  endl      return 0     I ve just tested it with Linux and gcc 4 1 4 3  I don t know if it s portable to other platforms running different compilers

User · Answer

I modified the solution provided in https   stackoverflow com a 264088 2712152 to make it a bit more general  Also since it doesn t use any of the new C  11 features we can use it with old compilers and should also work with msvc  But the compilers should enable C99 to use this since it uses variadic macros   The following macro can be used to check if a particular class has a particular typedef or not            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  lt typename T gt                                                struct name                                                            typedef char yes 1                                                  typedef char no 2                                                   template  lt typename U gt                                                struct type check                                                   template  lt typename  1 gt                                               static yes amp  chk type check lt typename  1  typedef name gt                template  lt typename gt                                                  static no amp  chk                                                      static bool const value   sizeof chk lt T gt  0      sizeof yes            The following macro can be used to check if a particular class has a particular member function or not with any given number of 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  lt typename T gt                                                struct name                                                            typedef return type  T   Sign    VA ARGS                            typedef char yes 1                                                  typedef char no 2                                                   template  lt typename U  U gt                                             struct type check                                                   template  lt typename  1 gt                                               static yes amp  chk type check lt Sign   amp  1  func gt                          template  lt typename gt                                                  static no amp  chk                                                      static bool const value   sizeof chk lt T gt  0      sizeof yes            We can use the above 2 macros to perform the checks for has typedef and has mem func as   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  lt  lt   Check Function A    lt  lt  has check function lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Check Function B    lt  lt  has check function lt B gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello Function A    lt  lt  hello check lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello Function B    lt  lt  hello check lt B gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello void Function A    lt  lt  hello void check lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Hello void Function B    lt  lt  hello void check lt B gt   value  lt  lt  std  endl    std  cout  lt  lt   Check Typedef A    lt  lt  has typedef check lt A gt   value  lt  lt  std  endl    std  cout  lt  lt   Check Typedef B    lt  lt  has typedef check lt B gt   value  lt  lt  std  endl

User · Answer

Well  this question has a long list of answers already  but I would like to emphasize the comment from Morwenn  there is a proposal for C  17 that makes it really much simpler   See N4502 for details  but as a self-contained example consider the following   This part is the constant part  put it in a header      See http   www open-std org jtc1 sc22 wg21 docs papers 2015 n4502 pdf  template  lt typename    gt  using void t   void      Primary template handles all types not supporting the operation  template  lt typename  template  lt typename gt  class  typename   void t lt  gt  gt  struct detect   std  false type         Specialization recognizes validates only types supporting the archetype  template  lt typename T  template  lt typename gt  class Op gt  struct detect lt T  Op  void t lt Op lt T gt  gt  gt    std  true type       then there is the variable part  where you specify what you are looking for  a type  a member type  a function  a member function etc     In the case of the OP   template  lt typename T gt  using toString t   decltype std  declval lt T gt    toString      template  lt typename T gt  using has toString   detect lt T  toString t gt     The following example  taken from N4502  shows a more elaborate probe      Archetypal expression for assignment operation  template  lt typename T gt  using assign t   decltype std  declval lt T amp  gt      std  declval lt T const  amp  gt         Trait corresponding to that archetype  template  lt typename T gt  using is assignable   detect lt T  assign t gt     Compared to the other implementations described above  this one is fairly simple  a reduced set of tools  void t and detect  suffices  no need for hairy macros   Besides  it was reported  see N4502  that it is measurably more efficient  compile-time and compiler memory consumption  than previous approaches   Here is a live example   It works fine with Clang  but unfortunately  GCC versions before 5 1 followed a different interpretation of the C  11 standard which caused void t to not work as expected   Yakk already provided the work-around  use the following definition of void t  void t in parameter list works but not as return type     if   GNUC    lt  5  amp  amp    defined   clang      https   stackoverflow com a 28967049 1353549 template  lt typename    gt  struct voider     using type   void     template  lt typename   Ts gt  using void t   typename voider lt Ts    gt   type   else template  lt typename    gt  using void t   void   endif

User · Answer

MSVC has the   if exists and   if not exists keywords  Doc   Together with the typeof-SFINAE approach of Nicola I could create a check for GCC and MSVC like the OP looked for   Update  Source can be found Here

User · Answer

Here is my version that handles all possible member function overloads with arbitrary arity  including template member functions  possibly with default arguments  It distinguishes 3 mutually exclusive scenarios when making a member function call to some class type  with given arg types   1  valid  or  2  ambiguous  or  3  non-viable  Example usage    include  lt string gt   include  lt vector gt   HAS MEM bar  HAS MEM FUN CALL bar   struct test      void bar int      void bar double      void bar int double       template  lt  typename T  gt     typename std  enable if lt  not std  is integral lt T gt   value  gt   type    bar const T amp   int 0        template  lt  typename T  gt     typename std  enable if lt  std  is integral lt T gt   value  gt   type    bar const std  vector lt T gt  amp   T         template  lt  typename T  gt     int bar const std  string amp   int         Now you can use it like this   int main int argc  const char   argv         static assert  has mem bar lt test gt   value            static assert  has valid mem fun call bar lt test char const  long  gt   value           static assert  has valid mem fun call bar lt test std  string amp  long  gt   value            static assert  has valid mem fun call bar lt test std  vector lt int gt   int   gt   value           static assert  has no viable mem fun call bar lt test std  vector lt double gt   double   gt   value            static assert  has valid mem fun call bar lt test int  gt   value           static assert  std  is same lt void result of mem fun call bar lt test int  gt   type gt   value            static assert  has valid mem fun call bar lt test int double  gt   value           static assert  not has valid mem fun call bar lt test int double int  gt   value            static assert  not has ambiguous mem fun call bar lt test double  gt   value           static assert  has ambiguous mem fun call bar lt test unsigned  gt   value            static assert  has viable mem fun call bar lt test unsigned  gt   value           static assert  has viable mem fun call bar lt test int  gt   value            static assert  has no viable mem fun call bar lt test void  gt   value            return 0      Here is the code  written in c  11  however  you can easily port it  with minor tweaks  to non-c  11 that has typeof extensions  e g  gcc   You can replace the HAS MEM macro with your own    pragma once   if   cplusplus  gt   201103   include  lt utility gt   include  lt type traits gt    define HAS MEM mem                                                                                                                                                                                               template  lt  typename T  gt                                                                                  struct has mem   mem                                                                                                                                                                                              struct yes                                                                                             struct no                                                                                                                                                                                                     struct ambiguate seed   char mem                                                                       template  lt  typename U  gt  struct ambiguate   U  ambiguate seed                                                                                                                                                  template  lt  typename U  typename   decltype  amp U  mem   gt  static constexpr no  test int                    template  lt  typename                                  gt  static constexpr yes test                                                                                                                               static bool constexpr value   std  is same lt decltype test lt  ambiguate lt T gt   gt  0   yes gt   value               typedef std  integral constant lt bool value gt     type                                                         define HAS MEM FUN CALL memfun                                                                                                                                                                                   template  lt  typename Signature  gt                                                                          struct has valid mem fun call   memfun                                                                                                                                                                         template  lt  typename T  typename    Args  gt                                                                struct has valid mem fun call   memfun lt  T Args      gt                                                                                                                                                               struct yes                                                                                             struct no                                                                                                                                                                                                     template  lt  typename U  bool   has mem   memfun lt U gt   value  gt                                              struct impl                                                                                                                                                                                                      template  lt  typename V  typename   decltype std  declval lt V gt    memfun std  declval lt Args gt          gt         struct test result   using type   yes                                                                                                                                                                         template  lt  typename V  gt  static constexpr typename test result lt V gt   type test int                        template  lt  typename    gt  static constexpr                            no test                                                                                                                                   static constexpr bool value   std  is same lt decltype test lt U gt  0   yes gt   value                            using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                   template  lt  typename U  gt                                                                                 struct impl lt U false gt    std  false type                                                                                                                                                                        static constexpr bool value   impl lt T gt   value                                                           using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct has ambiguous mem fun call   memfun                                                                                                                                                                     template  lt  typename T  typename    Args  gt                                                                struct has ambiguous mem fun call   memfun lt  T Args      gt                                                                                                                                                           struct ambiguate seed   void memfun                                                                                                                                                                           template  lt  class U  bool   has mem   memfun lt U gt   value  gt                                                 struct ambiguate   U  ambiguate seed                                                                                                                                                                            using ambiguate seed  memfun                                                                           using U  memfun                                                                                                                                                                                                                                                                                                    template  lt  class U  gt                                                                                    struct ambiguate lt U false gt    ambiguate seed                                                                                                                                                                    static constexpr bool value   not has valid mem fun call   memfun lt  ambiguate lt T gt  Args      gt   value      using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct has viable mem fun call   memfun                                                                                                                                                                        template  lt  typename T  typename    Args  gt                                                                struct has viable mem fun call   memfun lt  T Args      gt                                                                                                                                                              static constexpr bool value   has valid mem fun call   memfun lt T Args     gt   value                                                  or has ambiguous mem fun call   memfun lt T Args     gt   value                   using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct has no viable mem fun call   memfun                                                                                                                                                                     template  lt  typename T  typename    Args  gt                                                                struct has no viable mem fun call   memfun  lt  T Args      gt                                                                                                                                                          static constexpr bool value   not has viable mem fun call   memfun lt T Args     gt   value                  using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct result of mem fun call   memfun                                                                                                                                                                         template  lt  typename T  typename    Args  gt                                                                struct result of mem fun call   memfun lt  T Args      gt                                                                                                                                                               using type   decltype std  declval lt T gt    memfun std  declval lt Args gt                                          endif

User · Answer

How about this solution    include  lt type traits gt   template  lt typename U  typename   void gt  struct hasToString   std  false type       template  lt typename U gt  struct hasToString lt U    typename std  enable if lt bool sizeof  amp U  toString   gt   type  gt    std  true type

User · Answer

Now this was a nice little puzzle - great question   Here s an alternative to Nicola Bonelli s solution that does not rely on the non-standard typeof operator   Unfortunately  it does not work on GCC  MinGW  3 4 5 or Digital Mars 8 42n  but it does work on all versions of MSVC  including VC6  and on Comeau C     The longer comment block has the details on how it works  or is supposed to work    As it says  I m not sure which behavior is standards compliant - I d welcome commentary on that     update - 7 Nov 2008   It looks like while this code is syntactically correct  the behavior that MSVC and Comeau C   show does not follow the standard  thanks to Leon Timmermans and litb for pointing me in the right direction    The C  03 standard says the following      14 6 2 Dependent names  temp dep       Paragraph 3      In the definition of a class template   or a member of a class template  if a   base class of the class template   depends on a template-parameter  the   base class scope is not examined   during unqualified name lookup either   at the point of definition of the   class template or member or during an   instantiation of the class template or   member    So  it looks like that when MSVC or Comeau consider the toString   member function of T performing name lookup at the call site in doToString   when the template is instantiated  that is incorrect  even though it s actually the behavior I was looking for in this case    The behavior of GCC and Digital Mars looks to be correct - in both cases the non-member toString   function is bound to the call   Rats - I thought I might have found a clever solution  instead I uncovered a couple compiler bugs        include  lt iostream gt   include  lt string gt   struct Hello       std  string toString             return  Hello             struct Generic          the following namespace keeps the toString   method out of     most everything - except the other stuff in this     compilation unit  namespace       std  string toString                 return  toString not defined              template  lt typename T gt      class optionalToStringImpl   public T           public          std  string doToString                     in theory  the name lookup for this call to                  toString   should find the toString   in                  the base class T if one exists  but if one                  doesn t exist in the base class  it ll                  find the free toString   function in                  the private namespace                                This theory works for MSVC  all versions                 from VC6 to VC9  and Comeau C    but                 does not work with MinGW 3 4 5 or                  Digital Mars 8 42n                               I m honestly not sure what the standard says                  is the correct behavior here - it s sort                  of like ADL  Argument Dependent Lookup -                  also known as Koenig Lookup  but without                 arguments  except the implied  this  pointer               return toString                        template  lt typename T gt  std  string optionalToString T  amp  obj           ugly  hacky cast        optionalToStringImpl lt T gt   temp   reinterpret cast lt optionalToStringImpl lt T gt   gt    amp obj        return temp- gt doToString         int main int argc  char  argv          Hello helloObj      Generic genericObj       std  cout  lt  lt  optionalToString  helloObj   lt  lt  std  endl      std  cout  lt  lt  optionalToString  genericObj   lt  lt  std  endl      return 0

User · Answer

Now this was a nice little puzzle - great question   Here s an alternative to Nicola Bonelli s solution that does not rely on the non-standard typeof operator   Unfortunately  it does not work on GCC  MinGW  3 4 5 or Digital Mars 8 42n  but it does work on all versions of MSVC  including VC6  and on Comeau C     The longer comment block has the details on how it works  or is supposed to work    As it says  I m not sure which behavior is standards compliant - I d welcome commentary on that     update - 7 Nov 2008   It looks like while this code is syntactically correct  the behavior that MSVC and Comeau C   show does not follow the standard  thanks to Leon Timmermans and litb for pointing me in the right direction    The C  03 standard says the following      14 6 2 Dependent names  temp dep       Paragraph 3      In the definition of a class template   or a member of a class template  if a   base class of the class template   depends on a template-parameter  the   base class scope is not examined   during unqualified name lookup either   at the point of definition of the   class template or member or during an   instantiation of the class template or   member    So  it looks like that when MSVC or Comeau consider the toString   member function of T performing name lookup at the call site in doToString   when the template is instantiated  that is incorrect  even though it s actually the behavior I was looking for in this case    The behavior of GCC and Digital Mars looks to be correct - in both cases the non-member toString   function is bound to the call   Rats - I thought I might have found a clever solution  instead I uncovered a couple compiler bugs        include  lt iostream gt   include  lt string gt   struct Hello       std  string toString             return  Hello             struct Generic          the following namespace keeps the toString   method out of     most everything - except the other stuff in this     compilation unit  namespace       std  string toString                 return  toString not defined              template  lt typename T gt      class optionalToStringImpl   public T           public          std  string doToString                     in theory  the name lookup for this call to                  toString   should find the toString   in                  the base class T if one exists  but if one                  doesn t exist in the base class  it ll                  find the free toString   function in                  the private namespace                                This theory works for MSVC  all versions                 from VC6 to VC9  and Comeau C    but                 does not work with MinGW 3 4 5 or                  Digital Mars 8 42n                               I m honestly not sure what the standard says                  is the correct behavior here - it s sort                  of like ADL  Argument Dependent Lookup -                  also known as Koenig Lookup  but without                 arguments  except the implied  this  pointer               return toString                        template  lt typename T gt  std  string optionalToString T  amp  obj           ugly  hacky cast        optionalToStringImpl lt T gt   temp   reinterpret cast lt optionalToStringImpl lt T gt   gt    amp obj        return temp- gt doToString         int main int argc  char  argv          Hello helloObj      Generic genericObj       std  cout  lt  lt  optionalToString  helloObj   lt  lt  std  endl      std  cout  lt  lt  optionalToString  genericObj   lt  lt  std  endl      return 0

User · Answer

template lt class T gt  auto optionalToString T  obj  - gt decltype  obj- gt toString    std  string            return obj- gt toString       template lt class T gt  auto optionalToString T  obj  - gt decltype  std  string            throw  Error

User · Answer

Well  this question has a long list of answers already  but I would like to emphasize the comment from Morwenn  there is a proposal for C  17 that makes it really much simpler   See N4502 for details  but as a self-contained example consider the following   This part is the constant part  put it in a header      See http   www open-std org jtc1 sc22 wg21 docs papers 2015 n4502 pdf  template  lt typename    gt  using void t   void      Primary template handles all types not supporting the operation  template  lt typename  template  lt typename gt  class  typename   void t lt  gt  gt  struct detect   std  false type         Specialization recognizes validates only types supporting the archetype  template  lt typename T  template  lt typename gt  class Op gt  struct detect lt T  Op  void t lt Op lt T gt  gt  gt    std  true type       then there is the variable part  where you specify what you are looking for  a type  a member type  a function  a member function etc     In the case of the OP   template  lt typename T gt  using toString t   decltype std  declval lt T gt    toString      template  lt typename T gt  using has toString   detect lt T  toString t gt     The following example  taken from N4502  shows a more elaborate probe      Archetypal expression for assignment operation  template  lt typename T gt  using assign t   decltype std  declval lt T amp  gt      std  declval lt T const  amp  gt         Trait corresponding to that archetype  template  lt typename T gt  using is assignable   detect lt T  assign t gt     Compared to the other implementations described above  this one is fairly simple  a reduced set of tools  void t and detect  suffices  no need for hairy macros   Besides  it was reported  see N4502  that it is measurably more efficient  compile-time and compiler memory consumption  than previous approaches   Here is a live example   It works fine with Clang  but unfortunately  GCC versions before 5 1 followed a different interpretation of the C  11 standard which caused void t to not work as expected   Yakk already provided the work-around  use the following definition of void t  void t in parameter list works but not as return type     if   GNUC    lt  5  amp  amp    defined   clang      https   stackoverflow com a 28967049 1353549 template  lt typename    gt  struct voider     using type   void     template  lt typename   Ts gt  using void t   typename voider lt Ts    gt   type   else template  lt typename    gt  using void t   void   endif

User · Answer

Though this question is two years old  I ll dare to add my answer  Hopefully it will clarify the previous  indisputably excellent  solution  I took the very helpful answers of Nicola Bonelli and Johannes Schaub and merged them into a solution that is  IMHO  more readable  clear and does not require the typeof extension   template  lt class Type gt  class TypeHasToString          This type won t compile if the second template parameter isn t of type T         so I can put a function pointer type in the first parameter and the function        itself in the second thus checking that the function has a specific signature      template  lt typename T  T gt  struct TypeCheck       typedef char Yes      typedef long No          A helper struct to hold the declaration of the function pointer         Change it if the function signature changes      template  lt typename T gt  struct ToString               typedef void  T   fptr                 template  lt typename T gt  static Yes HasToString TypeCheck lt  typename ToString lt T gt   fptr   amp T  toString  gt         template  lt typename T gt  static No  HasToString        public      static bool const value    sizeof HasToString lt Type gt  0      sizeof Yes         I checked it with gcc 4 1 2  The credit goes mainly to Nicola Bonelli and Johannes Schaub  so give them a vote up if my answer helps you

User · Answer

C   allows SFINAE to be used for this  notice that with C  11 features this is simplier because it supports extended SFINAE on nearly arbitrary expressions - the below was crafted to work with common C  03 compilers     define HAS MEM FUNC func  name                                               template lt typename T  typename Sign gt                                        struct name                                                                   typedef char yes 1                                                        typedef char no  2                                                        template  lt typename U  U gt  struct type check                                template  lt typename  1 gt  static yes  amp chk type check lt Sign   amp  1  func  gt                template  lt typename    gt  static no   amp chk                                    static bool const value   sizeof chk lt T gt  0      sizeof yes                 the above template and macro tries to instantiate a template  giving it a member function pointer type  and the actual member function pointer  If the types to not fit  SFINAE causes the template to be ignored  Usage like this   HAS MEM FUNC toString  has to string    template lt typename T gt  void doSomething        if has to string lt T  std  string T       gt   value                   else                      But note that you cannot just call that toString function in that if branch  since the compiler will check for validity in both branches  that would fail for cases the function doesnt exist  One way is to use SFINAE once again  enable if can be gotten from boost too    template lt bool C  typename T   void gt  struct enable if     typedef T type      template lt typename T gt  struct enable if lt false  T gt        HAS MEM FUNC toString  has to string    template lt typename T gt   typename enable if lt has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T has toString           return t- gt toString       template lt typename T gt   typename enable if lt  has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T doesnt have toString           return  T  toString   does not exist        Have fun using it  The advantage of it is that it also works for overloaded member functions  and also for const member functions  remember using  std  string T       const as the member function pointer type then

User · Answer

I ve been looking a method that allows to somehow to not tie structure name has member to name of a class  member  Actually  this would be simpler if lambda can be allowed in unevaluated expression  this is forbidden by standard   i e  has member lt ClassName  SOME MACRO WITH DECLTYPE member name  gt   include  lt iostream gt   include  lt list gt   include  lt type traits gt    define LAMBDA FOR MEMBER NAME NAME     auto object instance  - gt  decltype  amp  decltype object instance   NAME       template lt typename T gt  struct TypeGetter       constexpr TypeGetter     default      constexpr TypeGetter T         using type   T       constexpr auto getValue                 return std  declval lt type gt               template lt typename T  typename LambdaExpressionT gt  struct has member       using lambda prototype   LambdaExpressionT         SFINAE     template lt class ValueT  class   void gt      struct is void t deducable   std  false type          template lt class ValueT gt      struct is void t deducable lt ValueT          std  void t lt decltype std  declval lt lambda prototype gt    std  declval lt ValueT gt      gt  gt    std  true type          static constexpr bool value   is void t deducable lt T gt   value      struct SimpleClass       int field      void method          int main void           const auto helpful lambda   LAMBDA FOR MEMBER NAME field       using member field   decltype helpful lambda       std  cout  lt  lt  has member lt SimpleClass  member field gt   value       const auto lambda   LAMBDA FOR MEMBER NAME method       using member method   decltype lambda       std  cout  lt  lt  has member lt SimpleClass  member method gt   value

User · Answer

My take  to universally determine if something is callable without making verbose type traits for each and every one  or using experimental features  or long code  template lt typename Callable  typename    Args  typename   decltype declval lt Callable gt    declval lt Args gt         gt  std  true type isCallableImpl Callable  Args       return        std  false type isCallableImpl        return        template lt typename    Args  typename Callable gt  constexpr bool isCallable Callable callable        return decltype isCallableImpl callable  declval lt Args gt               Usage  constexpr auto TO STRING TEST      auto in  - gt  decltype in toString      return        constexpr bool TO STRING WORKS   isCallable lt T gt  TO STRING TEST

User · Answer

An example using SFINAE and template partial specialization  by writing a Has foo concept check     include  lt type traits gt  struct A     struct B  int foo int a  int b      struct C void foo int a  int b      struct D int foo       struct E  public B        available in C  17 onwards as part of  lt type traits gt  template lt typename    gt  using void t   void   template lt typename T  typename   void gt  struct Has foo  std  false type     template lt typename T gt   struct Has foo lt T  void t lt      std  enable if t lt          std  is same lt              int               decltype std  declval lt T gt    foo  int 0   int 0            gt   value      gt   gt  gt   std  true type      static assert not Has foo lt A gt   value   A does not have a foo    static assert Has foo lt B gt   value   B has a foo    static assert not Has foo lt C gt   value   C has a foo with the wrong return      static assert not Has foo lt D gt   value   D has a foo with the wrong arguments      static assert Has foo lt E gt   value   E has a foo since it inherits from B

User · Answer

With C   20 you can write the following   template lt typename T gt  concept has toString   requires const T amp  t        t toString        template lt typename T gt  std  string optionalToString const T amp  obj        if constexpr  has toString lt T gt           return obj toString        else         return  toString not defined

User · Answer

This question is old  but with C  11 we got a new way to check for a functions existence  or existence of any non-type member  really   relying on SFINAE again   template lt class T gt  auto serialize imp std  ostream amp  os  T const amp  obj  int      - gt  decltype os  lt  lt  obj  void        os  lt  lt  obj     template lt class T gt  auto serialize imp std  ostream amp  os  T const amp  obj  long      - gt  decltype obj stream os   void        obj stream os      template lt class T gt  auto serialize std  ostream amp  os  T const amp  obj      - gt  decltype serialize imp os  obj  0   void        serialize imp os  obj  0       Now onto some explanations  First thing  I use expression SFINAE to exclude the serialize  imp  functions from overload resolution  if the first expression inside decltype isn t valid  aka  the function doesn t exist    The void   is used to make the return type of all those functions void   The 0 argument is used to prefer the os  lt  lt  obj overload if both are available  literal 0 is of type int and as such the first overload is a better match      Now  you probably want a trait to check if a function exists  Luckily  it s easy to write that  Note  though  that you need to write a trait yourself for every different function name you might want    include  lt type traits gt   template lt class gt  struct sfinae true   std  true type     namespace detail    template lt class T  class A0 gt    static auto test stream int        - gt  sfinae true lt decltype std  declval lt T gt    stream std  declval lt A0 gt      gt     template lt class  class A0 gt    static auto test stream long  - gt  std  false type       detail    template lt class T  class Arg gt  struct has stream   decltype detail  test stream lt T  Arg gt  0        Live example   And on to explanations  First  sfinae true is a helper type  and it basically amounts to the same as writing decltype void std  declval lt T gt    stream a0    std  true type     The advantage is simply that it s shorter  Next  the struct has stream   decltype      inherits from either std  true type or std  false type in the end  depending on whether the decltype check in test stream fails or not  Last  std  declval gives you a  value  of whatever type you pass  without you needing to know how you can construct it  Note that this is only possible inside an unevaluated context  such as decltype  sizeof and others     Note that decltype is not necessarily needed  as sizeof  and all unevaluated contexts  got that enhancement  It s just that decltype already delivers a type and as such is just cleaner  Here s a sizeof version of one of the overloads   template lt class T gt  void serialize imp std  ostream amp  os  T const amp  obj  int      int    sizeof  os  lt  lt  obj  0     0      os  lt  lt  obj      The int and long parameters are still there for the same reason  The array pointer is used to provide a context where sizeof can be used

User · Answer

Strange nobody suggested the following nice trick I saw once on this very site    template  lt class T gt  struct has foo       struct S   void foo              struct derived   S  T          template  lt typename V  V gt  struct W          template  lt typename X gt      char   amp test W lt void  X         amp X  foo gt      1        template  lt typename gt      char   amp test       2        static const bool value   sizeof test lt derived gt  0      1       You have to make sure T is a class  It seems that ambiguity in the lookup of foo is a substitution failure  I made it work on gcc  not sure if it is standard though

User · Answer

This is what type traits are there for  Unfortunately  they have to be defined manually  In your case  imagine the following   template  lt typename T gt  struct response trait       static bool const has tostring   false      template  lt  gt  struct response trait lt your type with tostring gt        static bool const has tostring   true

User · Answer

I had a similar problem   A template class that may be derived from few base classes  some that have a certain member and others that do not   I solved it similarly to the  typeof   Nicola Bonelli s  answer  but with decltype so it compiles and runs correctly on MSVS    include  lt iostream gt   include  lt string gt   struct Generic         struct HasMember      HasMember      a 1        int  a             SFINAE test template  lt typename T gt  class S   public T   public    std  string foo  std  string b          return foo2 lt T gt  b 0        protected    template  lt typename T gt  std  string foo2  std  string b  decltype  T   a           return b   std  to string T   a         template  lt typename T gt  std  string foo2  std  string b               return b    No           int main int argc  char  argv        S lt HasMember gt  d1    S lt Generic gt  d2     std  cout  lt  lt  d1 foo  HasMember      lt  lt  std  endl    std  cout  lt  lt  d2 foo  Generic      lt  lt  std  endl    return 0

User · Answer

A simple solution for C  11   template lt class T gt  auto optionalToString T  obj   - gt  decltype   obj- gt toString            return     obj- gt toString      auto optionalToString      - gt  string       return  toString not defined       Update  3 years later   and this is untested   To test for the existence  I think this will work   template lt class T gt  constexpr auto test has toString method T  obj   - gt  decltype   obj- gt toString     std  true type           return     obj- gt toString      constexpr auto test has toString method      - gt  std  false type       return  toString not defined

User · Answer

I know that this question is years old  but I think it would useful for people like me to have a more complete updated answer that also works for const overloaded methods such as std  vector lt  gt   begin  Based on that answer and that answer from my follow up question  here s a more complete answer  Note that this will only work with C  11 and higher   include  lt iostream gt   include  lt vector gt   class EmptyClass     template  lt typename T gt  class has begin       private      has begin     delete           struct one   char x 1          struct two   char x 2           template  lt typename C gt  static one test  decltype void std  declval lt C  amp  gt    begin               template  lt typename C gt  static two test            public      static constexpr bool value   sizeof test lt T gt  0      sizeof one           int main int argc  char  argv          std  cout  lt  lt  std  boolalpha      std  cout  lt  lt   quot vector lt int gt   begin   exists   quot   lt  lt  has begin lt std  vector lt int gt  gt   value  lt  lt  std  endl      std  cout  lt  lt   quot EmptyClass  begin   exists   quot   lt  lt  has begin lt EmptyClass gt   value  lt  lt  std  endl      return 0     Or the shorter version   include  lt iostream gt   include  lt vector gt   class EmptyClass     template  lt typename T  typename   void gt  struct has begin   std  false type      template  lt typename T gt  struct has begin lt T  decltype void std  declval lt T  amp  gt    begin     gt    std  true type      int main int argc  char  argv          std  cout  lt  lt  std  boolalpha      std  cout  lt  lt   quot vector lt int gt   begin   exists   quot   lt  lt  has begin lt std  vector lt int gt  gt   value  lt  lt  std  endl      std  cout  lt  lt   quot EmptyClass exists   quot   lt  lt  has begin lt EmptyClass gt   value  lt  lt  std  endl     Note that here a complete sample call must be provided  This means that if we tested for the resize method s existence then we would have put resize 0   Deep magic explanation  The first answer posted of this question used test  decltype  amp C  helloworld     however this is problematic when the method it is testing is ambiguous due const overloading  thus making the substitution attempt fail  To solve this ambiguity we use a void statement which can take any parameters because it is always translated into a noop and thus the ambiguity is nullified and the call is valid as long as the method exists  has begin lt T  decltype void std  declval lt T  amp  gt    begin     gt   Here s what s happening in order  We use std  declval lt T  amp  gt    to create a callable value for which begin can then be called  After that the value of begin is passed as a parameter to a void statement  We then retrieve the type of that void expression using the builtin decltype so that it can be used as a template type argument  If begin doesn t exist then the substitution is invalid and as per SFINAE the other declaration is used instead

User · Answer

C  20 - requires expressions With C  20 come concepts and assorted tools such as requires expressions which are a built-in way to check for a function existence  With them you could rewrite your optionalToString function as follows  template lt class T gt  std  string optionalToString T  obj        constexpr bool has toString   requires const T amp  t            t toString                if constexpr  has toString          return obj- gt toString        else         return  quot toString not defined quot      Pre-C  20 - Detection toolkit N4502 proposes a detection toolkit for inclusion into the C  17 standard library that eventually made it into the library fundamentals TS v2  It most likely won t ever get into the standard because it has been subsumed by requires expressions since  but it still solves the problem in a somewhat elegant manner  The toolkit introduces some metafunctions  including std  is detected which can be used to easily write type or function detection metafunctions on the top of it  Here is how you could use it  template lt typename T gt  using toString t   decltype  std  declval lt T amp  gt    toString       template lt typename T gt  constexpr bool has toString   std  is detected v lt toString t  T gt    Note that the example above is untested  The detection toolkit is not available in standard libraries yet but the proposal contains a full implementation that you can easily copy if you really need it  It plays nice with the C  17 feature if constexpr  template lt class T gt  std  string optionalToString T  obj        if constexpr  has toString lt T gt           return obj- gt toString        else         return  quot toString not defined quot      C  14 - Boost Hana Boost Hana apparently builds upon this specific example and provides a solution for C  14 in its documentation  so I m going to quote it directly         Hana provides a is valid function that can be combined with C  14 generic lambdas to obtain a much cleaner implementation of the same thing  auto has toString   hana  is valid    auto amp  amp  obj  - gt  decltype obj toString           This leaves us with a function object has toString which returns whether the given expression is valid on the argument we pass to it  The result is returned as an IntegralConstant  so constexpr-ness is not an issue here because the result of the function is represented as a type anyway  Now  in addition to being less verbose  that s a one liner    the intent is much clearer  Other benefits are the fact that has toString can be passed to higher order algorithms and it can also be defined at function scope  so there is no need to pollute the namespace scope with implementation details   Boost TTI Another somewhat idiomatic toolkit to perform such a check - even though less elegant - is Boost TTI  introduced in Boost 1 54 0  For your example  you would have to use the macro BOOST TTI HAS MEMBER FUNCTION  Here is how you could use it   include  lt boost tti has member function hpp gt      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 lt T  std  string gt   value   Then  you could use the bool to create a SFINAE check  Explanation The macro BOOST TTI HAS MEMBER FUNCTION generates the metafunction has member function toString which takes the checked type as its first template parameter  The second template parameter corresponds to the return type of the member function  and the following parameters correspond to the types of the function s parameters  The member value contains true if the class T has a member function std  string toString    Alternatively  has member function toString can take a member function pointer as a template parameter  Therefore  it is possible to replace has member function toString lt T  std  string gt   value by has member function toString lt std  string T       gt   value

User · Answer

The generic template that can be used for checking if some  feature  is supported by the type    include  lt type traits gt   template  lt template  lt typename gt  class TypeChecker  typename Type gt  struct is supported          these structs are used to recognize which version        of the two functions was chosen during overload resolution     struct supported         struct not supported             this overload of chk will be ignored by SFINAE principle        if TypeChecker lt Type  gt  is invalid type     template  lt typename Type  gt      static supported chk typename std  decay lt TypeChecker lt Type  gt  gt   type             ellipsis has the lowest conversion rank  so this overload will be        chosen during overload resolution only if the template overload above is ignored     template  lt typename Type  gt      static not supported chk               if the template overload of chk is chosen during        overload resolution then the feature is supported        if the ellipses overload is chosen the the feature is not supported     static constexpr bool value   std  is same lt decltype chk lt Type gt  nullptr   supported gt   value       The template that checks whether there is a method foo that is compatible with signature double const char       if T doesn t have foo method with the signature that allows to compile the bellow    expression then instantiating this template is Substitution Failure  SF     which Is Not An Error  INAE  if this happens during overload resolution template  lt typename T gt  using has foo   decltype double std  declval lt T gt    foo std  declval lt const char  gt          Examples     types that support has foo struct struct1   double foo const char                     exact signature match struct struct2   int    foo const std  string  amp str         compatible signature struct struct3   float  foo                                compatible ellipsis signature struct struct4   template  lt typename T gt                   int    foo T t                            compatible template signature     types that do not support has foo struct struct5   void        foo const char          returns void struct struct6   std  string foo const char          std  string can t be converted to double struct struct7   double      foo       int           const char  can t be converted to int  struct struct8   double      bar const char          there is no foo method  int main         std  cout  lt  lt  std  boolalpha       std  cout  lt  lt  is supported lt has foo  int     gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  double  gt   value  lt  lt  std  endl     false      std  cout  lt  lt  is supported lt has foo  struct1 gt   value  lt  lt  std  endl     true     std  cout  lt  lt  is supported lt has foo  struct2 gt   value  lt  lt  std  endl     true     std  cout  lt  lt  is supported lt has foo  struct3 gt   value  lt  lt  std  endl     true     std  cout  lt  lt  is supported lt has foo  struct4 gt   value  lt  lt  std  endl     true      std  cout  lt  lt  is supported lt has foo  struct5 gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  struct6 gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  struct7 gt   value  lt  lt  std  endl     false     std  cout  lt  lt  is supported lt has foo  struct8 gt   value  lt  lt  std  endl     false      return 0      http   coliru stacked-crooked com a 83c6a631ed42cea4

User · Answer

A simple solution for C  11   template lt class T gt  auto optionalToString T  obj   - gt  decltype   obj- gt toString            return     obj- gt toString      auto optionalToString      - gt  string       return  toString not defined       Update  3 years later   and this is untested   To test for the existence  I think this will work   template lt class T gt  constexpr auto test has toString method T  obj   - gt  decltype   obj- gt toString     std  true type           return     obj- gt toString      constexpr auto test has toString method      - gt  std  false type       return  toString not defined

User · Answer

MSVC has the   if exists and   if not exists keywords  Doc   Together with the typeof-SFINAE approach of Nicola I could create a check for GCC and MSVC like the OP looked for   Update  Source can be found Here

User · Answer

C   allows SFINAE to be used for this  notice that with C  11 features this is simplier because it supports extended SFINAE on nearly arbitrary expressions - the below was crafted to work with common C  03 compilers     define HAS MEM FUNC func  name                                               template lt typename T  typename Sign gt                                        struct name                                                                   typedef char yes 1                                                        typedef char no  2                                                        template  lt typename U  U gt  struct type check                                template  lt typename  1 gt  static yes  amp chk type check lt Sign   amp  1  func  gt                template  lt typename    gt  static no   amp chk                                    static bool const value   sizeof chk lt T gt  0      sizeof yes                 the above template and macro tries to instantiate a template  giving it a member function pointer type  and the actual member function pointer  If the types to not fit  SFINAE causes the template to be ignored  Usage like this   HAS MEM FUNC toString  has to string    template lt typename T gt  void doSomething        if has to string lt T  std  string T       gt   value                   else                      But note that you cannot just call that toString function in that if branch  since the compiler will check for validity in both branches  that would fail for cases the function doesnt exist  One way is to use SFINAE once again  enable if can be gotten from boost too    template lt bool C  typename T   void gt  struct enable if     typedef T type      template lt typename T gt  struct enable if lt false  T gt        HAS MEM FUNC toString  has to string    template lt typename T gt   typename enable if lt has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T has toString           return t- gt toString       template lt typename T gt   typename enable if lt  has to string lt T                      std  string T       gt   value  std  string gt   type doSomething T   t          something when T doesnt have toString           return  T  toString   does not exist        Have fun using it  The advantage of it is that it also works for overloaded member functions  and also for const member functions  remember using  std  string T       const as the member function pointer type then

User · Answer

I wrote an answer to this in another thread that  unlike the solutions above  also checks inherited member functions   SFINAE to check for inherited member functions  Here are some example from that solution   Example1   We are checking for a member with the following signature   T  const iterator begin   const  template lt class T gt  struct has const begin       typedef char   amp Yes  1       typedef char   amp No  2        template lt class U gt       static Yes test U const   data                       typename std  enable if lt std  is same lt                               typename U  const iterator                                decltype data- gt begin                         gt   value gt   type     0       static No test           static const bool value   sizeof Yes     sizeof has const begin  test  typename std  remove reference lt T gt   type  0         Please notice that it even checks the constness of the method  and works with primitive types  as well   I mean has const begin lt int gt   value is false and doesn t cause a compile-time error     Example 2  Now we are looking for the signature  void foo MyClass amp   unsigned   template lt class T gt  struct has foo       typedef char   amp Yes  1       typedef char   amp No  2        template lt class U gt      static Yes test U   data  MyClass  arg1   0                      typename std  enable if lt std  is void lt                               decltype data- gt foo  arg1  1u                        gt   value gt   type     0       static No test           static const bool value   sizeof Yes     sizeof has foo  test  typename std  remove reference lt T gt   type  0         Please notice that MyClass doesn t has to be default constructible or to satisfy any special concept  The technique works with template members  as well   I am eagerly waiting opinions regarding this

User · Answer

Probably not as good as other examples  but this is what I came up with for C  11  This works for picking overloaded methods  template  lt typename    Args gt  struct Pack       define Proxy T    T  amp     int    nullptr     template  lt typename Class  typename ArgPack  typename   nullptr t gt  struct HasFoo       enum   value   false        template  lt typename Class  typename    Args gt  struct HasFoo lt      Class      Pack lt Args    gt       decltype  void  Proxy Class  foo Proxy Args        nullptr  gt        enum   value   true        Example usage struct Object       int foo int n            return n     if SOME CONDITION     int foo int n  char c    return n   c     endif     template  lt bool has foo int char gt  struct Dispatcher   template  lt  gt  struct Dispatcher lt false gt        template  lt typename Object gt      static int exec Object  amp object  int n  char c                return object foo n    c            template  lt  gt  struct Dispatcher lt true gt        template  lt typename Object gt      static int exec Object  amp object  int n  char c                return object foo n  c             int runExample         using Args   Pack lt int  char gt       enum   has overload   HasFoo lt Object  Args gt   value        Object object      return Dispatcher lt has overload gt   exec object  100   a

User · Answer

This question is old  but with C  11 we got a new way to check for a functions existence  or existence of any non-type member  really   relying on SFINAE again   template lt class T gt  auto serialize imp std  ostream amp  os  T const amp  obj  int      - gt  decltype os  lt  lt  obj  void        os  lt  lt  obj     template lt class T gt  auto serialize imp std  ostream amp  os  T const amp  obj  long      - gt  decltype obj stream os   void        obj stream os      template lt class T gt  auto serialize std  ostream amp  os  T const amp  obj      - gt  decltype serialize imp os  obj  0   void        serialize imp os  obj  0       Now onto some explanations  First thing  I use expression SFINAE to exclude the serialize  imp  functions from overload resolution  if the first expression inside decltype isn t valid  aka  the function doesn t exist    The void   is used to make the return type of all those functions void   The 0 argument is used to prefer the os  lt  lt  obj overload if both are available  literal 0 is of type int and as such the first overload is a better match      Now  you probably want a trait to check if a function exists  Luckily  it s easy to write that  Note  though  that you need to write a trait yourself for every different function name you might want    include  lt type traits gt   template lt class gt  struct sfinae true   std  true type     namespace detail    template lt class T  class A0 gt    static auto test stream int        - gt  sfinae true lt decltype std  declval lt T gt    stream std  declval lt A0 gt      gt     template lt class  class A0 gt    static auto test stream long  - gt  std  false type       detail    template lt class T  class Arg gt  struct has stream   decltype detail  test stream lt T  Arg gt  0        Live example   And on to explanations  First  sfinae true is a helper type  and it basically amounts to the same as writing decltype void std  declval lt T gt    stream a0    std  true type     The advantage is simply that it s shorter  Next  the struct has stream   decltype      inherits from either std  true type or std  false type in the end  depending on whether the decltype check in test stream fails or not  Last  std  declval gives you a  value  of whatever type you pass  without you needing to know how you can construct it  Note that this is only possible inside an unevaluated context  such as decltype  sizeof and others     Note that decltype is not necessarily needed  as sizeof  and all unevaluated contexts  got that enhancement  It s just that decltype already delivers a type and as such is just cleaner  Here s a sizeof version of one of the overloads   template lt class T gt  void serialize imp std  ostream amp  os  T const amp  obj  int      int    sizeof  os  lt  lt  obj  0     0      os  lt  lt  obj      The int and long parameters are still there for the same reason  The array pointer is used to provide a context where sizeof can be used

User · Answer

This is a C  11 solution for the general problem if  If I did X  would it compile    template lt class gt  struct type sink   typedef void type        consumes a type  and makes it  void  template lt class T gt  using type sink t   typename type sink lt T gt   type  template lt class T  class void gt  struct has to string   std  false type       template lt class T gt  struct has to string lt    T    type sink t lt  decltype  std  declval lt T gt    toString      gt   gt   std  true type       Trait has to string such that has to string lt T gt   value is true if and only if T has a method  toString that can be invoked with 0 arguments in this context   Next  I d use tag dispatching   namespace details     template lt class T gt    std  string optionalToString helper T  obj  std  true type   has to string          return obj- gt toString          template lt class T gt    std  string optionalToString helper T  obj  std  false type   has to string          return  toString not defined         template lt class T gt  std  string optionalToString T  obj      return details  optionalToString helper  obj  has to string lt T gt           which tends to be more maintainable than complex SFINAE expressions   You can write these traits with a macro if you find yourself doing it alot  but they are relatively simple  a few lines each  so maybe not worth it    define MAKE CODE TRAIT  TRAIT NAME          template lt class T  class void gt  struct TRAIT NAME   std  false type       template lt class T gt  struct TRAIT NAME lt  T  type sink t lt  decltype    VA ARGS      gt   gt   std  true type       what the above does is create a macro MAKE CODE TRAIT   You pass it the name of the trait you want  and some code that can test the type T   Thus   MAKE CODE TRAIT  has to string  std  declval lt T gt    toString       creates the above traits class   As an aside  the above technique is part of what MS calls  expression SFINAE   and their 2013 compiler fails pretty hard   Note that in C  1y the following syntax is possible   template lt class T gt  std  string optionalToString T  obj      return compiled if lt  has to string  gt   obj    amp   auto amp  amp  obj        return obj toString          compiled else    amp         return  toString not defined             which is an inline compilation conditional branch that abuses lots of C   features   Doing so is probably not worth it  as the benefit  of code being inline  is not worth the cost  of next to nobody understanding how it works   but the existence of that above solution may be of interest

User · Answer

The standard C   solution presented here by litb will not work as expected if the method happens to be defined in a base class    For a solution that handles this situation refer to    In Russian   http   www rsdn ru forum message 2759773 1 aspx   English Translation by Roman Perepelitsa    http   groups google com group comp lang c   moderated tree browse frm thread 4f7c7a96f9afbe44 c95a7b4c645e449f pli 1   It is insanely clever  However one issue with this solutiion is that gives compiler errors if the type being tested is one that cannot be used as a base class  e g  primitive types   In Visual Studio  I noticed that if working with method having no arguments  an extra pair of redundant      needs to be inserted around the argments to deduce     in the sizeof expression

User · Answer

I had a similar problem   A template class that may be derived from few base classes  some that have a certain member and others that do not   I solved it similarly to the  typeof   Nicola Bonelli s  answer  but with decltype so it compiles and runs correctly on MSVS    include  lt iostream gt   include  lt string gt   struct Generic         struct HasMember      HasMember      a 1        int  a             SFINAE test template  lt typename T gt  class S   public T   public    std  string foo  std  string b          return foo2 lt T gt  b 0        protected    template  lt typename T gt  std  string foo2  std  string b  decltype  T   a           return b   std  to string T   a         template  lt typename T gt  std  string foo2  std  string b               return b    No           int main int argc  char  argv        S lt HasMember gt  d1    S lt Generic gt  d2     std  cout  lt  lt  d1 foo  HasMember      lt  lt  std  endl    std  cout  lt  lt  d2 foo  Generic      lt  lt  std  endl    return 0

User · Answer

template lt class T gt  auto optionalToString T  obj  - gt decltype  obj- gt toString    std  string            return obj- gt toString       template lt class T gt  auto optionalToString T  obj  - gt decltype  std  string            throw  Error

User · Answer

You can skip all the metaprogramming in C  14  and just write this using fit  conditional from the Fit library   template lt class T gt  std  string optionalToString T  x        return fit  conditional             auto  obj  - gt  decltype obj- gt toString      return obj- gt toString                  auto     return  toString not defined           x       You can also create the function directly from the lambdas as well   FIT STATIC LAMBDA FUNCTION optionalToString    fit  conditional         auto  obj  - gt  decltype obj- gt toString    std  string      return obj- gt toString              auto   - gt  std  string   return  toString not defined          However  if you are using a compiler that doesn t support generic lambdas  you will have to write separate function objects   struct withToString       template lt class T gt      auto operator   T  obj  const - gt  decltype obj- gt toString    std  string                  return obj- gt toString              struct withoutToString       template lt class T gt      std  string operator   T   const               return  toString not defined             FIT STATIC FUNCTION optionalToString    fit  conditional      withToString        withoutToString

User · Answer

Though this question is two years old  I ll dare to add my answer  Hopefully it will clarify the previous  indisputably excellent  solution  I took the very helpful answers of Nicola Bonelli and Johannes Schaub and merged them into a solution that is  IMHO  more readable  clear and does not require the typeof extension   template  lt class Type gt  class TypeHasToString          This type won t compile if the second template parameter isn t of type T         so I can put a function pointer type in the first parameter and the function        itself in the second thus checking that the function has a specific signature      template  lt typename T  T gt  struct TypeCheck       typedef char Yes      typedef long No          A helper struct to hold the declaration of the function pointer         Change it if the function signature changes      template  lt typename T gt  struct ToString               typedef void  T   fptr                 template  lt typename T gt  static Yes HasToString TypeCheck lt  typename ToString lt T gt   fptr   amp T  toString  gt         template  lt typename T gt  static No  HasToString        public      static bool const value    sizeof HasToString lt Type gt  0      sizeof Yes         I checked it with gcc 4 1 2  The credit goes mainly to Nicola Bonelli and Johannes Schaub  so give them a vote up if my answer helps you

User · Answer

I ve been looking a method that allows to somehow to not tie structure name has member to name of a class  member  Actually  this would be simpler if lambda can be allowed in unevaluated expression  this is forbidden by standard   i e  has member lt ClassName  SOME MACRO WITH DECLTYPE member name  gt   include  lt iostream gt   include  lt list gt   include  lt type traits gt    define LAMBDA FOR MEMBER NAME NAME     auto object instance  - gt  decltype  amp  decltype object instance   NAME       template lt typename T gt  struct TypeGetter       constexpr TypeGetter     default      constexpr TypeGetter T         using type   T       constexpr auto getValue                 return std  declval lt type gt               template lt typename T  typename LambdaExpressionT gt  struct has member       using lambda prototype   LambdaExpressionT         SFINAE     template lt class ValueT  class   void gt      struct is void t deducable   std  false type          template lt class ValueT gt      struct is void t deducable lt ValueT          std  void t lt decltype std  declval lt lambda prototype gt    std  declval lt ValueT gt      gt  gt    std  true type          static constexpr bool value   is void t deducable lt T gt   value      struct SimpleClass       int field      void method          int main void           const auto helpful lambda   LAMBDA FOR MEMBER NAME field       using member field   decltype helpful lambda       std  cout  lt  lt  has member lt SimpleClass  member field gt   value       const auto lambda   LAMBDA FOR MEMBER NAME method       using member method   decltype lambda       std  cout  lt  lt  has member lt SimpleClass  member method gt   value

User · Answer

You can skip all the metaprogramming in C  14  and just write this using fit  conditional from the Fit library   template lt class T gt  std  string optionalToString T  x        return fit  conditional             auto  obj  - gt  decltype obj- gt toString      return obj- gt toString                  auto     return  toString not defined           x       You can also create the function directly from the lambdas as well   FIT STATIC LAMBDA FUNCTION optionalToString    fit  conditional         auto  obj  - gt  decltype obj- gt toString    std  string      return obj- gt toString              auto   - gt  std  string   return  toString not defined          However  if you are using a compiler that doesn t support generic lambdas  you will have to write separate function objects   struct withToString       template lt class T gt      auto operator   T  obj  const - gt  decltype obj- gt toString    std  string                  return obj- gt toString              struct withoutToString       template lt class T gt      std  string operator   T   const               return  toString not defined             FIT STATIC FUNCTION optionalToString    fit  conditional      withToString        withoutToString

User · Answer

Here are some usage snippets   The guts for all this are farther down  Check for member x in a given class   Could be var  func  class  union  or enum   CREATE MEMBER CHECK x   bool has x   has member x lt class to check for x gt   value    Check for member function 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 lt class to check for x gt   value    Check for member variable x   CREATE MEMBER VAR CHECK x   bool has var x   has member var x lt class to check for x gt   value    Check for member class x   CREATE MEMBER CLASS CHECK x   bool has class x   has member class x lt class to check for x gt   value    Check for member union x   CREATE MEMBER UNION CHECK x   bool has union x   has member union x lt class to check for x gt   value    Check for member enum x   CREATE MEMBER ENUM CHECK x   bool has enum x   has member enum x lt class to check for x gt   value    Check for any member function x regardless of 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 lt class to check for x gt   value    OR  CREATE MEMBER CHECKS x      Just stamps out the same macro calls as above  bool has any func x   has member func x lt class to check for x gt   value    Details and core          - 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  lt typename    Args gt  struct ambiguate   public Args           Non-variadic version of the line above    template  lt typename A  typename B gt  struct ambiguate   public A  public B      template lt typename A  typename   void gt  struct got type   std  false type      template lt typename A gt  struct got type lt A gt    std  true type       typedef A type      template lt typename T  T gt  struct sig check   std  true type      template lt typename Alias  typename AmbiguitySeed gt  struct has member       template lt typename C gt  static char    amp f decltype  amp C  value     1       template lt typename C gt  static char    amp f        2          Make sure the member name is consistently spelled the same      static assert           sizeof f lt AmbiguitySeed gt  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 lt Alias gt  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 lt typename T  typename   std  true type gt                                struct Alias   member                                                                                                                                       template lt typename T gt                                                           struct Alias   member  lt                                                            T  std  integral constant lt bool  got type lt decltype  amp T  member  gt   value gt      gt    static const decltype  amp T  member  value                                                                                                                 struct AmbiguitySeed   member   char member                                                                                                                 template lt typename T gt                                                           struct has member   member                                                        static const bool value                                                             has member lt                                                                      Alias   member lt ambiguate lt T  AmbiguitySeed   member gt  gt                             Alias   member lt AmbiguitySeed   member gt                                    gt   value                                                                                                                                                CREATE MEMBER VAR CHECK     Check for member variable with given name   define CREATE MEMBER VAR CHECK var name                                                                                                                    template lt typename T  typename   std  true type gt                                struct has member var   var name   std  false type                                                                                                          template lt typename T gt                                                           struct has member var   var name lt                                                  T                                                                               std  integral constant lt                                                          bool                                                                             std  is member function pointer lt decltype  amp T  var name  gt   value          gt                                                                           gt    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 lt typename T  typename   std  true type gt                                struct has member func   templ postfix   std  false type                                                                                                    template lt typename T gt                                                           struct has member func   templ postfix lt                                            T  std  integral constant lt                                                         bool                                                                            sig check lt func sig   amp T  func name gt   value                                gt                                                                           gt    std  true type      CREATE MEMBER CLASS CHECK     Check for member class with given name   define CREATE MEMBER CLASS CHECK class name                                                                                template lt typename T  typename   std  true type gt                struct has member class   class name   std  false type                                                                      template lt typename T gt                                           struct has member class   class name lt                              T                                                               std  integral constant lt                                          bool                                                            std  is class lt                                                   typename got type lt typename T  class name gt   type            gt   value                                                   gt                                                           gt    std  true type      CREATE MEMBER UNION CHECK     Check for member union with given name   define CREATE MEMBER UNION CHECK union name                                                                                template lt typename T  typename   std  true type gt                struct has member union   union name   std  false type                                                                      template lt typename T gt                                           struct has member union   union name lt                              T                                                               std  integral constant lt                                          bool                                                            std  is union lt                                                   typename got type lt typename T  union name gt   type            gt   value                                                   gt                                                           gt    std  true type      CREATE MEMBER ENUM CHECK     Check for member enum with given name   define CREATE MEMBER ENUM CHECK enum name                                                                                  template lt typename T  typename   std  true type gt                struct has member enum   enum name   std  false type                                                                        template lt typename T gt                                           struct has member enum   enum name lt                                T                                                               std  integral constant lt                                          bool                                                            std  is enum lt                                                    typename got type lt typename T  enum name gt   type             gt   value                                                   gt                                                           gt    std  true type      CREATE MEMBER FUNC CHECK     Check for function with given name  any signature   define CREATE MEMBER FUNC CHECK func             template lt typename T gt                               struct has member func   func                         static const bool value                                 has member   func lt T gt   value                      amp  amp   has member var   func lt T gt   value                amp  amp   has member class   func lt T gt   value              amp  amp   has member union   func lt T gt   value              amp  amp   has member enum   func lt T gt   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

User · Answer

Here is my version that handles all possible member function overloads with arbitrary arity  including template member functions  possibly with default arguments  It distinguishes 3 mutually exclusive scenarios when making a member function call to some class type  with given arg types   1  valid  or  2  ambiguous  or  3  non-viable  Example usage    include  lt string gt   include  lt vector gt   HAS MEM bar  HAS MEM FUN CALL bar   struct test      void bar int      void bar double      void bar int double       template  lt  typename T  gt     typename std  enable if lt  not std  is integral lt T gt   value  gt   type    bar const T amp   int 0        template  lt  typename T  gt     typename std  enable if lt  std  is integral lt T gt   value  gt   type    bar const std  vector lt T gt  amp   T         template  lt  typename T  gt     int bar const std  string amp   int         Now you can use it like this   int main int argc  const char   argv         static assert  has mem bar lt test gt   value            static assert  has valid mem fun call bar lt test char const  long  gt   value           static assert  has valid mem fun call bar lt test std  string amp  long  gt   value            static assert  has valid mem fun call bar lt test std  vector lt int gt   int   gt   value           static assert  has no viable mem fun call bar lt test std  vector lt double gt   double   gt   value            static assert  has valid mem fun call bar lt test int  gt   value           static assert  std  is same lt void result of mem fun call bar lt test int  gt   type gt   value            static assert  has valid mem fun call bar lt test int double  gt   value           static assert  not has valid mem fun call bar lt test int double int  gt   value            static assert  not has ambiguous mem fun call bar lt test double  gt   value           static assert  has ambiguous mem fun call bar lt test unsigned  gt   value            static assert  has viable mem fun call bar lt test unsigned  gt   value           static assert  has viable mem fun call bar lt test int  gt   value            static assert  has no viable mem fun call bar lt test void  gt   value            return 0      Here is the code  written in c  11  however  you can easily port it  with minor tweaks  to non-c  11 that has typeof extensions  e g  gcc   You can replace the HAS MEM macro with your own    pragma once   if   cplusplus  gt   201103   include  lt utility gt   include  lt type traits gt    define HAS MEM mem                                                                                                                                                                                               template  lt  typename T  gt                                                                                  struct has mem   mem                                                                                                                                                                                              struct yes                                                                                             struct no                                                                                                                                                                                                     struct ambiguate seed   char mem                                                                       template  lt  typename U  gt  struct ambiguate   U  ambiguate seed                                                                                                                                                  template  lt  typename U  typename   decltype  amp U  mem   gt  static constexpr no  test int                    template  lt  typename                                  gt  static constexpr yes test                                                                                                                               static bool constexpr value   std  is same lt decltype test lt  ambiguate lt T gt   gt  0   yes gt   value               typedef std  integral constant lt bool value gt     type                                                         define HAS MEM FUN CALL memfun                                                                                                                                                                                   template  lt  typename Signature  gt                                                                          struct has valid mem fun call   memfun                                                                                                                                                                         template  lt  typename T  typename    Args  gt                                                                struct has valid mem fun call   memfun lt  T Args      gt                                                                                                                                                               struct yes                                                                                             struct no                                                                                                                                                                                                     template  lt  typename U  bool   has mem   memfun lt U gt   value  gt                                              struct impl                                                                                                                                                                                                      template  lt  typename V  typename   decltype std  declval lt V gt    memfun std  declval lt Args gt          gt         struct test result   using type   yes                                                                                                                                                                         template  lt  typename V  gt  static constexpr typename test result lt V gt   type test int                        template  lt  typename    gt  static constexpr                            no test                                                                                                                                   static constexpr bool value   std  is same lt decltype test lt U gt  0   yes gt   value                            using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                   template  lt  typename U  gt                                                                                 struct impl lt U false gt    std  false type                                                                                                                                                                        static constexpr bool value   impl lt T gt   value                                                           using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct has ambiguous mem fun call   memfun                                                                                                                                                                     template  lt  typename T  typename    Args  gt                                                                struct has ambiguous mem fun call   memfun lt  T Args      gt                                                                                                                                                           struct ambiguate seed   void memfun                                                                                                                                                                           template  lt  class U  bool   has mem   memfun lt U gt   value  gt                                                 struct ambiguate   U  ambiguate seed                                                                                                                                                                            using ambiguate seed  memfun                                                                           using U  memfun                                                                                                                                                                                                                                                                                                    template  lt  class U  gt                                                                                    struct ambiguate lt U false gt    ambiguate seed                                                                                                                                                                    static constexpr bool value   not has valid mem fun call   memfun lt  ambiguate lt T gt  Args      gt   value      using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct has viable mem fun call   memfun                                                                                                                                                                        template  lt  typename T  typename    Args  gt                                                                struct has viable mem fun call   memfun lt  T Args      gt                                                                                                                                                              static constexpr bool value   has valid mem fun call   memfun lt T Args     gt   value                                                  or has ambiguous mem fun call   memfun lt T Args     gt   value                   using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct has no viable mem fun call   memfun                                                                                                                                                                     template  lt  typename T  typename    Args  gt                                                                struct has no viable mem fun call   memfun  lt  T Args      gt                                                                                                                                                          static constexpr bool value   not has viable mem fun call   memfun lt T Args     gt   value                  using type   std  integral constant lt bool  value gt                                                                                                                                                                                                                                                                     template  lt  typename Signature  gt                                                                          struct result of mem fun call   memfun                                                                                                                                                                         template  lt  typename T  typename    Args  gt                                                                struct result of mem fun call   memfun lt  T Args      gt                                                                                                                                                               using type   decltype std  declval lt T gt    memfun std  declval lt Args gt                                          endif

User · Answer

The standard C   solution presented here by litb will not work as expected if the method happens to be defined in a base class    For a solution that handles this situation refer to    In Russian   http   www rsdn ru forum message 2759773 1 aspx   English Translation by Roman Perepelitsa    http   groups google com group comp lang c   moderated tree browse frm thread 4f7c7a96f9afbe44 c95a7b4c645e449f pli 1   It is insanely clever  However one issue with this solutiion is that gives compiler errors if the type being tested is one that cannot be used as a base class  e g  primitive types   In Visual Studio  I noticed that if working with method having no arguments  an extra pair of redundant      needs to be inserted around the argments to deduce     in the sizeof expression

[c++] Templated check for the existence of a class member function?

Examples related to c++

Examples related to templates

Examples related to template-meta-programming

Examples related to sfinae