Программа для анализа русских/английских текстов

// FrequencyOfWords.cpp : Defines the entry point for the console application.
//
#include <windows.h>
#include <process.h>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <conio.h>
#include <string>
#include <deque>
#include <set>
#include <map>
 
namespace FOW
{
    using namespace std;
 
    // ========================================== //
    // Список используемых переменных и объектов  //
    // ========================================== //
 
    string bad_simbols       = "$?\"\\“”‚„«»‹›\
           §…&%#!{}[],.:;?*№()<>/*+=0123456789";     // Символы, которые не должны содержаться в слове
 
    string delim(59, '-');                           // Строка-разделитель
    string file_in            =         "in.txt";    // Имя анализируемого файла по умолчанию
    string file_of_exceptions = "exceptions.txt";    // Имя файла со списком слов-исключений
    string file_out           =        "out.txt";    // Имя результирующего файла по умолчанию
 
    size_t words_counter(0);                         // Всего слов в тексте(счётчик)
    int min_word_size = 3;                           // Минимальный размер слова по умолчанию
    set<string> exc;                                 // Список слов-исключений (в нижнем регистре)
    map<string, double> words;                       // Список анализируемых слов (в нижнем регистре), слово - ключ к числу повторений
 
    volatile bool ThreadFlag = true;                 // Флаг для управления потоком progress, при false поток завершается
    streamoff all_f_size(1);                         // Размер файла
    streamoff current_f_size(1);                     // На данный момент прочитано из файла
 
    // ========================================== //
    //            Функциональная часть            //
    // ========================================== //
 
    unsigned _stdcall progress(void*)
    {
        setlocale(LC_ALL, "");
        cout << "Прогресс:\n " << flush;
        cout.precision(4);
 
        while(ThreadFlag)
        {
            cout << "        " << '\r' << flush; // Очищаем пред. вывод
            cout << (((100 / (long double)all_f_size) * current_f_size)) << "%" << flush << '\r';
            if (ThreadFlag) Sleep(100);
        }
 
        // Гарантирует отображение "100%", при малых размерах файла и быстрой работе
        cout << "        " << '\r' << flush;
        cout << 100 << "%\r" << flush;
 
        // Возвращаем переменные в исходное состояние для возможного перезапуска программы
        all_f_size     = (1);
        current_f_size = (1);
 
        return 0;
    }
 
    void read_exceptions(string& exc_file)
    {
 
        ifstream file(exc_file);
        if (!file)
        {
            cout << "\nФайл с исключениями не загружен." << endl;
            return;
        }
 
        string buf;
        while (file >> buf)
        {
            for_each(buf.begin(), buf.end(), [] (char& ch) {ch = tolower(ch);});
            exc.insert(buf);
        }
 
        cout << "\nПрочитано исключений: " << exc.size() << endl;
        file.close();
    }
 
    int  read_text_file(string& inp_file, bool mode = true)
    {
        ifstream file(inp_file, ios::binary);
        if (!file)
        {
            cout << "\nФайл с текстом для анализа не загружен." << endl;
            return 1;
        }
 
        // Узнаём размер файла
        file.seekg (0, std::ios_base::end);
        all_f_size = file.tellg();
        file.seekg (0, std::ios_base::beg);
 
        string buf;
        while(file >> buf)
        {
            current_f_size = file.tellg();
 
            for_each(buf.begin(), buf.end(), [] (char& it) {it = tolower(it);});
 
            // Удаление паразитных знаков из кандитата на слово
            for (string::size_type pos = buf.find_first_of(bad_simbols); pos != string::npos;)
            {
                buf.erase(pos);
                pos = buf.find_first_of(bad_simbols);
            }
            // Если слово начинается с "'" или "—" или "-" - обрабатываем эту ситуацию
            if ((buf.begin() != buf.end()) && ((*buf.begin() == '\'') || (*buf.begin() == '—') || (*buf.begin() == '-'))) buf.erase(buf.begin());
            // То же самое, если оканчивается на "'" или "—" или "-"
            if ((buf.begin() != buf.end()) && ((*(--buf.end()) == '\'') || (*(--buf.end()) == '—') || (*(--buf.end()) == '-'))) buf.erase((--buf.end()));
 
            // Конец удаления паразитных знаков
 
            if (mode)
            {
                // Если слово не найдено в списке исключений и длиннее min_word_size
                if (!exc.count(buf) && (buf.size() >= (unsigned)min_word_size))
                {
                    if (words.count(buf)) ++words[buf];
                    words.insert(make_pair(buf, 1));
                    ++words_counter;
                }
            }
            else
            {
                // Если слово не найдено в списке исключений и равно длине min_word_size
                if (!exc.count(buf) && (buf.size() == (unsigned)min_word_size))
                {
                    if (words.count(buf)) ++words[buf];
                    words.insert(make_pair(buf, 1));
                    ++words_counter;
                }
            }
        }
        file.close();
        return 0;
    }
 
