带有VC ++编译器的SFINAE

Question

I'm currently trying to compile a simple SFINAE structure with VC++ compiler. My version (according to the cl command) is

Microsoft (R) C/C++ Optimizing Compiler Version 19.00.24215.1 for x86

this code compiles fine on clang

// Example program
#include <iostream>
#include <string>
#include <typeinfo>

struct spString
{
    template <class... T>
    spString format(T...) { return spString(); }
    const char* c_str() { return nullptr; }

    spString operator+(spString) { return spString(); }
    spString operator+(const char*) { return spString(); }
};

struct debuggable
{
    spString getDebugString() { return spString(); }
};

void fromFloat(spString, float&) {}
void fromInt(spString, int&) {}


template <class T> inline auto from( T v )
    -> decltype( v.getDebugString(), spString() )
{
    return v.getDebugString();
}
template <class T> inline auto from( T v )
    -> decltype( v->getDebugString(), spString() )
{
    spString r;
    r.format( "%u (%s)", (size_t) v, v->getDebugString().c_str() );
    return  r;
}
template <class T> inline spString from( T v )
{
    return spString("(") + typeid(T).name() + " instance)"; 
}
template <> inline spString from( float _v          ) { spString _d;  fromFloat         ( _d, _v ); return _d; }
template <> inline spString from( int _v            ) { spString _d;  fromInt           ( _d, _v ); return _d; }
//other base types

int main()
{
    debuggable x{};

    from(0);
    from(0.f);
    from(x);
}

but will fail on Microsoft's compiler. Noe that I can't use another version and I'm stuck with the one I'm using right now. I always had mitigated success with SFINAE on this compiler but I don't see how to easily "fix" this code.

the expected result is to get a debug string representation of something, if it has a getDebugString, use this method, if it's a base type, use a custom method, otherwise, just print the type's name.

Do you see any way to achieve that with my version of visual studio?

Answer 1

Here is the way to do what you want - tested with VC 19.00.24215.1.

Helper template to detected getDebugString() :

template <typename T>
auto has_getDebugString_impl(int) ->
    decltype(void(std::declval<T>().getDebugString()), std::true_type{});

template <typename T>
auto has_getDebugString_impl(...) -> std::false_type;

template <typename T>
struct has_getDebugString: decltype(has_getDebugString_impl<T>(0)) { };

Combined with std::enable_if :

template <class T>
inline std::enable_if_t < has_getDebugString<T>::value, spString > from(T v) {
    return v.getDebugString();
}

template <class T> 
inline std::enable_if_t < has_getDebugString<T>::value, spString > from(T *v) {
    spString r;
    r.format("%u (%s)", (size_t)v, v->getDebugString().c_str());
    return  r;
}
template <class T>
inline std::enable_if_t < ! has_getDebugString<T>::value, spString > from(T v) {
    return spString("(") + typeid(T).name() + " instance)"; 
}

And overload (not specialized template) for specific types:

inline spString from(float _v) { spString _d;  fromFloat(_d, _v); return _d; }
inline spString from(int _v) { spString _d;  fromInt(_d, _v); return _d; }

This is not the prettiest code, and there may be more straightforward way, but I had to deal with some issue in VC...

Note: You can use enable_if inside a default template parameter instead of as a return type if you want:

template <class T, class = std::enable_if_t<has_getDebugString<T>::value>>
inline spString from(T v) {
    return v.getDebugString();
}