Question

Consider I have the following “pair of floats” object input format: (first variable, second variable) e.g. (1.0, 15.6).

What’s the best way reading such structures? In C I would use scanf(“(%f, %f)”, &var1, &var2) – pretty nice, isn’t it?(yes, I know it doesn’t provide type safety and so on)

But I know only one way to do that using C++ streams:

float var1, var2;
char tmp;
cin >> tmp;
cin >> var1;
cin >> tmp;
cin >> var2;
cin >> tmp;

Seems ugly, and it’s just a pair of floats. So, is there an elegant way to do that? Like

cin >> "(" >> var1 >> ", " >> var2 >> ")";

Answer 1

I would write an input operator:
Stealing FloatPair from @Seth Carnegie.

Thus input now looks normal:

FloatPair c;
std::cin >> c;

I would make it look like this.

std::istream& operator>>(std::istream& stream, FloatPair& out)
{
    return stream >> I('(') >> out.a >> I(',') >> out.b >> I(')');
}

Then I have an ignore object like this.
It is simple to templatise if you wish. And to make the code slightly easier I call mine I

template<typename T>
struct ignore
{
    T ignoreItem;
    ignore(T const& x): ignoreItem(x) {}
};
template<typename T>
ignore<T> I(T const& x) { return ignore<T>(x);}  // This is where I in the above code comes from.

Then the input operator>> for the ignore looks like this.

std::istream& operator>>(std::istream& stream, ignore<T> const& test)
{
    T   next;
    if ((stream >> next) && (test.ignoreItem != next))       // if the stream already failed
    {    stream.setstate(std::ios::badbit);                 // then don't change anything
    }                                                       // as it may confuse people
    return stream;
}

A specialization for string. To handle the fact that operator>> on string only reads a word.
Note: in scanf() a space matches 1 or more spaces. Thus obeys the same rule if the input string has a space in it.

template<>
struct ignore<std::string>
{
    std::vector<std::string> ignoreItemVector;
    ignore(std::string const& x)
    {
        // Split the input into a list of words to ignore.
        std::stringstream  words(x);
        std::copy(std::istream_iterator<std::string>(words),
                std::istream_iterator<std::string>(words),
                std::back_inserter(ignoreItemVector)
                );
    }
};
template<>
std::istream& operator>><std::string>(std::istream& stream, ignore<std::string> const& test)
{
    // Specifically ignore each word.
    foreach(std::string const& loop, test.ignoreItemVector)
    {
        std::string   next;
        if ((stream >> next) && (loop != next))       // if the stream already failed
        {    stream.setstate(std::ios::badbit);      // then don't change anything
        }                                            // as it may confuse people
    }
    return stream;
}