SFINAE - Trying to determine if template type has member function with 'variable' return type

c++, c++11, sfinae, templates, visual-c++

Solution

Are you asking how to implement such a trait, or why `decltype` isn't behaving as you expect? If the former, here's one approach:

#include <type_traits>

template<typename T, bool DisableB = std::is_fundamental<T>::value>
struct HasOperatorMemberAccessor
{ 
private:
    typedef char no;
    struct yes { no m[2]; };

    struct ambiguator { char* operator ->() { return nullptr; } };
    struct combined : T, ambiguator { };
    static combined* make();

    template<typename U, U> struct check_impl;
    template<typename U>
    static no check(
        U*,
        check_impl<char* (ambiguator::*)(), &U::operator ->>* = nullptr
    );
    static yes check(...);

public:
    static bool const value=std::is_same<decltype(check(make())), yes>::value;
};

// false for fundamental types, else the definition of combined will fail
template<typename T>
struct HasOperatorMemberAccessor<T, true> : std::false_type { };

// true for non-void pointers
template<typename T>
struct HasOperatorMemberAccessor<T*, false> :
    std::integral_constant<
        bool,
        !std::is_same<typename std::remove_cv<T>::type, void>::value
    >
{ };

template<typename X>
struct PointerX
{
    X* operator ->() const { return nullptr; }
};

struct X { };

int main()
{
    static_assert(
        HasOperatorMemberAccessor<PointerX<bool>>::value,
        "PointerX<> has operator->"
    );
    static_assert(
        !HasOperatorMemberAccessor<X>::value,
        "X has no operator->"
    );
    static_assert(
        HasOperatorMemberAccessor<int*>::value,
        "int* is dereferencable"
    );
    static_assert(
        !HasOperatorMemberAccessor<int>::value,
        "int is not dereferencable"
    );
    static_assert(
        !HasOperatorMemberAccessor<void*>::value,
        "void* is not dereferencable"
    );
}

VC++ 2010 lacks the necessary C++11 facilities (e.g. expression SFINAE) needed to make this much cleaner.

Problem

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 GetReturnType( R ( C::*)()const); template<typename U, typename R, R(U::*)()const> struct SFINAE{}; template<typename U> static char Test(SFINAE<U, decltype( GetReturnType(&U::operator->)), &U::operator-> >*); template<typename U> static uint Test(...); static const bool value = sizeof(Test<T>(0)) == sizeof(char); }; ``` This class is the exact same as above except that operator-> return type has to be 'Object'. ``` template<typename T> struct HasOperatorMemberAccessorOBJECT { template <typename R, typename C> static R GetReturnType( R ( C::*)()const); template<typename U, typename R, R(U::*)()const> struct SFINAE{}; template<typename U> static char Test(SFINAE<U, Object*, &U::operator-> >*); // only change is we hardcoded Object as return type. template<typename U> static uint Test(...); static const bool value = sizeof(Test<T>(0)) == sizeof(char); }; ``` Results: ``` void main() { HasOperatorMemberAccessor<PointerX<Object>>::Test<PointerX<Object>>(0); // fails ::value is false; Test => Test(...) HasOperatorMemberAccessorOBJECT<PointerX<Object>>::Test<PointerX<Object>>(0); // works! ::value is true; Test => Test(SFINAE<>*) } ``` HasOperatorMemberAccessor was unable to find PointX's member function "Object operator->() const". So it uses Test's generic version Test(...). However, HasOperatorMemberAccessorOBJECT was able to find PointX's "Object operator->() const". Thus it uses Test specialized version Test(SFINAE*). Both should have been able to find the "Object operator->() const" method; and thus both should use Test's specialized version Test(SFINAE*); and thus HasOperatorMemberAccessor>::value should be true for both. The only difference between HasOperatorMemberAccessor and HasOperatorMemberAccessorOBJECT is that HasOperatorMemberAccessorOBJECT has the typename R hardcoded to object, So the issue is that "decltype( GetReturnType(&U::operator->))" is not returning Object correctly. I've tried a number of different permitations of discovering the return type. They go as follows: ``` decltype( GetReturnType(&U::operator->) ) typename decltype( GetReturnType(&U::operator->)) decltype( ((U*)nullptr)->operator->() ) typename decltype( ((U*)nullptr)->operator->() ) ``` None work, why? I'm using MSVC++ 10.0.

Original source