    void write_results(string& outp_file)
    {
        ofstream file(outp_file);
 
        // Подготавливаем для вывода, высчитываем для каждого слова процент его употребления в тексте
        for (map<string, double>::iterator it = words.begin(); it != words.end(); ++it)
        {
            it->second = it->second / (double)words_counter * 100;
        }
 
        // Собираем очередь и сортируем в порядке убывания процента повторения
        deque<pair<double, string>> buf;
        for (map<string, double>::iterator i = words.begin(); i != words.end(); ++i)
        {
            buf.insert(buf.begin(), make_pair(i->second, i->first));
        }
        sort(buf.rbegin(), buf.rend());
 
        // Сохраняем
        size_t count(0);
        //long double temp_buf = 0;
        for_each(buf.begin(), buf.end(), [/*&temp_buf, */&file, &count] (pair<double, string> it) 
        {
            //temp_buf += it.first;
            file  << '['<< ++count << "] " << std::setw(25) << std::left << it.second << std::right << it.first << '%' << endl;
        });
        count = 0;
        //cout << "sum = " << temp_buf << endl;
        file.close();
 
    }
 
    void input_name()
    {
        bool fl = false;
        do
        {
            if (fl) cout << "\nИмя анализируемого файла некорректно, повторите ввод:" << ends;
            else cout << "\nИмя анализируемого файла:" << ends;
            cin >> file_in;
            fl = true;
        }
        while (!ifstream(file_in));
    }
    
    int _main()
    {
        system("cls");
        cout << " Программа анализирует частоту употребления слов в тексте." << endl << delim << endl;
        bool mode = true;
 
        bool inp_err(false);
        do
        {
            if (inp_err) cout << "n должно быть > 0" << ends;
            cout << "\nСчитать словом буквенную последовательность от n символов, где n =" << ends;
            cin >> min_word_size;
            inp_err = true;
        }
        while (min_word_size < 1);
        inp_err = (false);
 
        char ch;
        do
        {
            if (inp_err) cout << "\n(y/n)!" << ends;
            cout << "\nИскать слова точно равные по длине " << min_word_size << "(y), или все равные и больше(n)? " << ends;
            ch = tolower(_getche());
            inp_err = true;
        }
        while (ch != 'y' && ch != 'n');
        inp_err = (false);
        (ch == 'n')? mode = true: mode = false;
 
        do
        {
            if (inp_err) cout << " - (Выбор - y/n!)" << ends;
            cout << "\nЗадать имена используемых файлов вручную?(y/n)" << ends;
            ch = tolower(_getche());
            inp_err = true;
        }
        while (ch != 'y' && ch != 'n');
        inp_err = (false);
 
        if (ch == 'y')
        {
            input_name();
            cout << "Имя файла содержащего слова-исключения:" << ends; cin >> file_of_exceptions;
            cout << "Имя файла для вывода:" << ends; cin >> file_out;
        }
 
        read_exceptions(file_of_exceptions);
 
        HANDLE hThread = (HANDLE)_beginthreadex(NULL, NULL, progress, NULL, NULL, NULL);
 
        read_text_file(file_in, mode);
 
        write_results(file_out);
 
        ThreadFlag = false;
        WaitForSingleObject(hThread, 120); // Даём время потоку завершиться
 
        cout << "\nНайдено слов: " << words_counter << endl;
 
        ch = 'e';
        do
        {
            if (inp_err) cout << " - (Выбор - y/n!)" << ends;
            cout << "\nРасчёт завершён, проанализировать новый файл?(y/n)" << ends;
            ch = tolower(_getche());
            inp_err = true;
        }
        while (ch != 'y' && ch != 'n');
        inp_err = (false);
 
        int ret(0); // Возвращаемое значение
 
        if (ch == 'y') ret = true;
        else cout << "\n\n" << delim << endl;
 
        // Сбрасываем всё что рассчитывали, для возможного перезапуска с новыми данными
        ThreadFlag = true;
        words_counter = 0;
        exc.clear();
        words.clear();
 
        return ret;
    }
}
 
int main()
{
    setlocale(LC_ALL, "");
    while (FOW::_main());
    system("pause");
    return 0;
}