Создать консольное приложение для учета прописанных в доме жителей

#include <map>
#include <set>
#include <vector>
#include <string>
#include <iostream>
#include <iterator>
 
using namespace std;
int main() 
{
    vector<set<int> > A;
    int n, i;
    string s, name;
    while (1) 
    {       
        cin >> s;
        if (s == "init")
        {
            cin >> n;
            A.resize(n);
      if (n <= 0) cout << "Error!";
      cout << endl;
        }
        if (s == "add")
        {
                cin >> i >> name;
                if (i > n) cout << "Error!";
                else
                pair<int, string> insert(i, name);
                cout << endl;
        }
                
        if (s == "list")
        {
            multiset<int, string>::iterator itMap;
            cin >> i;
      if ((i > n)||(i <= 0)) 
        cout << "Error!";
     else 
            itMap = A.find(i);
            for (itMap = A.begin(); itMap != A.end(); itMap++)
            {               
                cout << itMap->first << " : " << itMap->second <<  endl;
            }
    if (s == "exit")
            return 0;
    }
    system("pause");
}

else 
     {
            itMap = A.find(i);
            for (itMap = A.begin(); itMap != A.end(); itMap++)
            {               
                cout << itMap->first << " : " << itMap->second <<  endl;
            }
      }

int main() {
    vector<vector<string> > data;
    string name;
    int n,x;
    cin >> n;
    data.resize(n);
    //добавляем в x имя name
    for (int i = 0;i < n;i++) {
        cin >> x >> name;
        data[x].push_back(name);
    }
    //выводим всех прописаных в x
    cin >> x;
    for (int i = 0;i < data[x].size();i++)
        cout << data[x][i] << endl;
    return 0;
}

/*
Создать консольное приложение для учета прописанных в доме жителей.
С консоли должны считываться команды:
“init n” – где n – целое число, определяющая количество квартир в доме, квартиры
нумеруются с 1 по n предыдущие записи должны быть удалены,
“add i name” – прописать в квартиру с номером i человека с именем name,
“list i” – вывести в консоль всех прописанных людей в квартире с номером i,
“exit” – выход из консольного приложения.
*/
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <iterator>
#include <set>
#include <sstream>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                         T_str;
typedef std::vector     < T_str         >   T_strings;
typedef std::set        < T_str         >   T_residents;
typedef std::vector     < T_residents   >   T_residents_of_flat;
///////////////////////////////////////////////////////////////////////////////
enum   T_command_type
{
    INIT,
    ADD,
    LIST,
    EXIT,
    COMMANDS_COUNT
};
///////////////////////////////////////////////////////////////////////////////
struct    T_command
{
    //-------------------------------------------------------------------------
    static  T_strings   key_words_;
    static  T_strings   command_prompts_;
 
    T_command_type      command_type_;
    int                 first_param_;
    T_str               second_param_;
    bool                is_correct_;
    //-------------------------------------------------------------------------
    T_command()
    {
        key_words_.resize( COMMANDS_COUNT );
        key_words_[ INIT    ]   =   "init";
        key_words_[ ADD     ]   =   "add";
        key_words_[ LIST    ]   =   "list";
        key_words_[ EXIT    ]   =   "exit";
 
        command_prompts_.resize( COMMANDS_COUNT );
 
        command_prompts_    [ INIT  ]   
        =       key_words_  [ INIT  ]
            +   "\tколичество_квартир_в_доме\t(все предыдущие записи будут удалены)";
 
        command_prompts_    [ ADD   ]   
        =       key_words_  [ ADD   ]
            +   "\tномер_квартиры\t\t\tимя_прописываемого";
 
        command_prompts_    [ LIST  ]   
        =       key_words_  [ LIST  ]
            +   "\tномер_квартиры\t\t\t(печатает имена прописанных в квартире)";
 
        command_prompts_    [ EXIT  ]   
        =       key_words_  [ EXIT  ]
            +   "\t(выход из программы)";
    }
    //-------------------------------------------------------------------------
    T_command( T_str    const   &   str )
    {
        std::istringstream  istr( str );
        T_str               key_word;
 
        is_correct_     =       ( istr    >>  key_word      )
                            &&  successfully_set_command_type( key_word );
 
        if  ( 
                    is_correct_
                &&  command_type_   !=  EXIT 
            )
        {
            is_correct_     =   bool( istr    >>  first_param_  );
 
            if  ( 
                        is_correct_ 
                    &&  command_type_   ==  ADD
                )
            {
                is_correct_     =   bool( istr    >>  second_param_ );
            }
        }//IF
 
        is_correct_     =       is_correct_
                            &&  istr.eof();
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    bool    successfully_set_command_type( T_str    const   &   key_word )
    {
        auto    command_type_ind  
 
            =   std::distance
                    (
                        key_words_.begin        (),
 
                        std::find
                        (
                            key_words_.begin    (),
                            key_words_.end      (),
                            key_word
                        )
                    );
 
        command_type_   =   T_command_type( command_type_ind );
 
        return  command_type_ind    <   int( key_words_.size() );   
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
T_strings   T_command::key_words_;
T_strings   T_command::command_prompts_;
///////////////////////////////////////////////////////////////////////////////
class   T_house_registration
{
    //-------------------------------------------------------------------------
    T_residents_of_flat     residents_of_flat_;
    T_command               command_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    void    input_command()
    {
        do
        {
            std::cout   <<  "\n\n\nВведите одну из команд вида:"
                        <<  std::endl;
 
            std::copy
                (
                    command_.command_prompts_.begin     (),
                    command_.command_prompts_.end       (),
                    std::ostream_iterator< T_str >      ( std::cout, "\n" )
                );
 
            std::cout   <<  "\n-> ";
            T_str   command_str;
 
            do
            {
                getline ( 
                            std::cin, 
                            command_str 
                        );
            }
            while   (
                        command_str.empty()   
                    );
 
            command_    =   command_str;  
 
            if( !command_.is_correct_ )
            {
                std::cout   <<  "Команда некорректна!"
                            <<  std::endl;
            }
        }
        while( !command_.is_correct_ );
    }
    //-------------------------------------------------------------------------
    bool    command_is_exit()
    {
        return      command_.command_type_  ==  EXIT;
    }
    //-------------------------------------------------------------------------
    bool    successfully_execute_command()
    {
            switch  (
                        command_.command_type_    
                    )
            {
            case    INIT    :   return  successfully_execute_init_command   ();
            case    ADD     :   return  successfully_execute_add_command    ();
            case    LIST    :   return  successfully_execute_list_command   ();
            default         :   return  false;
            }//switch
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    bool    successfully_execute_init_command()
    {
        auto    flats_count     =   command_.first_param_;
 
        auto    bool_res        =       flats_count     >   0
                                    &&  flats_count     <   10000;
 
 
        if( bool_res )
        {
            residents_of_flat_.clear    ();
            residents_of_flat_.resize   ( flats_count );
        }
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    bool    successfully_execute_add_command()
    {
        try
        {
            residents_of_flat_.at( command_.first_param_ - 1 )
                .insert( command_.second_param_ );
            return  true;                
        }
        catch(...)
        {
            return  false;
        }
    }
    //-------------------------------------------------------------------------
    bool    successfully_execute_list_command()
    {
        auto    flat_ind    =   command_.first_param_ - 1;
 
        try
        {
            std::cout   <<  "В квартире "
                        <<  command_.first_param_
                        <<  " проживают:"
                        <<  std::endl;
 
            auto    residents   =   residents_of_flat_.at( flat_ind );
 
            if  (
                    residents.empty()    
                )
            {
                std::cout   <<  "пусто"
                            <<  std::endl;
            }
            else
            {
                std::copy
                    (
                        residents.begin                 (),
                        residents.end                   (),
                        std::ostream_iterator< T_str >  ( std::cout, "\n" )
                    );
            }//else
 
            return  true;
        }
        catch(...)
        {
            return  false;
        }
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    T_house_registration  house_reg;
 
    for(;;)
    {
        house_reg.input_command();
 
        if  (
                house_reg.command_is_exit()
            )
        {
            break;
        }
 
        std::cout   <<  (
                            house_reg.successfully_execute_command()
                                ?   "КОМАНДА УСПЕШНО ВЫПОЛНЕНА"
                                :   "КОМАНДА НЕВЫПОЛНИМА!"
                        )
 
                    <<  std::endl;
    }//for
}