防止实例化字符串流提取运算符（>>）不支持的类型的模板类

Question

I'm trying to learn a bit about templates and metafunctions, namely std::enable_if . I'm making a menu system for our school assignments (extracurricular, mind you), and need a way of getting input from the user. I'd like to define a template class for various types of input - something used along the lines of:

std::string userInput = Input<std::string>("What's your name?").Show();
float userHeight = Input<float>("How tall are you?").Show();

I'd like to (and I'm sure there are reasons not to, but nevertheless) do this generalized sort of conversion using a std::stringstream : get input from user, feed into SS, extract into variable of type T.

It's easy enough to see if the conversion failed during runtime, but I'd like to use std::enable_if to prevent people from using my Input<> class for cases where conversion is impossible, say:

std::vector<Boats> = Input<std::vector<>>("Example").Show();

Obviously a std::stringstream cannot convert a string to a vector, so it will always fail.

My question is this:

Can I format an std::enable_if clause to ONLY allow instantiation of my template class for the types listed above? Alternatively, is there a better way to go about it? Have I got things completely the wrong way around?

What I've done so far

I believe I have found a list of allowed types that std::stringstream can "convert" a string into:

http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/

I've been using std::enable_if like this up until this point:

template <typename T, typename = typename 
std::enable_if<std::is_arithmetic<T>::value, T>::type>

However, now I'd like to extend it to allow not only arithmetic values, but all values supported by the sstream >> operator.

Answer 1

If you prefer to use a SFINAE with a class template parameter, then you want

template <
    typename T,
    typename = decltype(std::declval<std::istringstream &>() >> std::declval<T &>(), void())
>
class Input /*...*/

Answer 2

I think that you are trying to use std::enable_if for something which doesn't require it. If your template function already relies on operator<< applied on a generic type T , then compilation will fail in any case if the operator is not specialized for that type.

Nothing prevents you from using std::enable_if to solve your specific problem, though that may be not the best way to do it.

If C++20 concepts were already largely adopted I'd say that that would be your way to go.

Answer 3

You could go the way as suggested here on SO and implement a class is_streamable which can check for that like this:

#include <type_traits>
#include <utility>
#include <iostream>
#include <sstream>

template<typename S, typename T>
class is_streamable
{
    template<typename SS, typename TT>
    static auto test(int)
        -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());

    template<typename, typename>
    static auto test(...)->std::false_type;

public:
    static const bool value = decltype(test<S, T>(0))::value;
};

class C
{
public:
    friend std::stringstream& operator<<(std::stringstream &out, const C& c);
};

std::stringstream& operator<<(std::stringstream& out, const C& c)
{
    return out;
}


int main() {
    std::cout << is_streamable<std::stringstream, C>::value << std::endl;
    return 0;
}

This would return one if the operator is implemented and zero if not.

With that you can alter your snippet to

template <typename T, typename = typename 
std::enable_if<is_streamable<std::stringstream, C>::value, T>::type>

Answer 4

There are several thing you want:

• a trait, is_streamable
• a way to forbid class instantiation.

For the traits, you might use std::experimental_is_detected or run your own:

template <typename T>
auto is_streamable_impl(int)
-> decltype (T{},
             void(), // Handle evil operator ,
             std::declval<std::istringstream &>() >> std::declval<T&>(),
             void(), // Handle evil operator ,
             std::true_type{});

template <typename T>
std::false_type is_streamable_impl(...); // fallback, ... has less priority than int

template <typename T>
using is_streamable = decltype(is_streamable_impl<T>(0));

Then to forbid intantiation, several choices:

static_assert :

template <typename T>
class Input
{
    static_assert(is_streamable<T>::value);
    // ...
};

or SFINAE friendly class:

template <typename T, typename = std::enable_if_t<is_streamable<T>>>
class Input
{
    // ...
};

so you allow to know if Input<T1> is valid.

Notice that without all that stuff, your program won't compile anyway when instantiating the problematic method (hard error, so no SFINAE friendly).

Being SFINAE friendly is not necessary most of the time.