sfinae

TLDR: See the last paragraph. I have an operator& defined for several template classes like so: template <typename T> struct Class { Class(T const &t) { } }; template <typename T_Lhs, typename T_Rhs> struct ClassAnd { ClassAnd(T_Lhs const &lhs, T_Rhs const &rhs) { } }; template <typename T, typename T_Rhs> ClassAnd<Class<T>, T_Rhs> operator&(Class<T> const &lhs, T_Rhs const &rhs) { return ClassAnd<Class<T>, T_Rhs>(lhs, rhs); } template <typename T0, typename T1, typename T_Rhs> ClassAnd<ClassAnd<T0, T1>, T_Rhs> operator&(ClassAnd<T0, T1> const &lhs, T_Rhs const &rhs) { return ClassAnd<ClassAnd

Why this code (fnc value in class M) do not get resolved by SFINAE rules? I'm getting an error: Error 1 error C2039: 'type' : is not a member of 'std::tr1::enable_if<_Test,_Type>' Of course type is not a member, it isn't defined in this general ver of enable_if but isn't the whole idea behind this to enable this ver of fnc if bool is true and do not instantiate it if it's false? Could please someone explain that to me? #include <iostream> #include <type_traits> using namespace std; template <class Ex> struct Null; template <class Ex> struct Throw; template <template <class> class Policy>

I'm working with some SFINAE features; currently in a portion of an application that must run in Linux and Windows; the compiler choices are MSVC (Visual Studio 2010 10.0) for Windows applications and GCC 4.4.5 for the Linux ones. I must check if some given object provides some functions to perform a custom serialization and call this functions, or do a simple memcpy and sizeof(Object) while the custom serialization methods are not provided. The problem is that a piece of code compile without warnings nor errors in MSVC but while compiling with GCC, the code is the following: template <

I was wondering if it's possible to extend the SFINAE approach to detecting whether a class has a certain member function (as discussed here: "Is there a Technique in C++ to know if a class has a member function of a given signature?" Check if a class has a member function of a given signature ) to support templated member functions? E.g. to be able to detect the function foo in the following class: struct some_class { template < int _n > void foo() { } }; I thought it might be possible to do this for a particular instantiation of foo, (e.g. check to see if void foo< 5 >() is a member) as

Update I posted a working rough draft of rebind as an answer to the question. Though I didn't have much luck finding a generic way to keep static_assert s from breaking metafunctions. Basically I want to check if a templated type T<U, Args...> can be constructed from some other type T<V, Args...> . Where T and Args... is the same in both types. The problem is, T<> might have a static_assert in it that totally breaks my metafunction. Below is a rough summary of what I'm trying to do. template<typename T> struct fake_alloc { using value_type = T; }; template<typename T, typename Alloc = fake

I was halfway through working on this piece of code and thought this is obviously not going to compile before hitting the build button. I was surprised that it not only compiled, but linked and worked as well. If I were to guess I would say that SFINAE is responsible for it compiling... is it? struct BaseClass { public: BaseClass() {} template<typename T> BaseClass(const T& a_other) { int i = 0; // for break point } template<typename T> BaseClass& operator= (const T& a_other) { int i = 0; // for break point return *this; } private: BaseClass(const BaseClass& a_other); // Does not have a

So, I'm following the example set by the code somewhere on this web page: http://eli.thegreenplace.net/2014/sfinae-and-enable_if/ Here's what I have: template<typename T> void fun(const typename std::enable_if_t<std::is_integral<T>::value, T>& val) { std::cout << "fun<int>"; } template<typename T> void fun(const typename std::enable_if_t<std::is_floating_point<T>::value, T>& val) { std::cout << "fun<float>"; } int main() { fun(4); fun(4.4); } This way I would have to write: fun<int>(4); fun<double>(4.4); How would I avoid that? Compiler complains that it can't deduce the parameter T . Piotr

I learned SFINAE can be used to determine whether a member function exists in a class or not. For example, the following code can be used to check if the method hello is present in a class. struct has_method_hello { using yes = char[1]; using no = char[2]; template <typename U, typename C> static constexpr yes& test(decltype(&U::hello)); template <typename> static constexpr no& test(...); static constexpr bool value = (sizeof(yes) == sizeof(test<T>(nullptr))); }; struct Foo { void hello() {} } std::cout << has_method_hello <Foo> :: value << std::endl; // 1 However, suppose the hello is