If we ask the compiler to tell us anything about a class type T that has not even been declared we are bound to get a compilation error. There is no way around that. Therefore if we want to know whether class T “exists”, where T might not even have been declared yet, we must … Read more
I’ve put some thoughts on how to implement the things you requested and came to a totally different conclusion. The problem at hand is very interesting: How do I check whether a class implements a hidden interface. Unfortunately the problem is a contradiction to the liskov substitution principle; one of the core object oriented principles. … Read more
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
NOTE: I opened a question here about whether OPs code is actually valid. My rewritten example below will work in any case. but I would like to know if the code is legal C++11 It is, although the default template argument may be considered a bit unusual. I personally like the following style better, which … Read more
I think this can’t work with a single defaulted template parameter, because its value needs to be resolved when the class template is instantiated. We need to defer the substitution to the point of constructor template instantiation. One way is to default the template parameter to T and add an extra dummy parameter to the … Read more
1. Primary Class Template When you write has_member<A>::value, the compiler looks up the name has_member and finds the primary class template, that is, this declaration: template< class , class = void > struct has_member; (In the OP, that’s written as a definition.) The template argument list <A> is compared to the template parameter list of … Read more
You should take a look at 14.5.6.1 Function template overloading (C++11 standard) where function templates equivalency is defined. In short, default template arguments are not considered, so in the 1st case you have the same function template defined twice. In the 2nd case you have expression referring template parameters used in the return type (again … Read more
IF the original declaration of User<> can be adapted to template<typename, typename=std::true_type> class User; then we can find a solution (following Luc Danton’s comment, instead of using std::enable_if) template<typename> struct is_Data : std::false_type {}; template<typename T> struct is_Data<Data<T>> : std::true_type {}; template<typename T> class User<T, typename is_Data<T>::type > { /* … */ }; However, this … 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
If you consider all the templates and implicitly-defined functions that are needed to determine the result of the template argument substitution, and imagine they are generated first, before substitution starts, then any errors occurring in that first step are not in the immediate context, and result in hard errors. If all those instantiations and implicitly-definitions … Read more