Parsing a string in C ++

Without your homework for you, it will give you a good start. I gave you a basic workflow for parsing a vertex list, you have to make the edge list yourself. I also leave the error checking for you, for example in parseVertex () you can give an error if you encounter invalid characters.

void skipWhiteSpace(const char*& first , const char* last) {
    // do whatever need to be done to skip white space
}

// parse integer only, no error checking is performed
bool parseVertex(const char*& first , const char* last) {
    skipWhiteSpace(first, last);
    const char* numBegin = first;
    for (; first != last && ::isdigit(static_cast<unsigned char>(*first)); 
        ++first) {}
    if (numBegin != first) {
        std::cout << "addVertex(" << std::string(numBegin, first) << ")" << std::endl;
        return true;
    }

    return false;
}

bool parseComma(const char*& first , const char* last) {
    skipWhiteSpace(first, last);
    if (first != last && ',' == *first) {
        ++first;
        return true;
    }

    return false;
}

// VL := V (, VL)
// a vertex list (VL) is a vertex (V) followed by a comma than another vertex list
bool parseVertexList(const char*& first, const char* last) {
    if (parseVertex(first, last)) {
        parseComma(first, last) && parseVertexList(first, last);
        return true;
    }

    return false;
}
}

void test() {
    const char* str = "1,2,3,4,15";
    parseVertexList(str, str + sizeof("1,2,3,4,15"));
}

      

        
        
        
      

    

Analyzing this sort of thing is pretty easy (albeit tedious) with recursive descent techniques. The idea is to split the language that is parsed into logical units, and then write a function to parse each of those units.

If we indicate in the example "| 1,2,3,4,15 | (1-> 2), (3-> 2), (4-> 15) |" that the whole string is a "polygon", we will write parsePolygon (), which will look something like this:

void parsePolygon (Buffer& b)
{
  parseVertices (b);
  parseEdges (b);
}

      

        
        
        
      

    

Suppose Buffer is a class that goes through your string. You will need two basic operations: look into the next symbol without consuming it, and use the next symbol.

parseVertices might look like this:

void parseVertices (Buffer& b)
{
  if (b.peek() != '|') { /* error */ }
  b.consume (); // burn the '|'
  parseVertexList (b);
  if (b.peek() != '|') { /* error */ }
  b.consume (); // burn the '|'
}

      

        
        
        
      

    

You want to handle errors much better, of course. If the thread encounters any error, it needs to pass the error code onto the call stack or throw an exception.

Two more examples ... parseVertexList and parseNumber might look like this:

void parseVertexList (Buffer& b)
{
  addVertex (parseNumber (b));
  while (b.peek() == ',')
  {
     b.consume (); // eat the comma
     addVertex (parseNumber (b));
  }
}

int parseNumber (Buffer& b)
{
  char accum[80] = { '0' };  // sensible default in case of failure
  int accumPos = 0;
  while (isDigit (b.peek())
  {
    accum[accumPos++] = b.consume();
  }
  return atoi(accum);
}

      

        
        
        
      

    

It's very quick and messy, but hopefully it gives you an idea of ​​how this technique works. You can mix the processing with your parsing as shown above, where the parseVertexList function actually makes the addVertex calls for you.

I think this is really one of the simplest manual parsing methods. Ideally, we can always use created parsers like boost spirit or pyparsing or lex / yacc, but life isn't always good, especially for homework.

Also, I suppose it's worth noting that the above technique may be a lot overkill for some parsing situations.

Use stringstream

. Check out the example on this page for reading in numbers using istringstream

.