sfinae

I have just begun dabbling with SFINAE and I am having trouble understanding the syntax behind the most often-used example which appears in various forms, but the idea is to check whether a particular type contains a given member. This particular one is from Wikipedia : template <typename T> struct has_typedef_foobar { typedef char yes[1]; typedef char no[2]; template <typename C> static yes& test(typename C::foobar*); template <typename> static no& test(...); static const bool value = sizeof(test<T>(0)) == sizeof(yes); }; There are a couple of things I don't get about this: What is the

Demo A in class declaration of A::foo. struct A { template <typename T> void foo(T a); }; A::foo is now split by sfinae. template <typename T> typename std::enable_if<(sizeof(T) > 4), void>::type A::foo(T a ) { std::cout << "> 4 \n"; } This doesn't work. Is this not allowed? The return type in the declaration must match the definition. struct A { template <typename T> typename std::enable_if<(sizeof(T) > 4), void>::type foo(T a); }; SFINAE cannot be encapsulated as an implementation detail. ( demo ) One way to achieve this is to internally tag-dispatch: #include <utility> #include <iostream>

This question already has an answer here: SFINAE working in return type but not as template parameter 3 answers Template specialization and enable_if problems [duplicate] 1 answer I have been liking SFINAE syntax like this for functions, seems to generally work well! template <class Integer, class = typename std::enable_if<std::is_integral<Integer>::value>::type> T(Integer n) { // ... } But am running into an issue when I want to do this as well in the same class... template <class Float, class = typename std::enable_if<std::is_floating_point<Float>::value>::type> T(Float n) { // ... } Getting

In this example a function is passed to an implicitly instantiated function template. // Function that will be passed as argument int foo() { return 0; } // Function template to call passed function template<typename F> int call(F f) { return f(); } template<typename F, typename A> int call(F f, A a) { return f(a); } int a = call(foo); We can break this code by adding an overload for foo() . int foo(int i) { return 0; } The name " foo " is now ambiguous and the example will no longer compile. This can be made to compile by explicitly providing function pointer type info. int (*func_takes_void)