sfinae

This question already has answers here : How does `void_t` work (2 answers) Closed last year . I have a program that is as follows. There is a base template struct X and a partial specialisation with SFINAE. template <typename T, typename U = void> struct X{ X() { std::cout << "in 1" << std::endl; }; }; template <typename T> struct X< T, std::enable_if_t<std::is_integral_v<T>> > { X() { std::cout << "in 2" << std::endl; }; }; int main() { X<int> x; } When running the program in 2 is printed. Why is it that the second specialization is chosen over the first since both of them effectively

When I compile this code: #include <type_traits> template <typename T> void do_stuff(std::enable_if_t<std::is_integral<T>::value, T> &t) {} template <typename T> void do_stuff(std::enable_if_t<std::is_class<T>::value, T> &t) {} int main() { int i = 1; do_stuff(i); return 0; } GCC says: 37325975.cpp: In function ‘int main()’: 37325975.cpp:11:15: error: no matching function for call to ‘do_stuff(int&)’ do_stuff(i); ^ 37325975.cpp:4:6: note: candidate: template<class T> void do_stuff(std::enable_if_t<std::is_integral<_Tp>::value, T>&) void do_stuff(std::enable_if_t<std::is_integral<T>::value, T>

I want to specialize a template class constructor: If type is int default value is 50 and -50 . and if it's float default should be 0.5 and -0.5 . My code is : #include <iostream> #include <limits> #include <type_traits> template<typename T> class Foo{ public: template<typename = typename std::enable_if< std::is_integral<T>::value&& !std::is_floating_point<T>::value>::type> Foo(T value1 = 50, T value2 = -50) :value1_(value1), value2_(value2){} template<typename = typename std::enable_if< std::is_floating_point<T>::value>::type> Foo(T value1 = 0.5, T value2 = -0.5, void* dummy = 0) : value1_

This question is related to this answer . In this example SFINAE uses variable template has_literal_x specialization instead of the base template: struct A { }; A operator"" _x(char const*) { return {}; } template<typename T, typename S, typename = void> constexpr bool has_literal_x = false; template<typename T, typename S> constexpr bool has_literal_x<T, S, std::enable_if_t< std::is_same< decltype(operator""_x(std::declval<S>())), T >::value > > = true; int main() { std::cout << has_literal_x<A, char const*> << std::endl; // 1 } And here it uses the base template: template<typename T,

Many of Boost's SFINAE helpers have appeared in the std library with C++11, but has_dereference doesn't seem to have. Other than this feature, I've managed to eliminate a Boost dependency from my package, and I'd like to get rid of it entirely, so how best to get the same effect using just C++11 std features? Nir Friedman The easiest way to check if a class has some function with no external dependencies is generally with the void_t idiom. // Define this once in your project somewhere accessible template <class ... T> using void_t = void; The trick then is always the same; you define a class

I'm writing some simple point code while trying out Visual Studio 10 (Beta 2), and I've hit this code where I would expect SFINAE to kick in, but it seems not to: template<typename T> struct point { T x, y; point(T x, T y) : x(x), y(y) {} }; template<typename T, typename U> struct op_div { typedef decltype(T() / U()) type; }; template<typename T, typename U> point<typename op_div<T, U>::type> operator/(point<T> const& l, point<U> const& r) { return point<typename op_div<T, U>::type>(l.x / r.x, l.y / r.y); } template<typename T, typename U> point<typename op_div<T, U>::type> operator/(point<T>

Very weird problem I've been struggling with for the past few hours (after solving 5-6 other issues with SFINAE as I'm new to it). Basically in the following code I want to have f() working for all possible template instantiations, but have g() available only when N == 2 : #include <type_traits> #include <iostream> template<typename T, int N> class A { public: void f(void); void g(void); }; template<typename T, int N> inline void A<T, N>::f() { std::cout << "f()\n"; } template<typename T, int N, typename std::enable_if<N == 2, void>::type* = nullptr> inline void A<T, N>::g() { std::cout << "g(