sfinae

When I compile the following snippet, I get a compiler error with clang, but not with g++/MSVC: #include <string> template<typename T> struct Const { explicit Const(T val) : value(val) {} T value; }; template<typename T> struct Var { explicit Var(const std::string &n) : name(n) {} std::string name; }; template<typename L, typename R> struct Greater { Greater(L lhs, R rhs) : left(lhs), right(rhs) {} L left; R right; }; template<typename L> Greater<L, Const<int> > operator > (L lhs, int rhs) { return Greater<L, Const<int> >(lhs, Const<int>(rhs)); } template<typename R> Greater<Const<int>, R>

I want to check for the existence of a function in a specific namespace using SFINAE. I have found SFINAE to test a free function from another namespace which does the job, but there are some things I don't understand. Currently I have this working code, straight from the linked question: // switch to 0 to test the other case #define ENABLE_FOO_BAR 1 namespace foo { #if ENABLE_FOO_BAR int bar(); #endif } namespace detail_overload { template<typename... Args> void bar(Args&&...); } namespace detail { using namespace detail_overload; using namespace foo; template<typename T> decltype(bar()) test

The base components of my hobby library has to work with C++98 and C++11 compilers. To learn and to enjoy myself I created the C++98 implementations of several type support functionality (like enable_if , conditional , is_same , is_integral etc. ...) in order to use them when there is no C++11 support. However while I was implementing is_constructible I got stuck. Is there any kind of template magic (some kind of SFINAE) with which I can implement it without C++11 support ( declval )? Of course there is no variadic template support in C++03, so I will specialise the implementation till some

This question already has an answer here: Is it possible to determine if a type is a scoped enumeration type? 1 answer How can one implement type trait whose value member is true if and only if the passed in type T is a class enum? While I know that for instance +T{}; will work if T is an enum and fail if it is an enum class, I couldn't find a way so far to use this for SFINAE. Based on your +T{} test: Option #1: Expression SFINAE in trailing return type: #include <type_traits> template <typename T> auto test(int) -> decltype((void)+T{}, std::false_type{}); template <typename T> auto test(...)

template<class T> struct is_iterator { static const bool value = ??? // What to write ??? }; int main() { assert(false == is_iterator<int>::value); assert(true == is_iterator<vector<int>::iterator>::value); assert(true == is_iterator<list<int>::iterator>::value); assert(true == is_iterator<string::iterator>::value); assert(true == is_iterator<char*>::value); // a raw pointer is also an iterator } The question is: How to make the five assert statements pass? Alexey Malistov template<class T> struct is_iterator { static T makeT(); typedef void * twoptrs[2]; // sizeof(twoptrs) > sizeof(void *)

I found several questions & answers on SO dealing with detecting at compile time (via SFINAE) whether a given class has a member of certain name, type, or signature. However, I couldn't find one that also applies to static public member functions (when pointer-to-member tricks won't work). Any ideas? Following may help: ( https://ideone.com/nDlFUE ) #include <cstdint> #define DEFINE_HAS_SIGNATURE(traitsName, funcName, signature) \ template <typename U> \ class traitsName \ { \ private: \ template<typename T, T> struct helper; \ template<typename T> \ static std::uint8_t check(helper<signature,

I have is_callable trait defined like this: #ifndef IS_CALLABLE_HPP #define IS_CALLABLE_HPP #include <type_traits> namespace is_callable_detail { struct no {}; struct yes { no x[2]; }; template<bool CallableArgs, typename Callable, typename ReturnType, typename ...Args> struct check_return { static const bool value = std::is_convertible<decltype(std::declval<Callable>()(std::declval<Args>()...)), ReturnType>::value; }; template<typename Callable, typename ReturnType, typename ...Args> struct check_return<false, Callable, ReturnType, Args...> { static const bool value = false; }; } template