Греческий в консоли

namespace win32api
{
 
inline bool read(HANDLE con, char * buf, uint32_t len, DWORD & rcount)
{
    return ::ReadConsoleA(con, buf, len, &rcount, 0) != 0;
}
inline bool read(HANDLE con, wchar_t * buf, uint32_t len, DWORD & rcount)
{
    return ::ReadConsoleW(con, buf, len, &rcount, 0) != 0;
}
 
inline bool write(HANDLE con, char const *buf, uint32_t len)
{
    DWORD dummy;
    return ::WriteConsoleA(con, buf, len, &dummy, 0) != 0;
}
inline bool write(HANDLE con, wchar_t const * buf, uint32_t len)
{
    DWORD dummy;
    return ::WriteConsoleW(con, buf, len, &dummy, 0) != 0;
}
 
}
 
template
<
    typename CharT, typename TraitsT = std::char_traits<CharT>
  , size_t BufSize = 256
  , size_t PtrBack = 4
>
class basic_streambuf_win32
    : public std::basic_streambuf<CharT, TraitsT>
{
    typedef std::basic_streambuf<CharT, TraitsT> base_streambuf;
 
    typedef typename base_streambuf::int_type    int_type;
    typedef TraitsT                              traits_type;
 
public:
    basic_streambuf_win32()
        : icon_(::GetStdHandle(STD_INPUT_HANDLE))
        , ocon_(::GetStdHandle(STD_OUTPUT_HANDLE))
    {
        std::memset(ibuf_, 0, sizeof(ibuf_));
        std::memset(obuf_, 0, sizeof(obuf_));
 
        this->setg(&ibuf_[0], &ibuf_[BufSize], &ibuf_[BufSize]);
        this->setp(&obuf_[0], &obuf_[BufSize]);
    }
    virtual ~basic_streambuf_win32()
    {
        sync();
    }
 
protected:
 
    virtual int_type overflow(int_type c)
    {
        if(this->pptr() >= this->epptr() && out() < 0)
        {
            return traits_type::eof();
        }
        return c == traits_type::eof()
            ? traits_type::not_eof(c)
            : this->sputc(traits_type::to_char_type(c));
    }
 
    virtual int_type underflow()
    {
        if(this->gptr() >= this->egptr() && in() < 0)
        {
            return traits_type::eof();
        }
        return this->sgetc();
    }
 
    virtual std::streamsize showmanyc()
    {
        return this->egptr() - this->gptr();
    }
 
    virtual int_type pbackfail(int_type c)
    {
        if(this->gptr() > this->eback())
        {
            if(c != traits_type::eof())
            {
                this->gptr()[-1] = traits_type::to_char_type(c);
            }
            this->gbump(-1);
            return traits_type::not_eof(c);
        }
        return traits_type::eof();
    }
 
    virtual int sync()
    {
        return out();
    }
 
private:
    int out()
    {
        std::streamsize const cnt = this->pptr() - this->pbase();
        bool const s = win32api::write(ocon_, this->pbase(), static_cast<uint32_t>(cnt));
        this->pbump(-static_cast<int>(cnt));
        return s ? static_cast<int>(cnt) : -1;
    }
 
    int in()
    {
        std::streamsize pb = this->gptr() - this->eback();
        if(PtrBack < pb)
        {
            pb = PtrBack;
        }
        std::memmove(this->eback(), this->gptr() - pb, static_cast<size_t>(pb * sizeof(CharT)));
        DWORD rcount;
        if(win32api::read(icon_, this->eback() + pb, static_cast<uint32_t>(BufSize - pb), rcount))
        {
            this->setg(this->eback(), this->eback() + pb, this->eback() + pb + rcount);
            return rcount;
        }
        return -1;
    }
 
private:
    CharT ibuf_[BufSize];
    CharT obuf_[BufSize];
 
    HANDLE icon_;
    HANDLE ocon_;
};

#include <fcntl.h>
#include <io.h>
#include <stdint.h>
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#include <streambuf>
#include <iostream>
#include <fstream>
#include <string>
#include <locale>
 
#include <windows.h>
 
template <typename E, typename To, typename St = std::mbstate_t>
class null_codecvt
    : public std::codecvt<E, To, St>
{
public:
    typedef std::codecvt<E, To, St> base;
 
    explicit null_codecvt(size_t r = 0)
        : std::codecvt<E, To, St>(r)
    { }
 
protected:
    virtual typename base::result do_in(St &, To const *, To const *, To const * &, E *, E *, E * &) const
    {
        return base::noconv;
    }
    virtual typename base::result do_out(St &, E const *, E const *, E const * &, To *, E *, To * &) const
    {
        return base::noconv;
    }
    virtual typename base::result do_unshift(St &, To *, To *, To *&) const
    {
        return base::noconv;
    }
    virtual int do_length(St & state, To const * f1, To const * l1, size_t n2) const throw()
    {
        return (n2 < size_t(l1 - f1)) ? n2 : l1 - f1;
    }
    virtual bool do_always_noconv() const throw()
    {
        return true;
    }
    virtual int do_max_length() const throw()
    {
        return 2;
    }
    virtual int do_encoding() const throw()
    {
        return 2;
    }
};
 
// Тут должен быть вышеприведенный код....
 
int main()
{
    typedef basic_streambuf_win32<wchar_t> wstreambuf_win32;
 
    wstreambuf_win32 wb;
    std::wcout.rdbuf(&wb);
 
    // Очень важно открывать именно в бинарном режиме
    std::wifstream utf16File("test.txt", std::ios::binary);
 
    utf16File.imbue(std::locale(std::locale::classic(), new null_codecvt<wchar_t, char>));
 
    if(utf16File)
    {
        std::wstring text;
 
        std::getline(utf16File, text);
        {
            std::wcout << L"Russian text from file: " << text << std::endl;
        }
        std::getline(utf16File, text);
        {
            std::wcout << L"Greek text from file: " << text << std::endl;
        }
    }
    //.....
}