Here’s an option: #include <iostream> #include <type_traits> #include <string> template <class, template <class> class> struct is_instance : public std::false_type {}; template <class T, template <class> class U> struct is_instance<U<T>, U> : public std::true_type {}; template <class> class Second {}; int main() { using A = Second<int>; using B = Second<std::string>; using C = float; std::cout … Read more
should std::common_type use std::decay? Yes, see Library Working Group Defect #2141. Short version (long version, see link above): declval<A>() returns a A&& common_type is specified via declval, n3337: template <class T, class U> struct common_type<T, U> { typedef decltype(true ? declval<T>() : declval<U>()) type; }; common_type<int, int>::type therefore yields int&&, which is unexpected proposed resolution … Read more
Firstly, C++11 did not carry forward boost’s disable_if. So if you’re going to transition boost code, you’ll need to use enable_if with a negated condition (or redefine your own disable_if construct). Secondly, for SFINAE to reach in and apply to the method level, those methods must be templates themselves. Yet your tests have to be … Read more
Try this: #include <type_traits> template <typename T, template <typename> class Tmpl> // #1 see note struct is_derived { typedef char yes[1]; typedef char no[2]; static no & test(…); template <typename U> static yes & test(Tmpl<U> const &); static bool const value = sizeof(test(std::declval<T>())) == sizeof(yes); }; Usage: #include <iostream> template<class T> struct X {}; struct … Read more
You’re looking for std::disjunction. It’s specified in N4564 [meta.logical]. #include <type_traits> template<typename T, typename… Ts> constexpr bool contains() { return std::disjunction_v<std::is_same<T, Ts>…>; } static_assert( contains<int, bool, char, int, long>()); static_assert( contains<bool, bool, char, int, long>()); static_assert( contains<long, bool, char, int, long>()); static_assert(not contains<unsigned, bool, char, int, long>()); Live demo Or, adapted to a struct template<typename … Read more
common_reference came out of my efforts to come up with a conceptualization of STL’s iterators that accommodates proxy iterators. In the STL, iterators have two associated types of particular interest: reference and value_type. The former is the return type of the iterator’s operator*, and the value_type is the (non-const, non-reference) type of the elements of … Read more
POD is being replaced with two categories that give more nuances. The c++ standard meeting in november 2017 had this to say about it: Deprecating the notion of “plain old data” (POD). It has been replaced with two more nuanced categories of types, “trivial” and “standard-layout”. “POD” is equivalent to “trivial and standard layout”, but … Read more
Here’s an option: #include <iostream> #include <type_traits> #include <string> template <class, template <class> class> struct is_instance : public std::false_type {}; template <class T, template <class> class U> struct is_instance<U<T>, U> : public std::true_type {}; template <class> class Second {}; int main() { using A = Second<int>; using B = Second<std::string>; using C = float; std::cout … Read more
You have to write your own, but it’s simple: template<typename> struct is_std_array : std::false_type {}; template<typename T, std::size_t N> struct is_std_array<std::array<T,N>> : std::true_type {};
This is because of a flaw in the design of std::vector. std::vector defines copy construction even if it will fail to compile, and relies on users of std::vector to not invoke the method if it will fail to compile. The alternative design would be to SFINAE block the invocation of the method if the type … Read more