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<class T> std::string optionalToString(T* obj) { if (FUNCTION_EXISTS(T->toString)) return obj->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.
Yes, with SFINAE you can check if a given class does provide a certain method. Here's the working code:
#include <iostream> struct Hello { int helloworld() { return 0; } }; struct Generic {}; // SFINAE test template <typename T> class has_helloworld { typedef char one; struct two { char x[2]; }; template <typename C> static one test( decltype(&C::helloworld) ) ; template <typename C> static two test(...); public: enum { value = sizeof(test<T>(0)) == sizeof(char) }; }; int main(int argc, char *argv[]) { std::cout << has_helloworld<Hello>::value << std::endl; std::cout << has_helloworld<Generic>::value << std::endl; return 0; } 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.
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<class T> auto serialize_imp(std::ostream& os, T const& obj, int) -> decltype(os << obj, void()) { os << obj; } template<class T> auto serialize_imp(std::ostream& os, T const& obj, long) -> decltype(obj.stream(os), void()) { obj.stream(os); } template<class T> auto serialize(std::ostream& os, T const& obj) -> 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 << 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 <type_traits> template<class> struct sfinae_true : std::true_type{}; namespace detail{ template<class T, class A0> static auto test_stream(int) -> sfinae_true<decltype(std::declval<T>().stream(std::declval<A0>()))>; template<class, class A0> static auto test_stream(long) -> std::false_type; } // detail:: template<class T, class Arg> struct has_stream : decltype(detail::test_stream<T, Arg>(0)){}; And on to explanations. First, sfinae_true is a helper type, and it basically amounts to the same as writing decltype(void(std::declval<T>().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<class T> void serialize_imp(std::ostream& os, T const& obj, int, int(*)[sizeof((os << obj),0)] = 0) { os << 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.
decltype over sizeof is also that a temporary is not introduced by specially crafted rules for function calls (so you don't have to have access rights to the destructor of the return type and won't cause an implicit instantiation if the return type is a class template instantiation).
static_assert(has_stream<X, char>() == true, "fail X"); will compile and not assert because char is convertable to int, so if that behavior is not wanted and want that all argument types match i dont know how that can be achieved?
sfinae_false counterpart and used a return type on the long override that detected for the presence of a destructor. This excluded types that were still incomplete or didn't have public destructors. Excluding non-public destructors was acceptable for me.requires expressionsWith 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<class T> std::string optionalToString(T* obj) { constexpr bool has_toString = requires(const T& t) { t.toString(); }; if constexpr (has_toString) return obj->toString(); else return "toString not defined"; } 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<typename T> using toString_t = decltype( std::declval<T&>().toString() ); template<typename T> constexpr bool has_toString = std::is_detected_v<toString_t, T>; 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<class T> std::string optionalToString(T* obj) { if constexpr (has_toString<T>) return obj->toString(); else return "toString not defined"; } 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_validfunction 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&& obj) -> decltype(obj.toString()) { });This leaves us with a function object
has_toStringwhich returns whether the given expression is valid on the argument we pass to it. The result is returned as anIntegralConstant, 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 thathas_toStringcan 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.
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 <boost/tti/has_member_function.hpp> // Generate the metafunction BOOST_TTI_HAS_MEMBER_FUNCTION(toString) // Check whether T has a member function toString // which takes no parameter and returns a std::string constexpr bool foo = has_member_function_toString<T, std::string>::value; 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<T, std::string>::value by has_member_function_toString<std::string T::* ()>::value.
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<typename T, typename Sign> \ struct name { \ typedef char yes[1]; \ typedef char no [2]; \ template <typename U, U> struct type_check; \ template <typename _1> static yes &chk(type_check<Sign, &_1::func > *); \ template <typename > static no &chk(...); \ static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \ } 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 do not fit, SFINAE causes the template to be ignored. Usage like this:
HAS_MEM_FUNC(toString, has_to_string); template<typename T> void doSomething() { if(has_to_string<T, std::string(T::*)()>::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 doesn't exist. One way is to use SFINAE once again (enable_if can be obtained from boost, too):
template<bool C, typename T = void> struct enable_if { typedef T type; }; template<typename T> struct enable_if<false, T> { }; HAS_MEM_FUNC(toString, has_to_string); template<typename T> typename enable_if<has_to_string<T, std::string(T::*)()>::value, std::string>::type doSomething(T * t) { /* something when T has toString ... */ return t->toString(); } template<typename T> typename enable_if<!has_to_string<T, std::string(T::*)()>::value, std::string>::type doSomething(T * t) { /* something when T doesnt have toString ... */ return "T::toString() does not exist."; } 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!).
type_check is used to ensure that the signatures agree exactly. Is there a way to make it so that it will match any method which could be called in the manner that a method with signature Sign could be called? (E.g. if Sign = std::string(T::*)(), allow std::string T::toString(int default = 42, ...) to match.)
T must not be a primitive type, because the pointer-to-method-of-T declaration is not subject to SFINAE and will error out for any non-class T. IMO the easiest solution is to combine with is_class check from boost.
toString is a templated function?
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 <class Type> 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 <typename T, T> 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 <typename T> struct ToString { typedef void (T::*fptr)(); }; template <typename T> static Yes HasToString(TypeCheck< typename ToString<T>::fptr, &T::toString >*); template <typename T> static No HasToString(...); public: static bool const value = (sizeof(HasToString<Type>(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 :)
toString. If you write a generic library, that wishes to work with any class out there (think of something like boost), then requiring the user to define additional specializations of some obscure templates might be unacceptable. Sometimes it's preferable to write a very complicated code to keep the public interface as simple as it can be.
ToString class template. IIUC, it's to avoid instantiation errors when Type is not a class, right?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 <typename...> using void_t = void; // Primary template handles all types not supporting the operation. template <typename, template <typename> class, typename = void_t<>> struct detect : std::false_type {}; // Specialization recognizes/validates only types supporting the archetype. template <typename T, template <typename> class Op> struct detect<T, Op, void_t<Op<T>>> : 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 <typename T> using toString_t = decltype(std::declval<T>().toString()); template <typename T> using has_toString = detect<T, toString_t>; The following example, taken from N4502, shows a more elaborate probe:
// Archetypal expression for assignment operation. template <typename T> using assign_t = decltype(std::declval<T&>() = std::declval<T const &>()) // Trait corresponding to that archetype. template <typename T> using is_assignable = detect<T, assign_t>; 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__ < 5 && ! defined __clang__ // https://stackoverflow.com/a/28967049/1353549 template <typename...> struct voider { using type = void; }; template <typename...Ts> using void_t = typename voider<Ts...>::type; #else template <typename...> using void_t = void; #endif 
A simple solution for C++11:
template<class T> auto optionalToString(T* obj) -> decltype( obj->toString() ) { return obj->toString(); } auto optionalToString(...) -> string { return "toString not defined"; } Update, 3 years later: (and this is untested). To test for the existence, I think this will work:
template<class T> constexpr auto test_has_toString_method(T* obj) -> decltype( obj->toString() , std::true_type{} ) { return obj->toString(); } constexpr auto test_has_toString_method(...) -> std::false_type { return "toString not defined"; } 
template<typename> before the variadic overload: it was not getting considered for resolution.
const char* but the return type is std::false_type?This is what type traits are there for. Unfortunately, they have to be defined manually. In your case, imagine the following:
template <typename T> struct response_trait { static bool const has_tostring = false; }; template <> struct response_trait<your_type_with_tostring> { static bool const has_tostring = true; } 
&T::x or implicitly by binding it to a reference).Here is the most concise way I found in C++20, which is very close from your question:
template<class T> std::string optionalToString(T* obj) { if constexpr (requires { obj->toString(); }) return obj->toString(); else return "toString not defined"; } See it live on godbolt: https://gcc.godbolt.org/z/5jb1d93Ms
Yet another way to do it in C++17 (inspired by boost:hana).
This solution does not require has_something<T> SFINAE type traits classes.
/// @file has_something.h /// The `has_member` macro implementation #pragma once #include <type_traits> template<typename T, typename F> constexpr auto has_member_impl(F&& f) -> decltype(f(std::declval<T>()), true) { return true; } template<typename> constexpr bool has_member_impl(...) { return false; } #define has_member(V, EXPR) \ has_member_impl<decltype(V)>( [](auto&& obj)->decltype(obj.EXPR){} ) /// @file test.cpp #include "has_something.h" #include <iostream> #include <string> struct Example { int Foo; void Bar() {} std::string toString() { return "Hello from Example::toString()!"; } }; struct Example2 { int X; }; template<class T> std::string optionalToString(T& obj) { if constexpr(has_member(obj, toString())) return obj.toString(); else return "toString not defined"; } int main() { Example obj; static_assert(has_member(obj, Foo), "Example class must have Foo member"); static_assert(has_member(obj, Bar()), "Example class must have Bar() member function"); static_assert(!has_member(obj, ZFoo), "Example class must not have ZFoo member."); static_assert(!has_member(obj, ZBar()), "Example class must not have ZBar() member function"); Example e1; Example2 e2; std::cout << "e1: " << optionalToString(e1) << "\n"; std::cout << "e2: " << optionalToString(e2) << "\n"; } 
has_member macro. If you use it inside the class to check the private member existence, then yes, it does work. If you use that macro outside of class, for example in some function, then macro does not work. But, if you add this function to the friend list, then it works.
constexpr lambda which is introduced in C++17This is a C++11 solution for the general problem if "If I did X, would it compile?"
template<class> struct type_sink { typedef void type; }; // consumes a type, and makes it `void` template<class T> using type_sink_t = typename type_sink<T>::type; template<class T, class=void> struct has_to_string : std::false_type {}; \ template<class T> struct has_to_string< T, type_sink_t< decltype( std::declval<T>().toString() ) > >: std::true_type {}; Trait has_to_string such that has_to_string<T>::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<class T> std::string optionalToString_helper(T* obj, std::true_type /*has_to_string*/) { return obj->toString(); } template<class T> std::string optionalToString_helper(T* obj, std::false_type /*has_to_string*/) { return "toString not defined"; } } template<class T> std::string optionalToString(T* obj) { return details::optionalToString_helper( obj, has_to_string<T>{} ); } 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<class T, class=void> struct TRAIT_NAME : std::false_type {}; \ template<class T> struct TRAIT_NAME< T, type_sink_t< decltype( __VA_ARGS__ ) > >: std::true_type {}; 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<T>().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<class T> std::string optionalToString(T* obj) { return compiled_if< has_to_string >(*obj, [&](auto&& obj) { return obj.toString(); }) *compiled_else ([&]{ return "toString not defined"; }); } 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.
has_to_string however.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<class_to_check_for_x>::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<class_to_check_for_x>::value; Check for member variable x:
CREATE_MEMBER_VAR_CHECK(x); bool has_var_x = has_member_var_x<class_to_check_for_x>::value; Check for member class x:
CREATE_MEMBER_CLASS_CHECK(x); bool has_class_x = has_member_class_x<class_to_check_for_x>::value; Check for member union x:
CREATE_MEMBER_UNION_CHECK(x); bool has_union_x = has_member_union_x<class_to_check_for_x>::value; Check for member enum x:
CREATE_MEMBER_ENUM_CHECK(x); bool has_enum_x = has_member_enum_x<class_to_check_for_x>::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<class_to_check_for_x>::value; OR
CREATE_MEMBER_CHECKS(x); //Just stamps out the same macro calls as above. bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value; 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 <typename... Args> struct ambiguate : public Args... {}; //Non-variadic version of the line above. //template <typename A, typename B> struct ambiguate : public A, public B {}; template<typename A, typename = void> struct got_type : std::false_type {}; template<typename A> struct got_type<A> : std::true_type { typedef A type; }; template<typename T, T> struct sig_check : std::true_type {}; template<typename Alias, typename AmbiguitySeed> struct has_member { template<typename C> static char ((&f(decltype(&C::value))))[1]; template<typename C> static char ((&f(...)))[2]; //Make sure the member name is consistently spelled the same. static_assert( (sizeof(f<AmbiguitySeed>(0)) == 1) , "Member name specified in AmbiguitySeed is different from member name specified in Alias, or wrong Alias/AmbiguitySeed has been specified." ); static bool const value = sizeof(f<Alias>(0)) == 2; }; Macros (El Diablo!):
CREATE_MEMBER_CHECK:
//Check for any member with given name, whether var, func, class, union, enum. #define CREATE_MEMBER_CHECK(member) \ \ template<typename T, typename = std::true_type> \ struct Alias_##member; \ \ template<typename T> \ struct Alias_##member < \ T, std::integral_constant<bool, got_type<decltype(&T::member)>::value> \ > { static const decltype(&T::member) value; }; \ \ struct AmbiguitySeed_##member { char member; }; \ \ template<typename T> \ struct has_member_##member { \ static const bool value \ = has_member< \ Alias_##member<ambiguate<T, AmbiguitySeed_##member>> \ , Alias_##member<AmbiguitySeed_##member> \ >::value \ ; \ } CREATE_MEMBER_VAR_CHECK:
//Check for member variable with given name. #define CREATE_MEMBER_VAR_CHECK(var_name) \ \ template<typename T, typename = std::true_type> \ struct has_member_var_##var_name : std::false_type {}; \ \ template<typename T> \ struct has_member_var_##var_name< \ T \ , std::integral_constant< \ bool \ , !std::is_member_function_pointer<decltype(&T::var_name)>::value \ > \ > : std::true_type {} CREATE_MEMBER_FUNC_SIG_CHECK:
//Check for member function with given name AND signature. #define CREATE_MEMBER_FUNC_SIG_CHECK(func_name, func_sig, templ_postfix) \ \ template<typename T, typename = std::true_type> \ struct has_member_func_##templ_postfix : std::false_type {}; \ \ template<typename T> \ struct has_member_func_##templ_postfix< \ T, std::integral_constant< \ bool \ , sig_check<func_sig, &T::func_name>::value \ > \ > : std::true_type {} CREATE_MEMBER_CLASS_CHECK:
//Check for member class with given name. #define CREATE_MEMBER_CLASS_CHECK(class_name) \ \ template<typename T, typename = std::true_type> \ struct has_member_class_##class_name : std::false_type {}; \ \ template<typename T> \ struct has_member_class_##class_name< \ T \ , std::integral_constant< \ bool \ , std::is_class< \ typename got_type<typename T::class_name>::type \ >::value \ > \ > : std::true_type {} CREATE_MEMBER_UNION_CHECK:
//Check for member union with given name. #define CREATE_MEMBER_UNION_CHECK(union_name) \ \ template<typename T, typename = std::true_type> \ struct has_member_union_##union_name : std::false_type {}; \ \ template<typename T> \ struct has_member_union_##union_name< \ T \ , std::integral_constant< \ bool \ , std::is_union< \ typename got_type<typename T::union_name>::type \ >::value \ > \ > : std::true_type {} CREATE_MEMBER_ENUM_CHECK:
//Check for member enum with given name. #define CREATE_MEMBER_ENUM_CHECK(enum_name) \ \ template<typename T, typename = std::true_type> \ struct has_member_enum_##enum_name : std::false_type {}; \ \ template<typename T> \ struct has_member_enum_##enum_name< \ T \ , std::integral_constant< \ bool \ , std::is_enum< \ typename got_type<typename T::enum_name>::type \ >::value \ > \ > : std::true_type {} CREATE_MEMBER_FUNC_CHECK:
//Check for function with given name, any signature. #define CREATE_MEMBER_FUNC_CHECK(func) \ template<typename T> \ struct has_member_func_##func { \ static const bool value \ = has_member_##func<T>::value \ && !has_member_var_##func<T>::value \ && !has_member_class_##func<T>::value \ && !has_member_union_##func<T>::value \ && !has_member_enum_##func<T>::value \ ; \ } CREATE_MEMBER_CHECKS:
//Create all the checks for one member. Does NOT include func sig checks. #define CREATE_MEMBER_CHECKS(member) \ CREATE_MEMBER_CHECK(member); \ CREATE_MEMBER_VAR_CHECK(member); \ CREATE_MEMBER_CLASS_CHECK(member); \ CREATE_MEMBER_UNION_CHECK(member); \ CREATE_MEMBER_ENUM_CHECK(member); \ CREATE_MEMBER_FUNC_CHECK(member) 
sig_check<func_sig, &T::func_name> to free function checking : sig_check<func_sig, &func_name> it fails to build with "undeclared identifier" mentioning the name of the function we want to check ? because I would expect SFINAE to make it NOT an error, it does just that for members, why not for free functions ?
With C++ 20 you can write the following:
template<typename T> concept has_toString = requires(const T& t) { t.toString(); }; template<typename T> std::string optionalToString(const T& obj) { if constexpr (has_toString<T>) return obj.toString(); else return "toString not defined"; } 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:
We are checking for a member with the following signature: T::const_iterator begin() const
template<class T> struct has_const_begin { typedef char (&Yes)[1]; typedef char (&No)[2]; template<class U> static Yes test(U const * data, typename std::enable_if<std::is_same< typename U::const_iterator, decltype(data->begin()) >::value>::type * = 0); static No test(...); static const bool value = sizeof(Yes) == sizeof(has_const_begin::test((typename std::remove_reference<T>::type*)0)); }; Please notice that it even checks the constness of the method, and works with primitive types, as well. (I mean has_const_begin<int>::value is false and doesn't cause a compile-time error.)
Now we are looking for the signature: void foo(MyClass&, unsigned)
template<class T> struct has_foo { typedef char (&Yes)[1]; typedef char (&No)[2]; template<class U> static Yes test(U * data, MyClass* arg1 = 0, typename std::enable_if<std::is_void< decltype(data->foo(*arg1, 1u)) >::value>::type * = 0); static No test(...); static const bool value = sizeof(Yes) == sizeof(has_foo::test((typename std::remove_reference<T>::type*)0)); }; 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.
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.
struct g { void f(); private: void f(int); }; because one of the functions is private (this is because the code does using g::f;, which makes it fail if any f is not accessible).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 <iostream> #include <string> 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 <typename T> 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 <typename T> std::string optionalToString(T & obj) { // ugly, hacky cast... optionalToStringImpl<T>* temp = reinterpret_cast<optionalToStringImpl<T>*>( &obj); return temp->doToString(); } int main(int argc, char *argv[]) { Hello helloObj; Generic genericObj; std::cout << optionalToString( helloObj) << std::endl; std::cout << optionalToString( genericObj) << std::endl; return 0; } 
An example using SFINAE and template partial specialization, by writing a Has_foo concept check:
#include <type_traits> 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 <type_traits> template<typename...> using void_t = void; template<typename T, typename = void> struct Has_foo: std::false_type{}; template<typename T> struct Has_foo<T, void_t< std::enable_if_t< std::is_same< int, decltype(std::declval<T>().foo((int)0, (int)0)) >::value > >>: std::true_type{}; static_assert(not Has_foo<A>::value, "A does not have a foo"); static_assert(Has_foo<B>::value, "B has a foo"); static_assert(not Has_foo<C>::value, "C has a foo with the wrong return. "); static_assert(not Has_foo<D>::value, "D has a foo with the wrong arguments. "); static_assert(Has_foo<E>::value, "E has a foo since it inherits from B"); 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 <typename T> \ struct name { \ typedef char yes[1]; \ typedef char no[2]; \ template <typename U> \ struct type_check; \ template <typename _1> \ static yes& chk(type_check<typename _1::typedef_name>*); \ template <typename> \ static no& chk(...); \ static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \ } 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 <typename T> \ struct name { \ typedef return_type (T::*Sign)(__VA_ARGS__); \ typedef char yes[1]; \ typedef char no[2]; \ template <typename U, U> \ struct type_check; \ template <typename _1> \ static yes& chk(type_check<Sign, &_1::func>*); \ template <typename> \ static no& chk(...); \ static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \ } 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 << "Check Function A:" << has_check_function<A>::value << std::endl; std::cout << "Check Function B:" << has_check_function<B>::value << std::endl; std::cout << "Hello Function A:" << hello_check<A>::value << std::endl; std::cout << "Hello Function B:" << hello_check<B>::value << std::endl; std::cout << "Hello void Function A:" << hello_void_check<A>::value << std::endl; std::cout << "Hello void Function B:" << hello_void_check<B>::value << std::endl; std::cout << "Check Typedef A:" << has_typedef_check<A>::value << std::endl; std::cout << "Check Typedef B:" << has_typedef_check<B>::value << std::endl; } 
HAS_MEM_FUNC( onNext, has_memberfn_onNext, void, Args... ); ... template <typename V> struct Foo { void onNext(const V &); static_assert< has_memberfn_onNext<Foo<V>,const V &>::value, "API fail" ); };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<>::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 <iostream> #include <vector> class EmptyClass{}; template <typename T> class has_begin { private: has_begin() = delete; struct one { char x[1]; }; struct two { char x[2]; }; template <typename C> static one test( decltype(void(std::declval<C &>().begin())) * ) ; template <typename C> static two test(...); public: static constexpr bool value = sizeof(test<T>(0)) == sizeof(one); }; int main(int argc, char *argv[]) { std::cout << std::boolalpha; std::cout << "vector<int>::begin() exists: " << has_begin<std::vector<int>>::value << std::endl; std::cout << "EmptyClass::begin() exists: " << has_begin<EmptyClass>::value << std::endl; return 0; } Or the shorter version:
#include <iostream> #include <vector> class EmptyClass{}; template <typename T, typename = void> struct has_begin : std::false_type {}; template <typename T> struct has_begin<T, decltype(void(std::declval<T &>().begin()))> : std::true_type {}; int main(int argc, char *argv[]) { std::cout << std::boolalpha; std::cout << "vector<int>::begin() exists: " << has_begin<std::vector<int>>::value << std::endl; std::cout << "EmptyClass exists: " << has_begin<EmptyClass>::value << 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(&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<T, decltype(void(std::declval<T &>().begin()))> Here's what's happening in order: We use std::declval<T &>() 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.
void(...) part. I would've thought that this would work: template <auto> using v_to_void = void; ... v_to_void<std::declval<T&>().begin()> (avoiding decltype). Any idea why it doesn't?Strange nobody suggested the following nice trick I saw once on this very site :
template <class T> struct has_foo { struct S { void foo(...); }; struct derived : S, T {}; template <typename V, V> struct W {}; template <typename X> char (&test(W<void (X::*)(), &X::foo> *))[1]; template <typename> char (&test(...))[2]; static const bool value = sizeof(test<derived>(0)) == 1; }; 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.
How about this solution?
#include <type_traits> template <typename U, typename = void> struct hasToString : std::false_type { }; template <typename U> struct hasToString<U, typename std::enable_if<bool(sizeof(&U::toString))>::type > : std::true_type { }; 
toString is overloaded, as &U::toString is ambiguous.
The generic template that can be used for checking if some "feature" is supported by the type:
#include <type_traits> template <template <typename> class TypeChecker, typename Type> 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<Type_> is invalid type template <typename Type_> static supported chk(typename std::decay<TypeChecker<Type_>>::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 <typename Type_> 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<decltype(chk<Type>(nullptr)),supported>::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 <typename T> using has_foo = decltype(double(std::declval<T>().foo(std::declval<const char*>()))); Examples
// types that support has_foo struct struct1 { double foo(const char*); }; // exact signature match struct struct2 { int foo(const std::string &str); }; // compatible signature struct struct3 { float foo(...); }; // compatible ellipsis signature struct struct4 { template <typename T> 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 << std::boolalpha; std::cout << is_supported<has_foo, int >::value << std::endl; // false std::cout << is_supported<has_foo, double >::value << std::endl; // false std::cout << is_supported<has_foo, struct1>::value << std::endl; // true std::cout << is_supported<has_foo, struct2>::value << std::endl; // true std::cout << is_supported<has_foo, struct3>::value << std::endl; // true std::cout << is_supported<has_foo, struct4>::value << std::endl; // true std::cout << is_supported<has_foo, struct5>::value << std::endl; // false std::cout << is_supported<has_foo, struct6>::value << std::endl; // false std::cout << is_supported<has_foo, struct7>::value << std::endl; // false std::cout << is_supported<has_foo, struct8>::value << std::endl; // false return 0; } 
has_foo into the template call of is_supported. What I would like is to call something like: std::cout << is_supported<magic.foo(), struct1>::value << std::endl;. The reason for this, I want to define a has_foo for each different function signature that I want to check before I can check for the function?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<typename Callable, typename... Args, typename = decltype(declval<Callable>()(declval<Args>()...))> std::true_type isCallableImpl(Callable, Args...) { return {}; } std::false_type isCallableImpl(...) { return {}; } template<typename... Args, typename Callable> constexpr bool isCallable(Callable callable) { return decltype(isCallableImpl(callable, declval<Args>()...)){}; } Usage:
constexpr auto TO_STRING_TEST = [](auto in) -> decltype(in.toString()) { return {}; }; constexpr bool TO_STRING_WORKS = isCallable<T>(TO_STRING_TEST); 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<typename T> T declval(void); struct fake_void { }; template<typename T> T &operator,(T &,fake_void); template<typename T> T const &operator,(T const &,fake_void); template<typename T> T volatile &operator,(T volatile &,fake_void); template<typename T> T const volatile &operator,(T const volatile &,fake_void); struct yes { char v[1]; }; struct no { char v[2]; }; template<bool> struct yes_no:yes{}; template<> struct yes_no<false>:no{}; template<typename T> struct has_awesome_member { template<typename U> static yes_no<(sizeof(( declval<U>().awesome_member(),fake_void() ))!=0)> check(int); template<typename> static no check(...); enum{value=sizeof(check<T>(0)) == sizeof(yes)}; }; struct foo { int awesome_member(void); }; struct bar { }; struct foo_void { void awesome_member(void); }; struct wrong_params { void awesome_member(int); }; static_assert(has_awesome_member<foo>::value,""); static_assert(!has_awesome_member<bar>::value,""); static_assert(has_awesome_member<foo_void>::value,""); static_assert(!has_awesome_member<wrong_params>::value,""); 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'.
static_assert(false);). I was using this in connection with CRTP where I want to determine whether the derived class has a particular function--which turns out not to work, yet your asserts always passed. I lost some hair to that one.
operator , since this is the only operator that's implemented by the builtin void-type (you can write ((void)0, foo()), but any other operator like in ((void)0 + foo()) would always cause a compiler error and cannot be overridden), meaning that this is required for being able to dectect functions with a void return type. - As for namespace pollution: Sure you could just put everything (except for operator ,(), which has to remain visible as a global operator) into some namespace and adjust has_awesome_member to simply make use of that namespace.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 <string> #include <vector> HAS_MEM(bar) HAS_MEM_FUN_CALL(bar) struct test { void bar(int); void bar(double); void bar(int,double); template < typename T > typename std::enable_if< not std::is_integral<T>::value >::type bar(const T&, int=0){} template < typename T > typename std::enable_if< std::is_integral<T>::value >::type bar(const std::vector<T>&, T*){} template < typename T > int bar(const std::string&, int){} }; Now you can use it like this:
int main(int argc, const char * argv[]) { static_assert( has_mem_bar<test>::value , ""); static_assert( has_valid_mem_fun_call_bar<test(char const*,long)>::value , ""); static_assert( has_valid_mem_fun_call_bar<test(std::string&,long)>::value , ""); static_assert( has_valid_mem_fun_call_bar<test(std::vector<int>, int*)>::value , ""); static_assert( has_no_viable_mem_fun_call_bar<test(std::vector<double>, double*)>::value , ""); static_assert( has_valid_mem_fun_call_bar<test(int)>::value , ""); static_assert( std::is_same<void,result_of_mem_fun_call_bar<test(int)>::type>::value , ""); static_assert( has_valid_mem_fun_call_bar<test(int,double)>::value , ""); static_assert( not has_valid_mem_fun_call_bar<test(int,double,int)>::value , ""); static_assert( not has_ambiguous_mem_fun_call_bar<test(double)>::value , ""); static_assert( has_ambiguous_mem_fun_call_bar<test(unsigned)>::value , ""); static_assert( has_viable_mem_fun_call_bar<test(unsigned)>::value , ""); static_assert( has_viable_mem_fun_call_bar<test(int)>::value , ""); static_assert( has_no_viable_mem_fun_call_bar<test(void)>::value , ""); return 0; } 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 >= 201103 #include <utility> #include <type_traits> #define HAS_MEM(mem) \ \ template < typename T > \ struct has_mem_##mem \ { \ struct yes {}; \ struct no {}; \ \ struct ambiguate_seed { char mem; }; \ template < typename U > struct ambiguate : U, ambiguate_seed {}; \ \ template < typename U, typename = decltype(&U::mem) > static constexpr no test(int); \ template < typename > static constexpr yes test(...); \ \ static bool constexpr value = std::is_same<decltype(test< ambiguate<T> >(0)),yes>::value ; \ typedef std::integral_constant<bool,value> type; \ }; #define HAS_MEM_FUN_CALL(memfun) \ \ template < typename Signature > \ struct has_valid_mem_fun_call_##memfun; \ \ template < typename T, typename... Args > \ struct has_valid_mem_fun_call_##memfun< T(Args...) > \ { \ struct yes {}; \ struct no {}; \ \ template < typename U, bool = has_mem_##memfun<U>::value > \ struct impl \ { \ template < typename V, typename = decltype(std::declval<V>().memfun(std::declval<Args>()...)) > \ struct test_result { using type = yes; }; \ \ template < typename V > static constexpr typename test_result<V>::type test(int); \ template < typename > static constexpr no test(...); \ \ static constexpr bool value = std::is_same<decltype(test<U>(0)),yes>::value; \ using type = std::integral_constant<bool, value>; \ }; \ \ template < typename U > \ struct impl<U,false> : std::false_type {}; \ \ static constexpr bool value = impl<T>::value; \ using type = std::integral_constant<bool, value>; \ }; \ \ template < typename Signature > \ struct has_ambiguous_mem_fun_call_##memfun; \ \ template < typename T, typename... Args > \ struct has_ambiguous_mem_fun_call_##memfun< T(Args...) > \ { \ struct ambiguate_seed { void memfun(...); }; \ \ template < class U, bool = has_mem_##memfun<U>::value > \ struct ambiguate : U, ambiguate_seed \ { \ using ambiguate_seed::memfun; \ using U::memfun; \ }; \ \ template < class U > \ struct ambiguate<U,false> : ambiguate_seed {}; \ \ static constexpr bool value = not has_valid_mem_fun_call_##memfun< ambiguate<T>(Args...) >::value; \ using type = std::integral_constant<bool, value>; \ }; \ \ template < typename Signature > \ struct has_viable_mem_fun_call_##memfun; \ \ template < typename T, typename... Args > \ struct has_viable_mem_fun_call_##memfun< T(Args...) > \ { \ static constexpr bool value = has_valid_mem_fun_call_##memfun<T(Args...)>::value \ or has_ambiguous_mem_fun_call_##memfun<T(Args...)>::value; \ using type = std::integral_constant<bool, value>; \ }; \ \ template < typename Signature > \ struct has_no_viable_mem_fun_call_##memfun; \ \ template < typename T, typename... Args > \ struct has_no_viable_mem_fun_call_##memfun < T(Args...) > \ { \ static constexpr bool value = not has_viable_mem_fun_call_##memfun<T(Args...)>::value; \ using type = std::integral_constant<bool, value>; \ }; \ \ template < typename Signature > \ struct result_of_mem_fun_call_##memfun; \ \ template < typename T, typename... Args > \ struct result_of_mem_fun_call_##memfun< T(Args...) > \ { \ using type = decltype(std::declval<T>().memfun(std::declval<Args>()...)); \ }; #endif You can skip all the metaprogramming in C++14, and just write this using fit::conditional from the Fit library:
template<class T> std::string optionalToString(T* x) { return fit::conditional( [](auto* obj) -> decltype(obj->toString()) { return obj->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) -> decltype(obj->toString(), std::string()) { return obj->toString(); }, [](auto*) -> 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<class T> auto operator()(T* obj) const -> decltype(obj->toString(), std::string()) { return obj->toString(); } }; struct withoutToString { template<class T> std::string operator()(T*) const { return "toString not defined"; } }; FIT_STATIC_FUNCTION(optionalToString) = fit::conditional( withToString(), withoutToString() ); 
fit or any library other than the standard?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 <typename... Args> struct Pack {}; #define Proxy(T) ((T &)(*(int *)(nullptr))) template <typename Class, typename ArgPack, typename = nullptr_t> struct HasFoo { enum { value = false }; }; template <typename Class, typename... Args> struct HasFoo< Class, Pack<Args...>, decltype((void)(Proxy(Class).foo(Proxy(Args)...)), nullptr)> { 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 <bool has_foo_int_char> struct Dispatcher; template <> struct Dispatcher<false> { template <typename Object> static int exec(Object &object, int n, char c) { return object.foo(n) + c; } }; template <> struct Dispatcher<true> { template <typename Object> static int exec(Object &object, int n, char c) { return object.foo(n, c); } }; int runExample() { using Args = Pack<int, char>; enum { has_overload = HasFoo<Object, Args>::value }; Object object; return Dispatcher<has_overload>::exec(object, 100, 'a'); } If you know your class is default constructible, we can make the syntax simpler.
We'll start with the simplest case: Default constructible and we know the expected return type. Example method:
int foo (); We can write the type trait without declval:
template <auto v> struct tag_v { constexpr static auto value = v; }; template <class, class = int> struct has_foo_method : tag_v<false> {}; template <class T> struct has_foo_method <T, decltype(T().foo())> : tag_v<true> {}; Note that we set the default type to int because that's the return type of foo.
If there's multiple acceptable return types then we add a second argument to decltype that's the same type as the default, overriding the first argument:
decltype(T().foo(), int()) (The int type here is unimportant - I use it because it's only 3 letters)
#define HasMember(NAME) \ template<class Class, typename Type = void> \ struct HasMember_##NAME \ { \ typedef char (&yes)[2]; \ template<unsigned long> struct exists; \ template<typename V> static yes Check (exists<sizeof(static_cast<Type>(&V::NAME))>*); \ template<typename> static char Check (...); \ static const bool value = (sizeof(Check<Class>(0)) == sizeof(yes)); \ }; \ template<class Class> \ struct HasMember_##NAME<Class, void> \ { \ typedef char (&yes)[2]; \ template<unsigned long> struct exists; \ template<typename V> static yes Check (exists<sizeof(&V::NAME)>*); \ template<typename> static char Check (...); \ static const bool value = (sizeof(Check<Class>(0)) == sizeof(yes)); \ } Using above macro, you can find any member's existence in a class, be it variable or method. If there are 2 methods with same name, then we also have to provide the type of the method.
Usage:
#include<iostream> struct S { void Foo () const {} // void Foo () {} // If uncommented then, SFINAE fails int i; }; HasMember(Foo); HasMember(i); int main () { std::cout << HasMember_Foo<S, void (S::*) () const>::value << "\n"; std::cout << HasMember_Foo<S>::value << "\n"; std::cout << HasMember_i<S, int (S::*)>::value << "\n"; std::cout << HasMember_i<S>::value << "\n"; } The 2nd cout may print 0 if there are 2 methods with same name Foo present in S. In case of member variable, the type (as mentioned in 3rd cout) is redundant as the variable name can be only 1. However to check the specific type, it's useful (for both method and variable).
