sfinae

A (somewhat) outdated article explores ways to use decltype along with SFINAE to detect if a type supports certain operators, such as == or < . Here's example code to detect if a class supports the < operator: template <class T> struct supports_less_than { static auto less_than_test(const T* t) -> decltype(*t < *t, char(0)) { } static std::array<char, 2> less_than_test(...) { } static const bool value = (sizeof(less_than_test((T*)0)) == 1); }; int main() { std::cout << std::boolalpha << supports_less_than<std::string>::value << endl; } This outputs true , since of course std::string supports

suppose I have these declarations template<typename T> class User; template<typename T> class Data; and want to implement User<> for T = Data<some_type> and any class derived from Data<some_type> but also allow for other specialisations defined elsewhere. If I didn't already have the declaration of the class template User<> , I could simply template<typename T, typename A= typename std::enable_if<is_Data<T>::value>::type> class User { /*...*/ }; where template<template<typename> data>> struct is_Data { static const bool value = /* some magic here (not the question) */; }; However, this has two

How to test at compile time whether class B is derived from std::vector? template<class A> struct is_derived_from_vector { static const bool value = ????; }; How to test at compile time whether class B is derived from template family? template<class A, template< class > class Family> struct is_derived_from_template { static const bool value = ????; }; Using: template<class T> struct X {}; struct A : X<int> {} struct B : std::vector<char> {} struct D : X<D> {} int main() { std::cout << is_derived_from_template<A, X>::value << std::endl; // true std::cout << is_derived_from_template<D, X>::value

Consider the following program: #include <type_traits> enum class dummy {}; template <typename T> using EnableIf = typename std::enable_if<T::value, dummy>::type; template <typename T> using DisableIf = typename std::enable_if<!T::value, dummy>::type; template <typename T> struct dependent_true_type : std::true_type {}; template <typename T, EnableIf<dependent_true_type<T>>...> std::true_type f(); template <typename T, DisableIf<dependent_true_type<T>>...> std::false_type f(); static_assert(decltype(f<int>())::value, ""); int main() {} GCC 4.7 glady accepts this program. My recent clang 3.1

Consider following code: #include <iostream> #include <type_traits> template <typename T> struct A { int val = 0; template <class = typename std::enable_if<T::value>::type> A(int n) : val(n) {}; A(...) { } /* ... */ }; struct YES { constexpr static bool value = true; }; struct NO { constexpr static bool value = false; }; int main() { A<YES> y(10); A<NO> n; std::cout << "YES: " << y.val << std::endl << "NO: " << n.val << std::endl; } I want to selectively define constructor A::A(int) only for some types using enable_if. For all other types there is default constructor A::A(...) which should be

Why does this code work: template< typename T, std::enable_if_t<std::is_same<T, int>::value, T>* = nullptr> void Add(T) {} template< typename T, std::enable_if_t<!std::is_same<T, int>::value, T>* = nullptr> void Add(T) {} and can correctly distinguish between these two calls: Add(1); Add(1.0); while the following code if compiled results in the redefinition of Add() error? template< typename T, typename = typename std::enable_if<std::is_same<T, int>::value, T>::type> void Add(T) {} template< typename T, typename = typename std::enable_if<!std::is_same<T, int>::value, T>::type> void Add(T) {}

#include <type_traits> struct A{}; struct B{}; template <typename T> struct Foo { typename std::enable_if<std::is_same<T, A>::value>::type bar() {} typename std::enable_if<std::is_same<T, B>::value>::type bar() {} }; Error message: 14:5: error: 'typename std::enable_if<std::is_same<T, B>::value>::type Foo<T>::bar()' cannot be overloaded 10:5: error: with 'typename std::enable_if<std::is_same<T, A>::value>::type Foo<T>::bar()' Source on cpp.sh . I thought both typename std::enable_if<std::is_same<T,?>::value>::type could not be valid at the same time. Edit For posterity here is my edit based on