sfinae

Can generic lambdas take advantage of the "Substitution Failure Is Not An Error" rule ? Example auto gL = [](auto&& func, auto&& param1, auto&&... params) -> enable_if_t< is_integral< std::decay_t<decltype(param1)> >::value> { // ... }; auto gL = [](auto&& func, auto&& param1, auto&&... params) -> enable_if_t< !is_integral< std::decay_t<decltype(param1)> >::value> { // ... }; Are there any workarounds or plans to include this in the language ? Also since generic lambdas are templated function objects under the hood isn't it a bit odd that this can't be done ? Lambdas are function objects under

Having trouble with SFINAE. I need to be able to determine if a Type has a member function operator-> defined regardless of its return type. Example follows. This class in the tester. It defines operator->() with a return type of X*. I thus will not know what 'X' is to hardcode it everywhere. template <class X> class PointerX { ... X* operator->() const; ... } This class tries to determines if the passed in T has a method operator-> defined; regardless of what operator-> return type is. template<typename T> struct HasOperatorMemberAccessor { template <typename R, typename C> static R

Let's say you have these two classes: class A { public: int a; int b; } class B { public: int a; int b; } class C { public: float a1; float b1; } enum class Side { A, B }; I want a template function which takes a side and a T , and depending on the T , returns a reference to " T.a " or " T.b " if the class has a member T::a , or a reference to " T.a1 " or " T.b1 " if the class has a member T::a1 . My starting point is: template<typename T> auto &GetBySide(const Side &side, const T &twoSided) { return side == Side::A?twoSided.a:twoSided.b; } template<typename T> auto &GetBySide(const Side &side

This question already has answers here : Closed 6 years ago . Is it possible to write a template to check for a function's existence? (25 answers) In C++11, to find out whether a class has a member function size , you could define the following test helper: template <typename T> struct has_size_fn { typedef char (& yes)[1]; typedef char (& no)[2]; template <typename C> static yes check(decltype(&C::size)); template <typename> static no check(...); static bool const value = sizeof(check<T>(0)) == sizeof(yes); }; Is there a similar trick for doing this in C++98 without relying on compiler

Does an expression in noexcept specifier's parentheses participate in SFINAE during overload resolution of function templates? I want to make an wrapper for aggregates and want the std::is_constructible predicate to work properly for it: template< typename type > struct embrace : type { template< typename ...arguments > embrace(arguments &&... _arguments) noexcept(noexcept(type{std::forward< arguments >(_arguments)...})) : type{std::forward< arguments >(_arguments)...} // braces { ; } }; int main() { struct S { int i; double j; }; // aggregate using E = embrace< S >; E b(1, 1.0); //

I have a base taking derived type as template parameter. The following code works as expected. instantiation of base<non_default_impl> uses non_default_impl::data_t and base<default_impl> throws compilation error because event_data is only a forward declaration. template <typename T> struct event_data; template<typename T> struct tovoid { typedef void type; }; template <typename T, typename enable = void> struct get_data{ typedef event_data<T> type; }; template <typename T> struct get_data<T, typename tovoid<typename T::data_t>::type >{ typedef typename T::data_t type; }; template <typename T>