I have written up a complete answer here — it’s a work in progress, so I’m giving the authoritative hyperlink even though I’m cutting-and-pasting the text into this answer. Also see libc++’s documentation on Type traits intrinsic design. is_union is_union queries an attribute of the class that isn’t exposed through any other means; in C++, … Read more
I think testing if it is an enum and not implicitly convertible to the underlying type should do the trick. template <typename T, bool B = std::is_enum<T>::value> struct is_scoped_enum : std::false_type {}; template <typename T> struct is_scoped_enum<T, true> : std::integral_constant<bool, !std::is_convertible<T, typename std::underlying_type<T>::type>::value> {};
It’s an comma-separated list of expressions, the type is identical to the type of the last expression in the list. It’s usually used to verify that the first expression is valid (compilable, think SFINAE), the second is used to specify that decltype should return in case the first expression is valid.
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
TL;DR There are several ways to get different run-time behavior dependent on a template parameter. Performance is usually equal, so flexibility and maintainability are the main concern. In all cases, the various thin wrappers and constant conditional expressions will all be optimized away on any decent compiler for release builds. Below a small summary with … Read more
You may create a trait for that: namespace detail { // To allow ADL with custom begin/end using std::begin; using std::end; template <typename T> auto is_iterable_impl(int) -> decltype ( begin(std::declval<T&>()) != end(std::declval<T&>()), // begin/end and operator != void(), // Handle evil operator , ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++ void(*begin(std::declval<T&>())), // operator* std::true_type{}); template <typename T> std::false_type … Read more
Actually, things got much easier in C++11 thanks to the decltype and late return bindings machinery. Now, it’s just simpler to use methods to test this: // Culled by SFINAE if reserve does not exist or is not accessible template <typename T> constexpr auto has_reserve_method(T& t) -> decltype(t.reserve(0), bool()) { return true; } // Used … Read more
Passing a pointer to base_all<U…> merely requires the existence of a declaration of base_all<U…>. Without attempting the to access the definition, the compiler won’t detect that the type is actually ill-defined. One approach to mitigate that problem would be to use an argument which requires a definition of base_all<U…>, e.g.: template< class …T> struct base_all … Read more
Define all_true as template <bool…> struct bool_pack; template <bool… v> using all_true = std::is_same<bool_pack<true, v…>, bool_pack<v…, true>>; And rewrite your constructor to // Check convertibility to B&; also, use the fact that getA() is non-const template<typename… Args, typename = std::enable_if_t<all_true<std::is_convertible<Args&, B&>{}…>> C(Args&… args) : member{args.getA()…} {} Alternatively, under C++17, template<typename… Args, typename = std::enable_if_t<(std::is_convertible_v<Args&, B&> … Read more
The answer given by Alexey Malistov can be used on MSVC with a minor modification: namespace { template<class T, int discriminator> struct is_complete { static T & getT(); static char (& pass(T))[2]; static char pass(…); static const bool value = sizeof(pass(getT()))==2; }; } #define IS_COMPLETE(X) is_complete<X,__COUNTER__>::value Unfortunately, the __COUNTER__ predefined macro is not part of … Read more