Лексический анализатор

//////////////////////////////////////////////////////////////////////////////////////
//Разработать лексический анализатор, который реализует конечный автомат для поиска 
//во входном потоке бинарных векторов с четным числом единиц и нечетным числом нулей.
//////////////////////////////////////////////////////////////////////////////////////
#include <ctime>
#include <cstdlib>
#include <iostream>
#include <string>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::string  T_str;
//////////////////////////////////////////////////////////////////////////////////////
class T_FSM_0_11
{
    enum T_state
    {
        START_STATE,
        _0_1,
        _0_11_GOOD_VECT,
        _00_1,
        _00_11
    };
    //--------------------------------------------------------------------------------
public:
    T_FSM_0_11() : state_cur(START_STATE), vect_count()
    {}
    //--------------------------------------------------------------------------------
    void  parse(const T_str&  s)
    {
        std::cout << "В заданной строке "
                  << std::endl
                  << "\""
                  << s
                  << "\""
                  << std::endl;
 
        for(T_str::const_iterator  symb_it = s.begin();
            symb_it != s.end(); ++symb_it)
        {
            switch(state_cur)
            {
            case START_STATE:
                START_STATE_parse(*symb_it);
                break;
 
            case _0_1:
                _0_1_parse(*symb_it);
                break;
 
            case _0_11_GOOD_VECT:
                _0_11_GOOD_VECT_parse(*symb_it);
                break;
 
            case _00_1:
                _00_1_parse(*symb_it);
                break;
 
            case _00_11:
                _00_11_parse(*symb_it);
                break;
            
            default:
                std::cout << "Недопустимое состояние конечного автомата!"
                          << std::endl;
                break;
            }
        }
 
        if(!vect_count)
        {
            std::cout << "нет векторов с четным числом единиц и нечетным числом нулей."
                      << std::endl;        
        }
    }
    //--------------------------------------------------------------------------------
private:
    void  START_STATE_parse(T_str::value_type  symb)
    {
        vect_cur.clear();
        switch(symb)
        {
        case '0':
            vect_cur.push_back(symb);
            state_cur = _0_11_GOOD_VECT;
            break;
 
        case '1':
            vect_cur.push_back(symb);
            state_cur = _00_1;
            break;
 
        default:
            state_cur = START_STATE;
        }
    }
    //--------------------------------------------------------------------------------
    void  _0_1_parse(T_str::value_type  symb)
    {        
        switch(symb)
        {
        case '0':
            vect_cur.push_back(symb);
            state_cur = _00_1;
            break;
 
        case '1':
            vect_cur.push_back(symb);
            state_cur = _0_11_GOOD_VECT;
            break;
 
        default:
            state_cur = START_STATE;
        }
    }
    //--------------------------------------------------------------------------------
    void  _0_11_GOOD_VECT_parse(T_str::value_type  symb)
    {        
        switch(symb)
        {
        case '0':
            vect_cur.push_back(symb);
            state_cur = _00_11;
            break;
 
        case '1':
            vect_cur.push_back(symb);
            state_cur = _0_1;
            break;
 
        default:
            if(!vect_count++)
            {
                std::cout << "найдены следующие векторы"                          
                          << " с четным числом единиц и нечетным числом нулей:"
                          << std::endl;
            }
            std::cout << vect_cur
                      << std::endl;
            state_cur = START_STATE;
        }
    }
    //--------------------------------------------------------------------------------
    void  _00_1_parse(T_str::value_type  symb)
    {        
        switch(symb)
        {
        case '0':
            vect_cur.push_back(symb);
            state_cur = _0_1;
            break;
 
        case '1':
            vect_cur.push_back(symb);
            state_cur = _00_11;
            break;
 
        default:
            state_cur = START_STATE;
        }
    }
    //--------------------------------------------------------------------------------
    void  _00_11_parse(T_str::value_type  symb)
    {        
        switch(symb)
        {
        case '0':
            vect_cur.push_back(symb);
            state_cur = _0_11_GOOD_VECT;
            break;
 
        case '1':
            vect_cur.push_back(symb);
            state_cur = _00_1;
            break;
 
        default:
            state_cur = START_STATE;
        }
    }
    //--------------------------------------------------------------------------------
private:
    T_state  state_cur;
    T_str    vect_cur;
    int      vect_count;
};
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
    T_str  s;
    T_str  t;
    for(int i = 0; i < 70; ++i)
    {
        switch(rand() % 3)
        {
        case 0:
            s.push_back('0');
            break;
 
        case 1:
            s.push_back('1');
            break;
 
        default:
            s.push_back('_');            
        }        
        t.push_back('1' + rand() % ('9' - '1' + 1));
    }
 
    T_str  res = rand() % 2 ? s : t;
    
    T_FSM_0_11  fsm_0_11;
    fsm_0_11.parse(res);
}