sfinae

There are a number of similar questions/answers, but I couldn't quite put those answers together to serve my purposes. I want a traits template<typename Func, typename ReturnType, typename... Args> struct returns_a { static const bool value; }; such that returns_a<F,T,Args>::value is true if F(Args) is well formed and returns a T . After some more research, I got it working as follows: // value is true if Func(Args...) is well formed template<typename Func, typename... Args> class is_callable { template <typename F> static decltype(std::declval<F>()(std::declval<Args>()...), void(), 0) test

I feel certain it must be possible to use SFINAE (possibly with Macros) to static_assert() that arbitary code will not compile. There are some complex cases in my code-base, where i have a class that I want to forbid taking temporaries (I believe the pattern is): class(const class&& tmp)=delete; /* deny copying from an unnamed temporary */ class (class&& rhs){/* allow construction from non-temporary rvalue*/} Currently, I check an undesired constructor DOES NOT compile, but then of course I have to comment it out to get the tests to compile again! If I could do: static_assert(DOES_NOT_COMPILE

I would like to write a constructor for MyClass that take an argument and I want this to compile only if the argument is a pointer or an iterator (something having iterator_traits ). How to achieve this ? Regrettably, there is no standard way to detect whether a class models Iterator . The simplest check would be that *it and ++it are both syntactically valid; you can do this using standard SFINAE techniques: template<typename T, typename = decltype(*std::declval<T&>(), void(), ++std::declval<T&>(), void())> MyClass(T); Considering the Iterator requirements from 24.2.2:2: template<typename T>

I was trying to come up with a hack to test if std::isnan is defined without special casing compilers in the preprocessor, and came up with the following, which I was expecting to work fine. #include <cmath> #include <type_traits> namespace detail { using namespace std; struct dummy {}; void isnan(dummy); //bool isnan(float); // Just adding this declaration makes it work! template <typename T> struct is_isnan_available { template <typename T1> static decltype(isnan(T1())) test(int); template <typename> static void test(...); enum { value = !std::is_void<decltype(test<T>(0))>::value }; }; } int

I was reading the Wikipedia article on SFINAE and encountered following code sample: struct Test { typedef int Type; }; template < typename T > void f( typename T::Type ) {} // definition #1 template < typename T > void f( T ) {} // definition #2 void foo() { f< Test > ( 10 ); //call #1 f< int > ( 10 ); //call #2 without error thanks to SFINAE } Now I've actually written code like this before, and somehow intuitively I knew that I needed to type "typename T" instead of just "T". However, it would be nice to know the actual logic behind it. Anyone care to explain? In general, C++'s syntax

I have an incredibly exciting library that can translate points: it should work with any point types template<class T> auto translate_point(T &p, int x, int y) -> decltype(p.x, p.y, void()) { p.x += x; p.y += y; } template<class T> auto translate_point(T &p, int x, int y) -> decltype(p[0], void()) { p[0] += x; p[1] += y; } translate_point will work with points that have public x and y members, and it will also work with tuples/indexable containers where x and y are represented by the first and second element, respectively. The problem is, another library defines a point class with public x and