C ++: parsing a string of numbers with parentheses in it

The obvious solution is to use regular expressions (either std::regex

, in C ++ 11 or boost::regex

pre C ++ 11). Just grab the groups you are interested in and use std::istringstream

to transform them if necessary. In this case,

std::regex re( "\\s*\\d+\\s+\\d+\\s*\\((\\d+)\\s+([[:alpha:]]+))\\s*(\\d+)" );

      

        
        
        
      

    

Got to do the trick.

And regular expressions are really very simple; it will take you less time to learn them than to implement any alternative Solution.

For an alternative solution, you probably want to read the line character by breaking it down into tokens. Anything along the line:

std::vector<std::string> tokens;
std::string currentToken;
char ch;
while ( source.get(ch) && ch != '\n' ) {
    if ( std::isspace( static_cast<unsigned char>( ch ) ) ) {
        if ( !currentToken.empty() ) {
            tokens.push_back( currentToken );
            currentToken = "";
        }
    } else if ( std::ispunct( static_cast<unsigned char>( ch ) ) ) {
        if ( !currentToken.empty() ) {
            tokens.push_back( currentToken );
            currentToken = "";
        }
        currentToken.push_back( ch );
    } else if ( std::isalnum( static_cast<unsigned char>( ch ) ) ) {
        currentToken.push_back( ch );
    } else {
        //  Error: illegal character in line.  You'll probably
        //  want to throw an exception.
    }
}
if ( !currentToken.empty() ) {
    tokens.push_back( currentToken );
}

      

        
        
        
      

    

In this case, the sequence of alphanumeric characters is one token, just like any punctuation character. You could go further by ensuring that the token is either all alpha or all digits, and possibly rearranging the punctuation sequences, but that seems to be sufficient for your problem.

Once you have a list of tokens, you can do whatever checks you need (parentheses in the correct places, etc.) and convert the tokens you are interested in if conversions need them.

EDIT:

FWIW: I've experimented with using auto

plus lambda as a means of defining nested functions. My opinion was not whether a good idea or not: I do not always find results that can be read. But in this case:

auto pushToken = [&]() {
    if ( !currentToken.empty() ) {
        tokens.push_back( currentToken );
        currentToken = "";
    }
}

      

        
        
        
      

    

Just before the loop, replace everything if

with pushToken()

. (Or you can create a data structure with tokens

, currentToken

and a pushToken

. This will work even in pre-C ++ 11.)

EDIT:

One final note, since the OP seems to want to do this exclusively with std::istream

: the solution would be to add a manipulator MustMatch

:

class MustMatch
{
    char m_toMatch;
public:
    MustMatch( char toMatch ) : m_toMatch( toMatch ) {}
    friend std::istream& operator>>( std::istream& source, MustMatch const& manip )
    {
        char next;
        source >> next;
        //  or source.get( next ) if you don't want to skip whitespace.
        if ( source && next != m_toMatch ) {
            source.setstate( std::ios_base::failbit );
        }
        return source;
    }
}

      

        
        
        
      

    

As @Angew pointed out, you'll also need >>

for months; usually months will be represented as a class, so you overloaded >>

like this:

std::istream& operator>>( std::istream& source, Month& object )
{
    //      The sentry takes care of skipping whitespace, etc.
    std::ostream::sentry guard( source );
    if ( guard ) {
        std::streambuf* sb = source.rd();
        std::string monthName;
        while ( std::isalpha( sb->sgetc() ) ) {
            monthName += sb->sbumpc();
        }
        if ( !isLegalMonthName( monthName ) ) {
            source.setstate( std::ios_base::failbit );
        } else {
            object = Month( monthName );
        }
    }
    return source;
}

      

        
        
        
      

    

You could of course enter many variations here: the month name can be limited to a maximum of 3 characters, for example (by fulfilling a loop condition monthName.size() < 3 && std::isalpha( sb->sgetc() )

). But if you are dealing with months in any way in your code, writing a class Month

and its Operators >>

and <<

- this is what you will need to do sooner or later anyway.

Then something like:

source >> year >> dayOfYear >> MustMatch( '(' ) >> day >> month
       >> MustMatch( ')' ) >> hour;
if ( !(source >> ws) || source.get() != EOF ) {
    //  Format error...
}

      

        
        
        
      

    

is all that is needed. (Using manipulators like this is another technique worth exploring.)