Как создать свой поток и связать его с консолью

#include <iostream>
#include <string.h>
#include <fstream>
struct MyChar: public std::char_traits<char> {
    static bool
    eq(const char_type& __c1, const char_type& __c2)
    { return toupper(__c1) == toupper(__c2); }
 
    static bool
    lt(const char_type& __c1, const char_type& __c2)
    { return toupper(__c1) < toupper(__c2); }
    static int
    compare(const char_type* __s1, const char_type* __s2, size_t __n)
    { return memicmp(__s1, __s2, __n); }
};
//std::basic_ostream<char, MyChar> mcout;
typedef std::basic_string<char, MyChar> ci_string;
int main()
{
    std::basic_ofstream<char, MyChar> mfout;
    mfout.open("C:\\rt.txt");
    ci_string str1("Masha");
    mfout << str1;
    return 0;
}

#include <streambuf>
#include <limits>
#include <cstdio>
 
class console_buffer
    : public std::basic_streambuf< char, std::char_traits<char> >
{
public:
    explicit console_buffer(FILE * file)
        : file_(file)
    {}
 
    ~console_buffer()
    {
        std::fflush(file_);
    }
 
protected:
    std::basic_streambuf<char, std::char_traits<char> > * setbuf(char * s, std::streamsize n)
    {
        size_t n_size_t = sizeof(std::streamsize) > sizeof(size_t)
                          ? static_cast<size_t>(
                                std::min(
                                    static_cast<std::streamsize>(std::numeric_limits<size_t>::max())
                                  , n
                                )
                            )
                          : static_cast<size_t>(n);
        std::setvbuf(file_, s, s == 0 && n == 0 ? _IONBF : _IOFBF, n_size_t);
        return this;
    }
 
    pos_type seekoff(off_type off
                     , std::ios_base::seekdir dir
                     , std::ios_base::openmode = std::ios_base::in | std::ios_base::out)
    {
        int whence;
        switch(dir)
        {
        case std::ios_base::beg:
            whence = SEEK_SET;
            break;
        case std::ios_base::cur:
            whence = SEEK_CUR;
            break;
        case std::ios_base::end:
            whence = SEEK_END;
            break;
        default:
            return pos_type(-1);
        }
        if(off <= std::numeric_limits<off_type>::max() && std::fseek(file_, off, whence) == 0)
        {
            std::fpos_t pos;
            std::fgetpos(file_, &pos);
            return pos_type(pos);
        }
        return pos_type(-1);
    }
 
    pos_type seekpos(pos_type pos
                     , std::ios_base::openmode = std::ios_base::in | std::ios_base::out)
    {
        std::fpos_t p(pos);
        return std::fsetpos(file_, &p) == 0 ? pos : pos_type(-1);
    }
 
    int sync()
    {
        return std::fflush(file_) == 0 ? 0 : -1;
    }
 
    std::streamsize showmanyc()
    {
        return -1;
    }
 
    int_type overflow(int_type c = traits_type::eof())
    {
        if(c == traits_type::eof())
        {
            std::ptrdiff_t unwritten = this->pptr() - this->pbase();
            if(unwritten != 0)
            {
                std::fflush(file_);
                if(this->pptr() - this->pbase() < unwritten)
                {
                    return traits_type::not_eof(c);
                }
                return traits_type::eof();
            }
            return traits_type::not_eof(c);
        }
        else
        {
            int result = putc(c, file_);
            return result != EOF ? result : traits_type::eof();
        }
    }
 
private:
    FILE * file_;
};
 
#include <ostream>
 
int main()
{
    console_buffer conBuf(stdout);
    std::basic_ostream<char, std::char_traits<char> > conOut(&conBuf);
 
    conOut << "TeSt";
}