Re: wcout, VS2008 and UTF-16

Greetings.

I'm am currently trying to output wchar_t (== UTF-16) to the windows
console. (The console can display UTF_16 just fine if you change the font
to lucida console - easiest verified with adding a filename with some
greek or cyrillic characters in it and calling dir)

Now, my problem is, that the default wcout stream on windows will convert
wchar_t characters to multibyte.
One can overcome this by adding codecvt like described here:
http://www.ddj.com/cpp/184403638;jsessionid=ADO5UI2ASFTGBQE1GHOSKHWATMY32JVN?pgno=1

However, this only works for binary streams.

The reason that it does not work with wcout is that basic_filebuf<wchar_t,
..> , on which wcout is based will use fputwc(..) internally. This
function will still try to convert the wchar_t to multibyte unless the
stream is opened in binary mode.

So ... is it possible at all to get wcout to send full UTF-16 to the
console?

thanks,
Martin

Test code:
main.cpp
########
#include "stdafx.h"
#include <stdexcept>
#include <iostream>
#include <fstream>

#include <locale>

using std::codecvt ;
typedef codecvt < wchar_t , char , mbstate_t > NullCodecvtBase ;

class NullCodecvt : public NullCodecvtBase
{
public:
typedef wchar_t elem_t;
typedef char outp_t;
typedef mbstate_t state_t;

explicit NullCodecvt(size_t r=0 ) : NullCodecvtBase(r) { }

protected:
virtual result do_in(state_t& /* conversion state */,
                     const outp_t* /* begin convert */,
const outp_t* /* end convert */,
const outp_t*& /* next convert */,
elem_t* /* begin converted */,
elem_t* /* end converted */,
elem_t*& /* next converted */) const {
return noconv ;
}

virtual result do_out(state_t& ,
                      const elem_t* ,
const elem_t* ,
const elem_t*& ,
outp_t* ,
elem_t* ,
outp_t*& ) const {
return noconv ;
}

virtual result do_unshift(state_t& ,
                          outp_t* ,
outp_t* ,
outp_t*& ) const {
return noconv ;
}

virtual int do_length(state_t& ,
                      const outp_t* _F1,
                      const outp_t* _L1,
size_t _N2) const _THROW0() {
return (_N2 < (size_t)(_L1 - _F1)) ? _N2 : _L1 - _F1 ;
}

virtual bool do_always_noconv() const _THROW0() {
return true ;
}

virtual int do_max_length() const _THROW0() {
return 2 ;
}

virtual int do_encoding() const _THROW0() {
return 2 ;
}
};

int main()
{
using namespace std;
try {
// --- init locale ---
const char* locale_id = "german_Germany";
setlocale(LC_ALL, locale_id); // Need to set C locale for fputwc
conversions
std::locale newloc(std::locale(locale_id), new NullCodecvt());
std::locale::global( newloc );

// --- try with wofstream ---
wofstream f;
f.exceptions( ios::badbit | ios::failbit | ios::eofbit );
f.imbue( newloc );
// wchar_t output requires binary output !! (otherwise fputwc fails to
write non-basic wchar_t characters)
f.open("testuni.txt", ios_base::out | ios_base::binary);

// Output works just fine on a Latin1 Windows (e.g. german)
// (But note that we need to supply \r\n for a binary file)
f << L"aAbB ... ???? ... ? ? ? ...\r\n";
f << L"\u03C9 (greek omega) \r\n";
f.close();

// --- try with wcout ---
wcout.exceptions( ios::badbit | ios::failbit | ios::eofbit );
wcout.imbue( newloc );
wcout << L"aAbB ... ???? ... ? ? ? ...\n"; // Works just fine on (Latin1
charset)
wcout << L"\u03C9 (greek omega) \n"; // Will set badbit, since fputwc
fails

} catch(std::exception const& e) {
cerr << "X!: " << e.what() << endl;
return 1;
}
return 0;
}