Составить программу-переводчик

#include <map>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <cctype>
#include <string>
 
int main()
{
    //загрузка словаря
    std::ifstream ifs("eng_rus_dict.txt");
    std::map<std::string, std::string> smap;
    if(ifs.is_open())
    {
        std::string str1, str2;
        while(ifs >> str1 >> str2)
            smap[str1] = str2;
        ifs.clear();
        ifs.close();
    }
    else
        std::cerr << "Unable to open input file for loading dictionary\n";
 
    // загрузка англ. текста для перевода на русский
    ifs.open("eng_text.txt");
    std::string text;
    if(ifs.is_open())
    {
        char c;
        while(ifs.get(c))
            text += c;
        ifs.clear();
        ifs.close();
    }
    else
        std::cerr << "Unable to open input file for loading english text\n";
 
    //перевод текста на русский
    std::string word;
    std::string::iterator ibw(text.begin()), iew(text.begin());
    while(iew != text.end())
    {
        ibw = std::find_if(iew, text.end(), [](char c){return isalpha(c);});
        iew = std::find_if(ibw, text.end(), [](char c){return !isalpha(c);});
        word.assign(ibw, iew);
        for(auto const& val : smap)
        {
            if(val.first  == word)
            {
                text.replace(ibw - text.begin(), iew - ibw, val.second);
                break;
            }
        }
    }
 
    // сброс переведённого текста в файл
    std::ofstream ofs("rus_text.txt");
    if(ofs.is_open())
    {
        ofs << text;
        ofs.close();
    }
    else
        std::cerr << "Unable to open output file\n";
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Составить программу – перводчик с родного языка на иностранный или наоборот. Переводчик 
//разбивает текст на слова и заменяет каждое на соотвествующее в словаре, если таковое 
//имеется. Предусмотреть возможность расширения словаря.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <string>
#include <utility>
#include <windows.h>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                         T_str;
typedef std::map    < T_str,    T_str   >   T_dictionary;
/////////////////////////////////////////////////////////////////////////////////////////
enum    T_action
{
    TEXT_TRANSLATION_FROM_ENGLISH_INTO_RUSSIAN_ACTION   =   1,
    EXTENSION_ENGLISH_RUSSIAN_DICTIONARY_ACTION
};
/////////////////////////////////////////////////////////////////////////////////////////
void    print_prompt_and_action_val
    (
        T_str   const   &   prompt,
        T_action            action
    )
{
    std::cout   <<  '\t'    <<  prompt  <<  '\t'    <<  ": "    <<  action  <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_load_english_russian_dictionary_from_file_with_name_into_map_or_print_message
    (
        T_str   const   &   dictionary_file_name,
        T_dictionary    &   dictionary
    )
{
    std::ifstream   ifile( dictionary_file_name );
    bool            bool_res    =   ifile != nullptr;
 
    if( bool_res )
    {
        T_str   word_eng;
 
        while( ifile >> word_eng )
        {
            ifile   >>  dictionary[ word_eng ];
        }//while
    }
    else
    {
        std::cout   <<  "Файл словаря \""   <<  dictionary_file_name    <<  "\" не найден."     <<  std::endl;
    }//else
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    translate_text_from_english_into_russian_with_dictionary
    (
        T_str   const   &   english_text,
        T_str           &   russian_text,
        T_dictionary    &   english_russian_dictionary
    )
{
    std::istringstream      eng_in( english_text );
    std::ostringstream      rus_out;
 
    std::transform
        (
            std::istream_iterator< T_str >  ( eng_in        ),
            std::istream_iterator< T_str >  (),
            std::ostream_iterator< T_str >  ( rus_out,  " " ),
 
            [ &english_russian_dictionary ] ( T_str     const   &   word_eng )->T_str
            {
                T_str   word_rus    =   english_russian_dictionary[ word_eng ];
 
                return  word_rus.empty()
                            ?   "<нет_в_словаре>"
                            :   word_rus;
            }
        );
 
    russian_text    =   rus_out.str();
}
/////////////////////////////////////////////////////////////////////////////////////////
void    text_translation_from_english_into_russian_with_dictionary_file_name
    ( T_str     const   &   dictionary_file_name )
{
    T_dictionary    english_russian_dictionary;
 
    if  (
            successfully_load_english_russian_dictionary_from_file_with_name_into_map_or_print_message
                (
                    dictionary_file_name,
                    english_russian_dictionary
                )
        )
    {
        std::cout   <<  "Введите английский текст для перевода:"
                    <<  std::endl;
 
        T_str   english_text;
        std::cin.sync   ();
        getline         ( std::cin, english_text );
 
        T_str   russian_text;
 
        translate_text_from_english_into_russian_with_dictionary
            (
                english_text,
                russian_text,
                english_russian_dictionary
            );
 
        std::cout   <<  std::endl
                    <<  russian_text
                    <<  std::endl;
    }//if
}
/////////////////////////////////////////////////////////////////////////////////////////
namespace std
{
    std::ostream    &   operator<<
        (
            std::ostream                        &   ostr,
            T_dictionary::value_type    const   &   word_eng_and_word_rus
        )
    {
        ostr    <<  word_eng_and_word_rus.first
                <<  '\t'
                <<  word_eng_and_word_rus.second
                <<  std::endl;
 
        return  ostr;
    }
}//namespace std
/////////////////////////////////////////////////////////////////////////////////////////
void    extension_english_russian_dictionary_with_dictionary_file_name
    ( T_str     const   &   dictionary_file_name )
{
    T_dictionary    english_russian_dictionary;
 
    successfully_load_english_russian_dictionary_from_file_with_name_into_map_or_print_message
        (
            dictionary_file_name,
            english_russian_dictionary
        );
 
    std::cout   <<  "Введите количество добавляемых пар английское слово - русский перевод: ";
 
    int     n   =   0;
    std::cin    >>  n;
 
    for( int  i = 0; i < n; ++i )
    {
        std::cout   <<  std::endl
                    <<  "#"     <<  i + 1   <<  std::endl
                    <<  "английское слово\t: ";
 
        T_str   word_eng;
        std::cin    >>  word_eng;
 
        std::cout   <<  "русское слово\t\t: ";
        std::cin    >>  english_russian_dictionary[ word_eng ];
    }//for
 
    std::ofstream   ofile( dictionary_file_name );
 
    std::copy
        (
            english_russian_dictionary.begin                    (),
            english_russian_dictionary.end                      (),
            std::ostream_iterator< T_dictionary::value_type >   ( ofile )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    SetConsoleCP        (1251);
    SetConsoleOutputCP  (1251);
    const   T_str   DICTIONARY_FILE_NAME    =   "d.txt";
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  "Выберите действие:"
                    <<  std::endl;
 
        print_prompt_and_action_val
            (
                "перевод текста с английского на русский",
                TEXT_TRANSLATION_FROM_ENGLISH_INTO_RUSSIAN_ACTION
            );
 
        print_prompt_and_action_val
            (
                "расширение англо-русского словаря",
                EXTENSION_ENGLISH_RUSSIAN_DICTIONARY_ACTION
            );
 
        std::cout   <<  std::endl
                    <<  "-> ";
 
        int     action  =   0;
        std::cin    >>  action;
 
        switch( action )
        {
        case    TEXT_TRANSLATION_FROM_ENGLISH_INTO_RUSSIAN_ACTION   :
            text_translation_from_english_into_russian_with_dictionary_file_name    ( DICTIONARY_FILE_NAME );
            break;
 
        case    EXTENSION_ENGLISH_RUSSIAN_DICTIONARY_ACTION         :
            extension_english_russian_dictionary_with_dictionary_file_name          ( DICTIONARY_FILE_NAME );
            break;
 
        default:
            exit(0);
        }//switch
    }//for
}