virtual result do_in(
     StateType& _State,
      const Byte* _First1, 
       const Byte* _Last1, 
     const Byte*& _Next1,
      CharType* _First2,
       CharType* _Last2,
      CharType*& _Next2,
) const;

_State
The conversion state that is maintained between calls to the member function.

_First1
Pointer to the beginning of the sequence to be converted.

_Last1
Pointer to the end of the sequence to be converted.

_Next1
Pointer beyond the end of the converted sequence, to the first unconverted character.

_First2
Pointer to the beginning of the converted sequence.

_Last2
Pointer to the end of the converted sequence.

_Next2
Pointer to the CharType that comes after the last converted CharType, to the first unaltered character in the destination sequence.


Return Value
A return that indicates the success, partial success, or failure of the operation. The function returns:

codecvt_base::error if the source sequence is ill formed.
codecvt_base::noconv if the function performs no conversion.
codecvt_base::ok if the conversion succeeds.
codecvt_base::partial if the source is insufficient or if the destination is not large enough, for the conversion to succeed.

codecvt Class
A template class that describes an object that can serve as a locale facet that is able to control conversions between a sequence of values used to encode characters within the program and a sequence of values used to encode characters outside the program.

#include "stdafx.h"
#include <stdlib.h>
#include <windows.h>

class console_stream
{
public:
  console_stream( unsigned t ): h(0) { h = GetStdHandle(t); }
  console_stream& operator << (const wchar_t* str) { write(str); return *this; }
  console_stream& operator << (int i) { wchar_t buf[64]; write(_itow(i,buf,10)); return *this; }
private:
  void write(const wchar_t* str)
  {
    DWORD numchars;
    if(h) WriteConsoleW(h,str,wcslen(str),&numchars,0);
  }
  HANDLE h;
};

console_stream cin(STD_INPUT_HANDLE), cout(STD_OUTPUT_HANDLE), cerr(STD_ERROR_HANDLE);

#pragma setlocale( "russian" )

int main(int argc, char* argv[])
{
  cout << L"Привет мир!\n";
    return 0;
}

CS>#include "stdafx.h"
CS>#include <stdlib.h>
CS>#include <windows.h>

CS>class console_stream
CS>{
CS>public:
CS>  console_stream( unsigned t ): h(0) { h = GetStdHandle(t); }
CS>  console_stream& operator << (const wchar_t* str) { write(str); return *this; }
CS>  console_stream& operator << (int i) { wchar_t buf[64]; write(_itow(i,buf,10)); return *this; }
CS>private:
CS>  void write(const wchar_t* str)
CS>  {
CS>    DWORD numchars;
CS>    if(h) WriteConsoleW(h,str,wcslen(str),&numchars,0);
CS>  }
CS>  HANDLE h;
CS>};

CS>console_stream cin(STD_INPUT_HANDLE), cout(STD_OUTPUT_HANDLE), cerr(STD_ERROR_HANDLE);

CS>#pragma setlocale( "russian" )

CS>int main(int argc, char* argv[])
CS>{
CS>  cout << L"Привет мир!\n";
CS>    return 0;
CS>}
CS>

#include <iostream>
#include <io.h>
#include <fcntl.h>

int main(int argc, char* argv[])
{
    _setmode(_fileno(stdout), _O_U16TEXT);
    std::wcout << L"Привет мир!";
    return 0;
}

If a comment in the first or second line of the Python script matches the regular expression coding[=:]\s*([-\w.]+), this comment is processed as an encoding declaration; the first group of this expression names the encoding of the source code file. The recommended forms of this expression are

# -*- coding: <encoding-name> -*-

which is recognized also by GNU Emacs, and

# vim:fileencoding=<encoding-name>

which is recognized by Bram Moolenaar’s VIM. In addition, if the first bytes of the file are the UTF-8 byte-order mark ('\xef\xbb\xbf'), the declared file encoding is UTF-8 (this is supported, among others, by Microsoft’s notepad).

If an encoding is declared, the encoding name must be recognized by Python. The encoding is used for all lexical analysis, in particular to find the end of a string, and to interpret the contents of Unicode literals. String literals are converted to Unicode for syntactical analysis, then converted back to their original encoding before interpretation starts. The encoding declaration must appear on a line of its own.