Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I've recently had to print some national symbols in windows console using Mingw and found, that I got nothing in the output, if I use wide strings.

So, I studied the problem and found out that it is locale problem. I was unable to find somewhere complete solution, so I had to write something, that seems to work.

So, I decided to publish it here for review, or may be I should publish it somewhere it it worth.

  • I've tested in Mingw 4.7.0 using Russian locale.
  • It should probably correctly convert wide strings to national OEM encoded strings.

Code:

#ifndef CUSTOM_LOCALE_H
#define CUSTOM_LOCALE_H

#if (__cplusplus >= 201103L)
#define CUSTOM_LOCALE_OVERRIDE override
#else 
#define CUSTOM_LOCALE_OVERRIDE
#endif

#include <locale>
#include <iostream>
#include <windows.h>

namespace custom_locale
{

class CustomLocale : public std::codecvt <wchar_t, char, std::mbstate_t> {
  public:
    explicit CustomLocale ( size_t r = 0 ) : std::codecvt <wchar_t, char, std::mbstate_t> (r) {}

  protected:
    result do_in (state_type&, const char* from, const char* from_end, 
                  const char*& from_next, wchar_t* to, wchar_t* to_end, wchar_t*& to_next ) const CUSTOM_LOCALE_OVERRIDE
    {
        std::size_t size = from_end - from;
        std::size_t buffer_size = to_end - to;
        std::size_t written = MultiByteToWideChar(CP_OEMCP, 0, from, size, to, buffer_size);
        to_next = to + written;
        if (written == 0) {
            return error;
        }
        else if (written != buffer_size) {
            return partial;
        }
        else {
            return  ok;
        }
    }

    result do_out (state_type&, const wchar_t* from, const wchar_t* from_end, 
                   const wchar_t*& from_next, char* to, char* to_end, char*& to_next ) const CUSTOM_LOCALE_OVERRIDE
    {
        std::size_t size = from_end - from;
        std::size_t buffer_size = to_end - to;
        std::size_t written = WideCharToMultiByte(CP_OEMCP, 0, from, size, to, buffer_size, 0, 0);
        to_next = to + written;
        if (written == 0) {
            return error;
        }
        else if (written != buffer_size) {
            return partial;
        }
        else {
            return  ok;
        }
    }

    result do_unshift ( state_type&, char*, char*, char*& ) const CUSTOM_LOCALE_OVERRIDE { return ok; }
    int do_encoding () const throw () CUSTOM_LOCALE_OVERRIDE { return 1; }
    bool do_always_noconv () const throw () CUSTOM_LOCALE_OVERRIDE { return false; }

    int do_length ( state_type& state, const char* from, const char* from_end, size_t max ) const CUSTOM_LOCALE_OVERRIDE 
    {
      return std::codecvt <wchar_t, char, std::mbstate_t>::do_length ( state, from, from_end, max );
    }

    int do_max_length () const throw () CUSTOM_LOCALE_OVERRIDE
    {
      return std::codecvt <wchar_t, char, std::mbstate_t>::do_max_length ();
    }
};

inline void init()
{
    std::locale loc ( std::locale(), new CustomLocale() );
    std::ios_base::sync_with_stdio (false);
    std::wcout.imbue(loc);
    std::wcin.imbue(loc);
} 

}

#endif

Example:

#include "custom_locale.h"

int main ()
{
    custom_locale::init();    
    std::wstring s(L"привет");
    std::wcout << s << '\n';
    std::wstring u; 
    std::wcin >> u;
    s += L' ' + u;
    std::wcout << s << '\n';
    return 0;
}
share|improve this question

This is a somewhat old question, but I have an alternative that may work for this. Related to this question, if you turn off the synchronization with the underlying stdio, you can use imbue to set the locale for both wcout and wcin:

#include <locale>
#include <string>
#include <iostream>

int main ()
{
    // this code turns off the sync with stdio
    std::ios_base::sync_with_stdio(false);
    // now create the appropriate locale without setting the global one
    std::locale ru("ru_RU.utf8");
    // use imbue to allow the Russian words to be properly displayed
    std::wcout.imbue(ru);
    // ... and input
    std::wcin.imbue(ru);

    // the rest of the code is essentially unchanged from the original
    std::wstring s(L"привет");
    std::wcout << s << '\n';
    std::wstring u; 
    std::wcin >> u;
    s += L' ' + u;
    std::wcout << s << '\n';
 }

Using it in this way means that no custom class is required.

share|improve this answer
    
Does it work with default windows console settings (code page 866 for ru)? – Lol4t0 Dec 21 '15 at 13:25
    
After doing some thorough testing, no, it does not work with that. I'll work on this further to see if I can at least simplify what you've already done (which I can also verify works). – Edward Dec 23 '15 at 13:00

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.