Re: find function of String

* coolchap, on 19.10.2010 17:03:


Much depends on the detailed language spec and whether you need to check the
input for syntactical correctness.

With the most forgiving requirements I'd probably just code a loop scanning
through the string character by character, like a state machine.

A more general approach is shown below. I coded that up just for fun, and
because it's difficult to describe this approach but easy to just show it:

<code>
#include <iostream>
#include <sstream> // istringstream
#include <string>
#include <stdlib.h> // EXIT_SUCCESS, EXIT_FAILURE
#include <stdexcept>
#include <ctype.h> // isspace, isupper, isdigit
#include <stdio.h> // EOF
using namespace std;

bool throwX( string const& s ) { throw runtime_error( s ); }

typedef unsigned char UChar;

class UCharCode
{
private:
     int code_;

public:
     UCharCode(): code_( 0 ) {}

     UCharCode( int code )
         : code_( code == EOF? EOF : UChar( code ) )
     {}

     int value() const { return code_; }
};

bool isSpace( UCharCode code )
{
     return isspace( code.value() );
}

bool isUppercase( UCharCode code )
{
     return isupper( code.value() );
}

bool isDigit( UCharCode code )
{
     return isdigit( code.value() );
}

class Token
{
public:
     struct Kind
     {
         enum Enum
         {
             notAToken = 0,
             leftBracket, rightBracket, identifier, number,
             end
         };
     };

private:
     string spec_;
     Kind::Enum kind_;

     void makeIdentifierFrom( istream& stream )
     {
         kind_ = Kind::identifier;
         do
         {
             spec_ += char( stream.get() );
         } while( isUppercase( stream.peek() ) );
     }

     void makeNumberFrom( istream& stream )
     {
         kind_ = Kind::number;
         do
         {
             spec_ += char( stream.get() );
         } while( isDigit( stream.peek() ) );
     }

public:
     Token(): kind_( Kind::notAToken ) {}

     explicit Token( istream& stream )
     {
         int const charCode = stream.peek();

         if( charCode == '[' )
         {
             kind_ = Kind::leftBracket; spec_ = char( stream.get() );
         }
         else if( charCode == ']' )
         {
             kind_ = Kind::rightBracket; spec_ = char( stream.get() );
         }
         else if( isUppercase( charCode ) )
         {
             makeIdentifierFrom( stream );
         }
         else if( isDigit( charCode ) )
         {
             makeNumberFrom( stream );
         }
         else if( charCode == EOF )
         {
             kind_ = Kind::end;
         }
         else
         {
             kind_ = Kind::notAToken; spec_ = char( stream.get() );
         }
     }

     string const& spec() const { return spec_; }
     Kind::Enum kind() const { return kind_; }
};

class Lexer
{
private:
     istream& input_;
     Token currentToken_;

public:
     explicit Lexer( istream& aStream ): input_( aStream ) { advance(); }

     void skipSpaces()
     {
         while( isSpace( input_.peek() ) )
         {
             input_.get();
         }
     }

     void advance()
     {
         skipSpaces();
         currentToken_ = Token( input_ );
     }

     Token const& current() const { return currentToken_; }

     Token next()
     {
         advance();
         return current();
     }
};

void analyze( string const& spec )
{
     istringstream input( spec );
     Lexer lexer( input );

     while( lexer.current().kind() != Token::Kind::end )
     {
         (lexer.current().kind() != Token::Kind::notAToken)
             || throwX( "analyze: invalid token \"" + lexer.current().spec() +
"\"" );

         if( lexer.current().kind() == Token::Kind::identifier )
         {
             Token const id = lexer.current();

             lexer.advance();
             (lexer.current().kind() == Token::Kind::number)
                 || throwX( "analyze: identifier not followed by number" );
             cout << id.spec() << " " << lexer.current().spec() << endl;
         }
         lexer.advance();
     }
}

void cppMain()
{
     string const data =
         "[SBD 65 [INI 25 s [PUP 0 ][RPN 25 ]][ANA 1 ][BUIPNR 0 ][BUIPAX 1 ]"
         "[BUIBKG 0 ][BUIOPE 0 ][BUINCM 0 ][BUIREF 0 ][BUIAIR 0 ][BUISBR 0 ]"
         "[BUITSM 0 ][BUIFAR 0 ][BUIRFL 0 ][BUIGRP 0 ][BUIPDI 0 ]";

     analyze( data );
}

int main()
{
     try
     {
         cppMain();
         return EXIT_SUCCESS;
     }
     catch( exception const& x )
     {
         cerr << "!" << x.what() << endl;
     }
     return EXIT_FAILURE;
}
</code>

Cheers & hth.,

- Alf

--
blog at <url: http://alfps.wordpress.com>