int main()
{
  using namespace std;
  wstring ws = L"wide string";
  //setlocale(LC_ALL, "russian");
  ostream_iterator<char> osi(cout);
  transform(ws.begin(), ws.end(), osi, wctob);
}

struct widen : std::unary_function<char, wchar_t>
{
   widen(const std::ctype<wchar_t> &ct)
      : charType(ct)
   {}
   wchar_t operator()(char c)
   {
      return charType.widen(c);
   }
private:
   const std::ctype<wchar_t> &charType;
};

struct narrow : std::unary_function<wchar_t, char>
{
   narrow(const std::ctype<wchar_t> &ct)
      : charType(ct)
   {}
   char operator()(wchar_t c)
   {
      return charType.narrow(c);
   }
private:
   const std::ctype<wchar_t> &charType;
};
inline std::wstring to_wstring(const std::string &s, const std::locale &curLocale = std::locale::classic())
{
   std::wstring retVal;
   widen w(std::use_facet<std::ctype<wchar_t> >(curLocale));
   std::transform(s.begin(), s.end(), std::back_inserter(retVal), w);
   return retVal;
}

inline std::string to_string(const std::wstring &s, const std::locale &curLocale = std::locale::classic())
{
   std::string retVal;
   narrow n(std::use_facet<std::ctype<wchar_t> >(curLocale));
   std::transform(s.begin(), s.end(), std::back_inserter(retVal), n);
   return retVal;
}

переносимо сделать преобразование

ofstream& operator<<(ofstream&, char);

int main()
{
  using namespace std;
  wstring ws = L"wide строка.";
  //setlocale(LC_ALL, ".1251"); // хз как получить кодовую стариницу, потому альтернатива ниже
  locale::global(locale(".1251")); // кодировка для конверсии wctob
  cout << cout.getloc().name() << '\n';
  cout.imbue(locale()); // устанавливаем для стрима глобальную локаль, кодировка выбрана выше
  cout << cout.getloc().name() << '\n';
  cout.imbue(locale(".1252")); // не влияет на конверсию
  cout << cout.getloc().name() << '\n';
  ostream_iterator<char> osi(cout);
  transform(ws.begin(), ws.end(), osi, wctob);
}

C
Russian_Russia.1251
Russian_Russia.1252
wide строка.

setlocale(LC_ALL, "russian");

MC>А если локаль — utf8?

Say, for example, you have a code conversion facet called codecvt_utf8 that you want to use to output to cout a UTF-8 multibyte sequence corresponding to a wide string

Note that the Standard C++ library currently uses code conversion facets only within template class basic_filebuf, for converting from multibyte sequences when reading from a file and for converting to multibyte sequences when writing to a file

  wfstream wf("log", std::ios::out|std::ios::trunc);
  wf << L"ddd";

GN>int main()
GN>{
GN>  using namespace std;
GN>  wstring ws = L"wide string";
GN>  //setlocale(LC_ALL, "russian");
GN>  ostream_iterator<char> osi(cout);
GN>  transform(ws.begin(), ws.end(), osi, wctob);
GN>}
GN>

#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <wchar.h>

int main()
{
const wchar_t *str = L"Превед мир.";
char buf[256];
int i;
    setlocale(LC_ALL, "");

    i=wcstombs(buf, str, sizeof(buf));
    if (i<0) {
        printf("wcstombs: can't convert in current locale.\n");
    } else {
        printf("wcstombs: %s\n", buf);
    }

    fputs("wctomb: ", stdout);
    while (*str) {
        i=wctob(*str++);
        if (i>0) putchar(i);
    }
    putchar('\n');
    
    return 0;
}

$ gcc -Wall test.c
$ locale |grep LC_CTYPE
LC_CTYPE=ru_RU.KOI8-R
$ ./a.out 
wcstombs: Перевед мир.
wctomb: Перевед мир.
$ LC_ALL=ru_RU.UTF-8 ./a.out | iconv -f utf8
wcstombs: Перевед мир.
wctomb:  .

Description
The wctob function determines whether c corresponds to a member of the extended
character set whose multibyte character representation is a single byte when in the initial
shift state.

Returns
The wctob returns EOF if c does not correspond to a multibyte character with length
one in the initial shift state. Otherwise, it returns the single-byte representation of that
character as an unsigned char converted to an int.

GN>>int main()
GN>>{
GN>>  using namespace std;
GN>>  wstring ws = L"wide string";
GN>>  //setlocale(LC_ALL, "russian");
GN>>  ostream_iterator<char> osi(cout);
GN>>  transform(ws.begin(), ws.end(), osi, wctob);
GN>>}
GN>>

int main()
{
  setlocale(LC_ALL, "");
  wprintf(L"Перевед мир.");
  printf("Перевед мир.");
}

    if (i<0) {
        printf("wcstombs: can't convert in current locale.\n");

The wcstombs function converts a sequence of wide characters from the array pointed
to by pwcs into a sequence of corresponding multibyte characters that begins in the
initial shift state, and stores these multibyte characters into the array pointed to by s,
stopping if a multibyte character would exceed the limit of n total bytes or if a null
character is stored.

    // set C/C++ locale
    cout << "set system console locale..." 
         << endl
         << "C locale: "
         << setlocale(LC_ALL, "")
         << endl;
    locale::global(locale(""));
    cout << "C++ locale: "
         << locale().name().c_str()
         << endl
         << endl;
    //--------------------------------------------------------------------------
    // set C++ stream locale
    cout.imbue(locale());
    clog.imbue(locale());
    cerr.imbue(locale());
    wcout.imbue(locale());
    wclog.imbue(locale());
    wcerr.imbue(locale());
    //--------------------------------------------------------------------------
    // don't sync. c and c++ streams
    ios::sync_with_stdio(false);
    //--------------------------------------------------------------------------