std::codecvt::in

Parameters

state

A state object, as required by the facet instantiation.
Typically, this is an object of type mbstate_t, able to keep track of the shift state of a multibyte character conversion.
Member type state_type is the facet's state type (defined as an alias of codecvt's third template parameter, stateT).

from, from_end

Pointer to the initial and final characters of the source sequence. The range used is [from,from_end), which contains all the characters between from and from_end, including the character pointed by from but not the character pointed by from_end.
Note that null characters (if any) are also translated, and the function proceeds beyond them until from_end.
Member type extern_type is the facet's external character type (defined as an alias of codecvt's second template parameter, exnternT).

from_next

Pointer able to point to an element in the above range. Once the function returns, this object points to the element in the source range beyond the last one successfully translated.

to, to_limit

Pointer to the initial and final characters of the destination sequence. The range used is, at most, [to,to_limit), which contains all the characters between to and to_limit, including the character pointed by to but not the character pointed by to_limit.
A translation does not necessarily need to fill up the range to its limit, and may also exhaust it before finishing.
No additional null character is automatically appended (other than those translated from the source sequence).
Member type intern_type is the facet's internal character type (defined as an alias of codecvt's first template parameter, internT).

to_next

Pointer able to point to an element in the above range. Once the function returns, this object points to the element in the destination range beyond the last one successfully translated.

Return value

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// codecvt::in example
#include <iostream>       // std::wcout, std::wcout
#include <locale>         // std::locale, std::codecvt, std::use_facet
#include <string>         // std::wstring
#include <cwchar>         // std::mbstate_t

int main ()
{
  typedef std::codecvt<wchar_t,char,std::mbstate_t> facet_type;

  std::locale mylocale;

  const facet_type& myfacet = std::use_facet<facet_type>(mylocale);

  const char mystr[] = "Test string";

  // prepare objects to be filled by codecvt::in :
  wchar_t pwstr[sizeof(mystr)];              // the destination buffer (might be too short)
  std::mbstate_t mystate = std::mbstate_t(); // the shift state object
  const char* pc;                            // from_next
  wchar_t* pwc;                              // to_next

  // translate characters:
  facet_type::result myresult = myfacet.in (mystate,
      mystr, mystr+sizeof(mystr), pc,
      pwstr, pwstr+sizeof(mystr), pwc);

  if ( myresult == facet_type::ok )
  {
    std::wcout << L"Translation successful: ";
    std::wcout << pwstr << std::endl;
  }
  return 0;
}

Translation successful: Test string

Data races

Exception safety

See also

codecvt::out

Translate out characters (public member function )

codecvt::unshift

Unshift translation state (public member function )

codecvt::do_in

Translate in characters [virtual] (protected virtual member function )