我如何专门化我的std :: string模板

Question

I have the following templated function

template <typename As, typename std::enable_if<
std::is_arithmetic<As>::value, As>::type* = nullptr   > 
As getStringAs(const std::string& arg_name)
{
    std::istringstream istr(arg_name);
    As val;
    istr >> val;
    if (istr.fail())
        throw std::invalid_argument(arg_name);
    return val;
}

And i would like to use it like this:

getStringAs<float>("2.f");

What would be a good way to specialize the function for std::string so that i can write

getStringAs<std::string>("2.f");

I have tried all my known ways but they all seem to fail due to the ambiguity generated by the default type of the std::enable_if . For example: if i write:

template<>
std::string getStringAs<std::string>(const std::string& arg_name)
{    
}

This will not match any template overload. If i add a second type, this will generate an ambiguity error. I have tried google-in but the only thing i could find was about tag dispatch but that would make the call ugly on the user side. I was thinking at the very ugly solution of using a macro definition for replacing getStringAs<std::string> with a dispatch tag.

Thank you!

Answer 1

I usually use function overloading to resolve such problems. It allows you to easily extend the functions for more types and you need to use SFINAE only where necessary (for example, for std::is_arithmetic ). Since you cannot overload by return type, this only works if you store the result in one of the arguments.

template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value>::type
getStringAsImpl(std::string const& in, T& out)
{
    std::istringstream sstr(in);
    sstr >> out;
    if (sstr.fail())
    {
        throw std::invalid_argument(in);
    }
}

void getStringAsImpl(std::string const& in, std::string& out)
{
    out = in;
}

template <typename T>
T getStringAs(std::string const& in)
{
    T out;
    getStringAsImpl(in, out);
    return out;
}

Answer 2

One way is to move the SFINAE to the return type:

template <typename As>
auto getStringAs(const std::string& arg_name)
    -> typename std::enable_if<std::is_arithmetic<As>::value, As>::type;

template <typename As>
auto getStringAs(const std::string& arg_name)
    -> typename std::enable_if<std::is_same<As, std::string>::value, As>::type;

Answer 3

but they all seem to fail due to the ambiguity generated by the default type of the enable_if

The problem is that if you write

template <> 
std::string getStringAs<std::string> (const std::string& arg_name)
 { return arg_name; }

the specialization doesn't match the main template because std::is_arithmetic<std::string>::value is false so the second template parameter isn't enabled.

A possible solution (I prefer the solution suggested by bolov, but just to explore other ways and better understand the problem) is to enable the second template parameter with std::string as follows

template <typename As, typename std::enable_if<
      std::is_arithmetic<As>::value 
   || std::is_same<As, std::string>::value, bool>::type = true> 
As getStringAs(const std::string& arg_name)
{
    std::istringstream istr(arg_name);
    As val;
    istr >> val;
    if (istr.fail())
        throw std::invalid_argument(arg_name);

    return val;
}

now you can full specialize as usual

template <> 
std::string getStringAs<std::string> (const std::string& arg_name)
 { return arg_name; }

Observe that std::string now matches both getStringAs() versions but the compiler choose the second because is more specialized.