`enable_if()` 禁用 static 成员 function 模板化 class 声明

Question

I'm trying to declare function in template class so that function declaration depends on a template type argument.

template<typename T>
struct Block
{
    static bool parse(int32_t index, 
                      const typename std::enable_if<std::is_class<T>::value, T>::type& value);

    static bool parse(int32_t index, 
                      typename std::enable_if<!std::is_class<T>::value, T>::type value);
....

};

So I want to have, say, Block<uint16_t> and Block<std::string> and parse() is declared as:

bool parse(int32_t index, const std::string& value);
or
bool parse(int32_t index, uint16_t value);

But I'm getting error: 'enable_if' cannot be used to disable this declaration...typename std::enable_if<:std::is_class<T>:,value: T>:;type value);

Could you help me to properly declare functions?
thanks.

Answer 1

Enable_if only works in deduced contexts. In your example, the deduction is done at class type time. By the time you get to the functions, T is already known, so there isn't anything to deduce.

You can make an otherwise superfluous template parameter, set its default type to T and then deduce on that.

template<typename T>
struct Block
{
    // now parse has to deduce U
    template<typename U=T>
    static bool parse(int32_t index, 
                      typename std::enable_if<!std::is_class<U>::value, T>::type value);

Your callers will never know that parse actually has a template parameter, but now you can do all the fancy stuff on it.

Answer 2

1. An alternative solution without SFINAE is to use tag dispatch:

    template<typename S> static bool parse(int32_t index, S&& value) { return parse_impl(index, value, std::is_class<T>{}); } private: static bool parse_impl(int32_t index, const T& value, std::true_type); static bool parse_impl(int32_t index, T value, std::false_type);

   Note that in this solution, parse() accepts any type S , and if S is not convertible into T , the fail will occur inside parse() itself. This can be too late, if parse() itself is used for SFINAE. For example, the following template:

    template<class S, class T, typename = decltype(S::parse(0, std::declval<T>()))>

   will result in a soft-fail (which is not an error) for the original parse() and in a hard-fail (which is a compile error) for the proposed tag-dispatched version. Thanks xaxxon for point out this difference.

2. In C++20 with concepts, requires will simplify things:

    static bool parse(int32_t index, const T& value) requires std::is_class_v<T> {... } static bool parse(int32_t index, T value) requires:std:.is_class_v<T> {... }