Конечный автомат

/////////////////////////////////////////////////////////////////////////////////////////
//Построить автомат, распознающий регулярные выражения вида: c*c(aa)*b(a)*(aa|ab)
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_FSM_base  //Базовый класс для любого конечного автомата. В классе-наследнике
                    //достаточно определить значения состояний, заполнить таблицу переходов
                    //и множество допускающих состояний.
{
    //-----------------------------------------------------------------------------------
    typedef int                                                 T_state;
    typedef std::pair   < T_state,              char        >   T_state_and_symb;
    typedef std::map    < T_state_and_symb,     T_state     >   T_state_transition_table;
    typedef std::set    < T_state                           >   T_states;
    //-----------------------------------------------------------------------------------
    T_state                     cur_state_;
    T_state_transition_table    state_transition_table_;
    T_states                    final_states_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_FSM_base( T_state     start_state )
        :
        cur_state_( start_state )
    {}
    //-----------------------------------------------------------------------------------
    bool    string_is_accepted( T_str   &   s )
    {
        for( auto  c_it = s.begin(); c_it != s.end(); ++c_it )
        {
            if  (
                    !successfully_set_cur_state_for_symb( *c_it )
                )
            {
                return  false;
            }
        }//for
 
        return  cur_state_is_final();
    }
    //-----------------------------------------------------------------------------------
    void    add_rule
        (
            T_state     cur_state,
            char        symb,
            T_state     new_state
        )
    {
        state_transition_table_
            [    
                T_state_and_symb
                    (
                        cur_state,
                        symb
                    )
            ]
        
            =   new_state;
    }
    //-----------------------------------------------------------------------------------
    void    add_final_state( T_state    state )
    {
        final_states_.insert( state );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool    successfully_set_cur_state_for_symb( char   symb )
    {
        auto    tr_it   =   state_transition_table_.find
                                (
                                    T_state_and_symb
                                        (
                                            cur_state_,
                                            symb
                                        )
                                );
 
        bool    bool_res    =   tr_it   !=  state_transition_table_.end();
 
        if( bool_res )
        {
            cur_state_  =   tr_it->second;
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    cur_state_is_final()
    {
        return  final_states_.count( cur_state_ )   !=  0;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_FSM_cab   :   public  T_FSM_base
{
    //-----------------------------------------------------------------------------------
    enum    T_state_val
    {
        start,
        _2,
        _3,
        _4,
        _5,
        _6,
        _7,
        _8,
        _9,
        _10
    };
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_FSM_cab()
        :
        T_FSM_base( start )
    {
        add_rule(   start,  'c',    _2      );
        add_rule(   _2,     'a',    _3      );
        add_rule(   _2,     'b',    _4      );
 
        add_rule(   _2,     'c',    _2      );
        add_rule(   _3,     'a',    _2      );
        add_rule(   _4,     'a',    _5      );
 
        add_rule(   _5,     'a',    _6      );
        add_rule(   _5,     'b',    _7      );
        add_rule(   _6,     'a',    _6      );
 
        add_rule(   _6,     'b',    _7      );
 
        add_final_state( _6 );
        add_final_state( _7 );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        std::cout   <<  "Проверка регулярного выражения c*c(aa)*b(a)*(aa|ab)"
                    <<  std::endl;
 
        std::cout   <<  "Введите строку символов:"
                    <<  std::endl;
 
        T_str   s;
        getline( std::cin, s );
 
        T_FSM_cab   fsm;
 
        std::cout   <<  std::endl
                    <<  (
                            fsm.string_is_accepted(s)
                                ?   "Строка допускается"
                                :   "Строка НЕ допускается"
                        )
 
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }
}