C++ alternative for parsing input with sscanf

Question

Assuming my program expects arguments of the form [ 0.562 , 1.4e-2 ] (i.e. pairs of floats), how should I parse this input in C++ without regular expressions? I know there are many corner cases to consider when it comes to user input, but let's assume the given input closely matches the above format (apart from further whitespace).

In C, I could do something like sscanf(string, "[%g , %g]", &f1, &f2); to extract the two floating point values, which is very compact.

In C++, this is what I've come up with so far:

std::string s = "[ 0.562 , 1.4e-2 ]"; // example input

float f1 = 0.0f, f2 = 0.0f;

size_t leftBound = s.find('[', 0) + 1;
size_t count = s.find(']', leftBound) - leftBound;

std::istringstream ss(s.substr(leftBound, count));
string garbage;

ss >> f1 >> garbage >> f2;

if(!ss)
  std::cout << "Error while parsing" << std::endl;

How could I improve this code? In particular, I'm concerned with the garbage string, but I don't know how else to skip the , between the two values.

To answer your question, you can improve the code by using `sscanf()`. If you can't use sscanf(), then you should state the reason. In that case, the question has been asked many times before, see http://stackoverflow.com/questions/1033207/what-should-i-use-instead-of-sscanf — Daniel, Apr 25 '14 at 22:40
Unfortunately C++ is more verbose than C. If you have a C++11 compiler you might want to look into [regular expression](http://en.cppreference.com/w/cpp/regex) though. — Some programmer dude, Apr 25 '14 at 22:46
@JoachimPileborg I don't think regexes should be recommended for parsing floating point data. — sehe, Apr 25 '14 at 23:07

score 8 · Accepted Answer · answered Apr 26 '14 at 00:13

The obvious approach is to create a simple manipulator and use that. For example, a manipulator using a statically provided char to determine if the next non-whitespace character is that character and, if so, extracts it could look like this:

#include <iostream>
#include <sstream>

template <char C>
std::istream& expect(std::istream& in)
{
    if ((in >> std::ws).peek() == C) {
        in.ignore();
    }
    else {
        in.setstate(std::ios_base::failbit);
    }
    return in;
}

You can then use the thus build manipulator to extract characters:

int main(int ac, char *av[])
{
    std::string s(ac == 1? "[ 0.562 , 1.4e-2 ]": av[1]);
    float f1 = 0.0f, f2 = 0.0f;

    std::istringstream in(s);
    if (in >> expect<'['> >> f1 >> expect<','> >> f2 >> expect<']'>) {
        std::cout << "read f1=" << f1 << " f2=" << f2 << '\n';
    }
    else {
        std::cout << "ERROR: failed to read '" << s << "'\n";
    }
}

I think it's unlikely that all your tokens will be nicely space separated like that. — Timmmm, Apr 10 '17 at 09:45

sehe · Answer 2 · 2019-07-10T11:35:52.147

7

I you can afford to use boost, you could use Spirit.

See

From a string Live On Coliru (in c++03):
Update And here's the approach if you were actually trying to read from a stream (it's actually somewhat simpler, and integrates really well with your other stream reading activities):
Live On Coliru too (c++03)

Allthough this seems more verbose, Spirit is also a lot more powerful and type-safe than sscanf. And it operates on streams.

Also note that inf, -inf, nan will be handled as expected.

Live On Coliru

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_match.hpp>
#include <sstream>

namespace qi = boost::spirit::qi;

int main()
{
    std::istringstream ss("[ 0.562 , 1.4e-2 ]"); // example input
    ss.unsetf(std::ios::skipws); // we might **want** to handle whitespace in our grammar, not needed now

    float f1 = 0.0f, f2 = 0.0f;

    if (ss >> qi::phrase_match('[' >> qi::double_ >> ',' >> qi::double_ >> ']', qi::space, f1, f2))
    {
        std::cout << "Parsed: " << f1 << " and " << f2 << "\n"; // default formatting...
    } else
    {
        std::cout << "Error while parsing" << std::endl;
    }
}

edited Jul 10 '19 at 11:35

answered Apr 25 '14 at 23:06

sehe

374,641
47
450
633

1

Great answer, I didn't know how powerful Spirit was until now. I'm going to accept Dietmar Kühl's answer, though, because I cannot use boost in this specific case. But I'll keep this in mind for later use. – ph4nt0m Apr 26 '14 at 08:20
Unfortunately that code doesn't work anymore. Compiler is showing an error "Use of overloaded operator '>>' is ambigous". Would you know why? – Alan Kałuża Jul 09 '19 at 15:09
Oh also, it spits this error only when I pass f1 and f2 as arguments. Without them i.e. `if (ss >> qi::phrase_match('[' >> qi::double_ >> ',' >> qi::double_ >> ']', qi::space))` there is no ambiguity error. – Alan Kałuża Jul 09 '19 at 15:17
Added a link to demo [Live On Coliru](http://coliru.stacked-crooked.com/a/8c4a69ecd08ccce0). What's different for you @AlanKałuża? – sehe Jul 10 '19 at 11:36

score 2 · Answer 3 · answered Apr 25 '14 at 23:07

Other than regular expressions, there's probably something in Boost you can use. But if you can't use Boost then you can define a std::ctype<char> facet that effectively ignores all unnecessary characters by classifying them as whitespace. You can install this facet into a locale and imbue it into ss.

C++ alternative for parsing input with sscanf

3 Answers3

Linked