Русский язык в Linux, регистр

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <fstream>
#include <cctype>
#include <algorithm>
#include <time.h>
#include <regex>
using namespace std;
 
struct Word
{
    std::string word = "";
    int wordfreq = 0;
};
 
int main(int argc, _TCHAR* argv[])
{
    
    setlocale(LC_ALL, "Russian");
    
    cin >> NewFile;
 
    map <string, int> words; // контейнер для входного текста
    ifstream in;
    in.open(NewFile);// файл с входным текстом
    string word;
    int wCount = 0; // счетчик слов во входном тексте
 
    while (in >> word) // удаляем не важные символы из текста
    {
        setlocale(LC_ALL, "");
        std::transform(word.begin(), word.end(), word.begin(), tolower);// перевод в нижний регистр
        for (int i = 0; i<word.size(); i++)
        {
            if (word[i] == '.' || word[i] == ',' || word[i] == '(' || word[i] == ')' || word[i] == '[' || word[i] == ']' || word[i] == '!' || word[i] == '?' ||
                word[i] == '"' || word[i] == ';' || word[i] == ':' || word[i] == '#' || word[i] == '$' || word[i] == '%' || word[i] == '^' || word[i] == '&' ||
                word[i] == '*' || word[i] == '*' || word[i] == '+' || word[i] == '-' || word[i] == '“' || word[i] == '/' || word[i] == '”' || word[i] == '„' ||
                word[i] == '_' || word[i] == '—' || word[i] == '«' || word[i] == '»' || word[i] == '…' || word[i] == '*' || word[i] == '–') {
                word.erase(word.begin() + i);
                i--;
            }
        }
 
        if (!word.empty() && word != "--")
            words[word]++;
        wCount++;
    }

#include <iostream>
#include<fstream>
using namespace std;
 
int main()
{
    setlocale(LC_ALL,"C.UTF-8");
    std::ifstream stream("test.txt");
    //получаем размер файла
    stream.seekg(0,std::ios_base::end);
    size_t size=stream.tellg();
    stream.seekg(0);
 
    //и низкоуровневым чтением его, чтоб точно ничего не сбойнуло
    std::wstring str(size/sizeof(wchar_t),' ');
    stream.read((char*)str.data(),size);
 
    //выводим что прочитали
    wcout<<str;
    return 0;
}

in.imbue(std::locale(""));

g_utf8_strdown (word.c_str(), -1)

#pragma once
 
#ifdef dUSING_PRECOMPILED_HEADER
    #ifndef _STDEXCEPT_
        #error #include <stdexcept> first
    #endif
 
    #ifndef _FSTREAM_
        #error #include <fstream> first
    #endif
 
    #ifndef _CODECVT_
        #error #include <codecvt> first
    #endif
 
    #ifndef _STRING_
        #error #include <string> first
    #endif
#else
    #include <stdexcept>
    #include <fstream>
    #include <codecvt>
    #include <cassert>
    #include <string>
#endif
 
namespace fs{
namespace stream{
 
// ===================================================================================================
// ===================================================================================================
namespace detail
{
    template<class ch> 
    std::basic_ofstream<ch> 
    open__(const std::basic_string<ch>& filename, const int flag, const bool with_BOM)
    {
        std::basic_ofstream<ch> stream_;
 
        #ifdef _MSC_VER
            stream_.open(filename, std::ios::out | flag, _SH_DENYRW);
        #else
            stream.open(filename, std::ios::out | flag);
        #endif
 
        stream_.imbue(get_utf8_locale(with_BOM));
        
        if(!stream_)
            throw std::runtime_error("can`t open file");
 
        return stream_;
    }
 
    inline std::locale get_utf8_locale(const bool with_bom)
    {
        typedef std::codecvt_utf8<wchar_t, 0x10ffff, std::generate_header> 
            bom_codec_t;
        typedef std::codecvt_utf8<wchar_t> 
            no_bom_codec_t;
 
        return with_bom?
            std::locale(std::locale::empty(), new bom_codec_t):
            std::locale(std::locale::empty(), new no_bom_codec_t);
    }
 
    template<class Container, class Value> 
    void append__(Container& cont, Value&& val)
    {
        
        #ifdef _MSC_VER
        __if_exists(Container::emplace_back) 
            { cont.emplace_back( std::forward<Value>(val) );       return; }
 
        __if_exists(Container::push_back)    
            { cont.push_back( std::forward<Value>(val) )   ;       return; }
 
        __if_exists(Container::insert)       
            { cont.insert( cont.end(), std::forward<Value>(val) ); return; }
        #else
        TODO: not implemented...
        #endif
    }
 
}// namespace detail
// ===================================================================================================
// ===================================================================================================
    
// --- пересоздает файл заного
template<class ch> 
std::basic_ofstream<ch>
create(const std::basic_string<ch>& filename, const bool with_BOM)
{
    return detail::open__(filename, std::ios::trunc, with_BOM);
}
// ===================================================================================================
    
// --- открывает для добавления
template<class ch> 
std::basic_ofstream<ch>
append(const std::basic_string<ch>& filename, const bool with_BOM)
{
    return detail::open__(filename, std::ios::app, with_BOM);
}
// ===================================================================================================
    
// --- открывает для чтения    
template<class ch>
std::basic_ifstream<ch>
load(const std::basic_string<ch>& filename, const bool with_BOM)
{
    std::basic_ifstream<ch> stream_;
 
    stream_.open(filename, std::ios::in);
    stream_.imbue(detail::get_utf8_locale(with_BOM));
    
    if(!stream_)
        throw std::runtime_error("can`t open file");
    
    return stream_;
}
// ===================================================================================================
    
// --- хэлпер для загрузки всего файла построчно
template<class ch, class container> 
void load_lines(const std::basic_string<ch>& filename, container& cont, const bool with_BOM)
{
    auto in = load(filename, with_BOM);
    std::basic_string<ch> line;
    while (std::getline(in, line))
        detail::append__(cont, line);
}
    
template<class ch, class container> 
void load_lines(const ch* filename, container& cont, const bool with_BOM)
{
    assert(filename);
    load_lines(std::basic_string<ch>(filename), cont, with_BOM);
}
    
// ===================================================================================================
    
// --- хэлпер для загрузки отдельных слов 
template<class ch, class container> 
void load_words(const std::basic_string<ch>& filename, container& cont, const bool with_BOM)
{
    auto in = load(filename, with_BOM);
    std::basic_string<ch> word;
    while(in >> word)
        detail::append__(cont, word);
}
    
template<class ch, class container> 
void load_words(const ch* filename, container& cont, const bool with_BOM)
{
    assert(filename);
    load_words(std::basic_string<ch>(filename),cont, with_BOM);
}
    
// ===================================================================================================
 
} //namespace stream
} //namespace fs
 
 
#include <iostream>
#include <vector>
#include <set>
 
int main()
{
    setlocale(LC_ALL, "");
    
    std::cout << "Hello, world!\n";
    
    try
    {
        // --- загружаем весь файл построчно в указанный контейнер
        std::vector<std::wstring> mylines;
        fs::stream::load_lines(L"sample-utf8.txt", mylines, true);
    
        // --- загружаем все слова из файла в указанный контейнер
        std::set<std::wstring> mywords;
        fs::stream::load_words(L"sample-utf8.txt", mywords, true);
    }
    catch(const std::exception& e)
    {
        std::cout << e.what()<<std::endl;
    }
}