enable_if works because the substitution of a template argument resulted in an error, and so that substitution is dropped from the overload resolution set and only other viable overloads are considered by the compiler. In your example, there is no substitution occurring when instantiating the member functions because the template argument T is already known … Read more
You can add a defaulted type argument to the template: template <int otherN, typename = typename std::enable_if<otherN >= N>::type> explicit A(A<otherN> const &);
A conditional base class may be used: struct BaseWithVariable { int addedVariable; }; struct BaseWithoutVariable { }; template <bool AddMembers> class MyClass : std::conditional<AddMembers, BaseWithVariable, BaseWithoutVariable>::type { // etc. };
Look, another SFINAE-based solution for detecting STL-like containers: template<typename T, typename _ = void> struct is_container : std::false_type {}; template<typename… Ts> struct is_container_helper {}; template<typename T> struct is_container< T, std::conditional_t< false, is_container_helper< typename T::value_type, typename T::size_type, typename T::allocator_type, typename T::iterator, typename T::const_iterator, decltype(std::declval<T>().size()), decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()), decltype(std::declval<T>().cbegin()), decltype(std::declval<T>().cend()) >, void > > : public std::true_type {}; … Read more
Let’s remove some code. template< class T, class U/* = std::enable_if_t<std::is_same<int, T>::value>*/ > void g() { } template< class T, class U/* = std::enable_if_t<std::is_same<double, T>::value>*/ > void g() { } would you be surprised if the compiler rejected the two above templates? They are both template functions of “type” template<class,class>void(). The fact that the 2nd … Read more
Put the hack in the template parameters. The enable_if on template parameter approach has at least two advantages over the others: readability: the enable_if use and the return/argument types are not merged together into one messy chunk of typename disambiguators and nested type accesses; even though the clutter of the disambiguator and nested type can … Read more