Parsing a non-uniform string into integers - c++

Question

I am writing a parser for .obj files, and there is a part of the file that is in the format
f [int]/[int] [int]/[int] [int]/[int]
and the integers are of unknown length. In each [int]/[int] pair, they both need to be put onto separate arrays. What is the simplest method to separate them as integers?

Answer 1

You can do it with fscanf:
int matched = fscanf(fptr, "f %d/%d %d/%d %d/%d", &a, &b, &c, &d, &e, &f);
if (matched != 6) fail();
or ifstream and sscanf:
char buf[100];
yourIfstream.getLine(buf, sizeof(buf));
int matched = sscanf(buf, "f %d/%d %d/%d %d/%d", &a, &b, &c, &d, &e, &f);
if (matched != 6) fail();

Answer 2

Consider using one of the scanf functions (fscanf if you are reading the file using <stdio.h> and FILE*, or sscanf to parse a line in memory buffer).
So, if you have a buffer with data and two integer arrays like this:
int first[3], second[3];
char *buffer = "f 10/20 1/300 344/2";
Then you can just write:
sscanf(buffer, "f %d/%d %d/%d %d/%d",
&first[0], &second[0], &first[1], &second[1], &first[2], &second[2]);
(The spaces in sscanf's input pattern are not necessary as %d skips the spaces, but they improve readability.)
If you need error checking, then analyse the result of sscanf: this function returns number of successfully entered values (6 for this example if everything was correct).

Answer 3

I would use regular expressions for this. If you have a C++11-compliant compiler you can use , otherwise you can look in to boost::regex. In Perl-like syntax, your regular expression pattern would look something like this: f ([0-9]+)/([0-9]+) ([0-9]+)/([0-9]+) ([0-9]+)/([0-9]+). Then you take the sub matches in turn (what's inside the parathesis) and convert them from string or char* to integer with istringstream.

Answer 4

#include <stdlib.h>
long int strtol(const char *nptr, char **endptr, int base);
long long int strtoll(const char *nptr, char **endptr, int base);
The strtol function will both parse an integer from input, and return the place where the integer ends in the string. You could use it like
char *input = "f 123/234 234/345 345/456"
char *c = input;
char *endptr;
if (*c++ != 'f') fail();
if (*c++ != ' ') fail();
long l1 = strtol(c, &endptr, 10);
if (l1 < 0) fail(); /* you expect them unsigned, right? */
if (endptr == c) fail();
if (*endptr != '/') fail();
c = endptr+1;
...

Answer 5

The easiest way would be to use C++11 regular expressions:
static const std::regex ex("f (-?\\d+)//(-?\\d+) (-?\\d+)//(-?\\d+) (-?\\d+)//(-?\\d+)");
std::smatch match;
if(!std::regex_match(line, match, ex))
throw std::runtime_error("invalid face data");
int v0 = std::stoi(match[1]), t0 = std::stoi(match[2]),
v1 = std::stoi(match[3]), t1 = std::stoi(match[4]),
v2 = std::stoi(match[5]), t2 = std::stoi(match[6]);
While this might be sufficient for your case, I can't help adding a more flexible way to read those index tuples, which better copes with non-triangular faces and different face specification formats. For this we assume you have already put the face line into a std::istringstream and already ate away the face tag. This is usually the case, since the easiest way to read an OBJ file is still:
for(std::string line,tag; std::getline(file, line); )
{
std::istringstream sline(line);
sline >> tag;
if(tag == "v")
...
else if(tag == "f")
...
}
To now read the face data (inside the "f" case of course) we first read each single index tuple individually. Then we just parse this index using regular expressions for each possible index format and handle them appropriately, returning the individual vertex, texcoord and normal indices in a 3-element std::tuple:
for(std::string corner; sline>>corner; )
{
static const std::regex vtn_ex("(-?\\d+)/(-?\\d+)/(-?\\d+)");
static const std::regex vn_ex("(-?\\d+)//(-?\\d+)");
static const std::regex vt_ex("(-?\\d+)/(-?\\d+)/?");
std::smatch match;
std::tuple<int,int,int> idx;
if(std::regex_match(corner, match, vtn_ex))
idx = std::make_tuple(std::stoi(match[1]),
std::stoi(match[2]), std::stoi(match[3]));
else if(std::regex_match(corner, match, vn_ex))
idx = std::make_tuple(std::stoi(match[1]), 0, std::stoi(match[2]));
else if(std::regex_match(corner, match, vt_ex))
idx = std::make_tuple(std::stoi(match[1]), std::stoi(match[2]), 0);
else
idx = std::make_tuple(std::stoi(str), 0, 0);
//do whatever you want with the indices in std::get<...>(idx)
};
Of course this offers possibilities for performance-guided optimizations (if neccessary), like eliminating the need for allocating new strings and streams in each and every loop iteration. But it is the easiest way to privide the flexibility neccessary for a proper OBJ loader. But it may also be that the above version for triangles with vertices and texcoords only is sufficient for you already.