Создание манипулятора

cout << up << "кибер";

// =======================================================================
// =======================================================================
// =======================================================================
 
#include <locale>
 
namespace tools{
 
#if defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
#endif
 
    template<class str> class string_semantic
    {
        using s = ::std::remove_reference_t<str>;
 
        template<class u> static std::true_type
            check(decltype(&u::c_str)*);
 
        template<class> static std::false_type
            check(...);
 
        using checked     
            = decltype(check<s>(nullptr));
 
        enum { eIS_STRING  = checked::value            };
        enum { eIS_ARRAY   = std::is_array<s>::value   };
        enum { eIS_POINTER = std::is_pointer<s>::value };
    public:
        enum { value = eIS_STRING || eIS_ARRAY || eIS_POINTER };
    };
 
#if defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW__)
    #pragma GCC diagnostic pop
#endif
 
    #define dIF_STRING_SEMANTIC(type_)     \
        ::std::enable_if_t<::tools::string_semantic<type_>::value>* = nullptr
    #define dIF_NOT_STRING_SEMANTIC(type_) \
        ::std::enable_if_t<!::tools::string_semantic<type_>::value>* = nullptr
 
}// namespace tools
 
// =======================================================================
// =======================================================================
// =======================================================================
 
#include <iostream>
 
struct wrap_cout
{
    using manipulator
        = std::wostream&(*)(std::wostream&);
 
    using wrap_manipulator
        = wrap_cout&(*)(wrap_cout&);
 
    wrap_cout(std::wostream& os)
        : os(os), upcase(false)
    {}
    
    template<class T, dIF_STRING_SEMANTIC(T)>
    wrap_cout& operator<< (T&& data) 
    { 
        if(!upcase)
            os << data; 
        else
        {
            std::locale loc("");
            for (auto& ch: data) 
                os << ::std::toupper(ch, loc);
        }
        return *this;
    }
 
    template<class T, dIF_NOT_STRING_SEMANTIC(T)>
    wrap_cout& operator<< (T&& data) 
    { 
        os << std::forward<T>(data); 
        return *this;
    }
 
    wrap_cout& operator<< (manipulator func)
        { func(os); return *this; }
 
    void set_upacase(){ upcase = true;}
private:
    std::wostream& os;
    bool upcase;
};
 
 
wrap_cout& up(wrap_cout& out) 
{
    out.set_upacase();
    return out;
}
 
wrap_cout operator << (std::wostream& out, wrap_cout::wrap_manipulator func)
{
    wrap_cout o(out);
    return func(o); 
}
 
int main()
{
    ::setlocale(LC_ALL, "");
    std::wcout << up << L"кибер\n";
}

//g++  5.4.0
#include <iostream>
#include <string>
#include <exception>
 
 
struct upper{
    upper() : stream(nullptr) {}
    upper(std::ostream &s) : stream(&s) {}
    std::ostream *stream; 
};
 
 
upper operator<<(std::ostream &s, const upper &)
{
    return {s};
}
 
 
 
std::ostream &operator<<(const upper &s, const char *source)
{
    if (s.stream == nullptr) {
        throw std::runtime_error("streami nvalid");
    }
    std::string str(source);
    if (!str.empty()) {
        auto& f = std::use_facet<std::ctype<char>>(s.stream->getloc());
        f.toupper(&str[0], &str[0] + str.size());
    }    
    return *s.stream << str;
}
 
 
 
int main()
{
    upper up;
    std::cout << up << "text";
}

//g++  5.4.0
 
#include <iostream>
 
 
 
struct upper{
    upper() : stream(nullptr) {}
    upper(std::ostream &s) : stream(&s) {}
    std::ostream *stream; 
};
 
 
upper operator<<(std::ostream &s, const upper &)
{
    return {s};
}
 
 
 
std::ostream &operator<<(const upper &s, const char *source)
{
    std::string str(source);
    if (!str.empty() && s.stream != nullptr) {
        auto& f = std::use_facet<std::ctype<char>>(s.stream->getloc());
        f.toupper(&str[0], &str[0] + str.size());
    }    
    return *s.stream << str;
}
 
 
 
int main()
{
    upper up;
    std::cout << up << "кибер";
}

//g++  5.4.0
#include <iostream>
#include <string>
#include <exception>
 
 
#include <boost/locale.hpp>
#include <boost/algorithm/string/case_conv.hpp>
    
 
 
struct upper{
    upper() = default;
    upper(std::ostream &s) : stream(std::make_unique<std::ostream>(s.rdbuf())) {
        boost::locale::generator gen;
        std::locale loc = gen("ru_RU.UTF-8"); 
        stream->imbue(loc);
    }
    std::unique_ptr<std::ostream> stream; 
};
 
 
upper operator<<(std::ostream &s, const upper &)
{
    return {s};
}
 
 
 
std::ostream &operator<<(const upper &s, const char *source)
{
    if (!s.stream) {
        throw std::runtime_error("invalid stream");
    }
    return *s.stream << boost::locale::to_upper(source, s.stream->getloc());
}
 
 
 
int main()
{
    upper up;
    
    std::cout << up << "Для hoggy";
}