Error trying to implement type checking with SFINAE

user_13201964 0
Viewed 38

I was following Jean Guegant's SFINAE blog post, where he implements a type trait using sizeof() which checks if there is a serialize function in the class. Inside which he has this reallyHas struct which checks if serialize is just a member of the class or an actual member function, by doing this

template<typename T>
struct has_serialize {
    typedef char yes[1];
    typedef char no[2];

    template<typename U, U u> struct reallyHas{}; 

    template <typename C>
    static yes& test(reallyHas<string (C::*)(), &C::serialize>*){}

    // for const method
    template<typename C>
    static yes& test(reallyHas<string (C::*)() const, &C::serialize>*){}

    template<typename> // variadic template
    static no& test(...){} // sink hole

    enum {
         value = (sizeof(test<T>(0)) == sizeof(yes))
    };
};

This works fine only when the test function has the signature of

template <typename C>
static yes& test(reallyHas<string (C::*)(), &C::serialize>*){}

But not when

template <typename C>
static yes& test(reallyHas<string (C::*)(), &C::serialize>){}

I don't really understand the significance of the * in the argument, In the end we are just checking if the substitution happens or not, so shouldn't it work in both the cases

typetraits sfinae c++
1 Answers

Simplifying, the principle of SFINAE is to provide a few candidates for a symbol (overloads, template specializations etc.). Then, for a given argument the compiler will try out every candidate one at a time, until it finds the best match.

In this case, the test function is used for SFINAE. The goal is to have it defined in such a way that for types with a serialize member function it will resolve to a function test that returns a yes type and for a function returning the no type otherwise.

The example shown above accomplishes this by using a trick where 0 gets converted to a pointer. It is possible for such a conversion to occur by the rules of the language.

When test<T>(0) gets called, the compiler will first look at the first overload and by substituting T will end up with a function that looks something like this:

static yes& test(reallyHas<string (T::*)(), &T::serialize>*){}

The compiler will now see if this overload can be chosen. It will see if 0 (int) can be converted to reallyHas<string (T::*)(), &T::serialize>*. As ints can be converted to pointers an error will occur only if the type reallyHas<string (T::*)(), &T::serialize>* would be ill-formed. This is the case if T doesn't have an appropriate a member function &T::serialize that can be converted to the function pointer string (T::*)(). For example for using T = int, it would fail as int isn't even a class type.

If the substitution fails, the compiler will analogically try the second overload and finally the third one. As the third one is declared as static no& test(...){} it can accept any arguments. In this case it could just as well be declared as static no& test(unsigned){} as 0 is convertible to unsigned.

Now notice what happens if you would change the first overload to this:

template <typename C>
static yes& test(reallyHas<string (C::*)(), &C::serialize>){}

Now the substitution failure will happen always (even if T has a member serialize function) as 0 (int) is not convertible to a class type reallyHas<T>.

user_125016840
Related