Annex D (normative) Compatibility features [depr]

D.21 Deprecated convenience conversion interfaces [depr.conversions]

D.21.1 Class template wstring_­convert [depr.conversions.string]

Class template wstring_­convert performs conversions between a wide string and a byte string.
It lets you specify a code conversion facet (like class template codecvt) to perform the conversions, without affecting any streams or locales.
[Example
:
If you want to use the code conversion facet codecvt_­utf8 to output to cout a UTF-8 multibyte sequence corresponding to a wide string, but you don't want to alter the locale for cout, you can write something like:
wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
std::string mbstring = myconv.to_bytes(L"Hello\n");
std::cout << mbstring;
— end example
]
namespace std {
  template<class Codecvt, class Elem = wchar_t,
           class WideAlloc = allocator<Elem>,
           class ByteAlloc = allocator<char>>
    class wstring_convert {
    public:
      using byte_string = basic_string<char, char_traits<char>, ByteAlloc>;
      using wide_string = basic_string<Elem, char_traits<Elem>, WideAlloc>;
      using state_type  = typename Codecvt::state_type;
      using int_type    = typename wide_string::traits_type::int_type;

      wstring_convert() : wstring_convert(new Codecvt) {}
      explicit wstring_convert(Codecvt* pcvt);
      wstring_convert(Codecvt* pcvt, state_type state);
      explicit wstring_convert(const byte_string& byte_err,
                               const wide_string& wide_err = wide_string());
      ~wstring_convert();

      wstring_convert(const wstring_convert&) = delete;
      wstring_convert& operator=(const wstring_convert&) = delete;

      wide_string from_bytes(char byte);
      wide_string from_bytes(const char* ptr);
      wide_string from_bytes(const byte_string& str);
      wide_string from_bytes(const char* first, const char* last);

      byte_string to_bytes(Elem wchar);
      byte_string to_bytes(const Elem* wptr);
      byte_string to_bytes(const wide_string& wstr);
      byte_string to_bytes(const Elem* first, const Elem* last);

      size_t converted() const noexcept;
      state_type state() const;

    private:
      byte_string byte_err_string;  // exposition only
      wide_string wide_err_string;  // exposition only
      Codecvt* cvtptr;              // exposition only
      state_type cvtstate;          // exposition only
      size_t cvtcount;              // exposition only
    };
}
The class template describes an object that controls conversions between wide string objects of class basic_­string<Elem, char_­traits<Elem>, WideAlloc> and byte string objects of class basic_­string<char, char_­traits<char>, ByteAlloc>.
The class template defines the types wide_­string and byte_­string as synonyms for these two types.
Conversion between a sequence of Elem values (stored in a wide_­string object) and multibyte sequences (stored in a byte_­string object) is performed by an object of class Codecvt, which meets the requirements of the standard code-conversion facet codecvt<Elem, char, mbstate_­t>.
An object of this class template stores:
  • byte_­err_­string — a byte string to display on errors
  • wide_­err_­string — a wide string to display on errors
  • cvtptr — a pointer to the allocated conversion object (which is freed when the wstring_­convert object is destroyed)
  • cvtstate — a conversion state object
  • cvtcount — a conversion count
using byte_string = basic_string<char, char_traits<char>, ByteAlloc>;
The type shall be a synonym for basic_­string<char, char_­traits<char>, ByteAlloc>.
size_t converted() const noexcept;
Returns: cvtcount.
wide_string from_bytes(char byte); wide_string from_bytes(const char* ptr); wide_string from_bytes(const byte_string& str); wide_string from_bytes(const char* first, const char* last);
Effects: The first member function shall convert the single-element sequence byte to a wide string.
The second member function shall convert the null-terminated sequence beginning at ptr to a wide string.
The third member function shall convert the sequence stored in str to a wide string.
The fourth member function shall convert the sequence defined by the range [first, last) to a wide string.
In all cases:
  • If the cvtstate object was not constructed with an explicit value, it shall be set to its default value (the initial conversion state) before the conversion begins. Otherwise it shall be left unchanged.
  • The number of input elements successfully converted shall be stored in cvtcount.
Returns: If no conversion error occurs, the member function shall return the converted wide string.
Otherwise, if the object was constructed with a wide-error string, the member function shall return the wide-error string.
Otherwise, the member function throws an object of class range_­error.
using int_type = typename wide_string::traits_type::int_type;
The type shall be a synonym for wide_­string​::​traits_­type​::​int_­type.
state_type state() const;
returns cvtstate.
using state_type = typename Codecvt::state_type;
The type shall be a synonym for Codecvt​::​state_­type.
byte_string to_bytes(Elem wchar); byte_string to_bytes(const Elem* wptr); byte_string to_bytes(const wide_string& wstr); byte_string to_bytes(const Elem* first, const Elem* last);
Effects: The first member function shall convert the single-element sequence wchar to a byte string.
The second member function shall convert the null-terminated sequence beginning at wptr to a byte string.
The third member function shall convert the sequence stored in wstr to a byte string.
The fourth member function shall convert the sequence defined by the range [first, last) to a byte string.
In all cases:
  • If the cvtstate object was not constructed with an explicit value, it shall be set to its default value (the initial conversion state) before the conversion begins.
    Otherwise it shall be left unchanged.
  • The number of input elements successfully converted shall be stored in cvtcount.
Returns: If no conversion error occurs, the member function shall return the converted byte string.
Otherwise, if the object was constructed with a byte-error string, the member function shall return the byte-error string.
Otherwise, the member function shall throw an object of class range_­error.
using wide_string = basic_string<Elem, char_traits<Elem>, WideAlloc>;
The type shall be a synonym for basic_­string<Elem, char_­traits<Elem>, WideAlloc>.
explicit wstring_convert(Codecvt* pcvt); wstring_convert(Codecvt* pcvt, state_type state); explicit wstring_convert(const byte_string& byte_err, const wide_string& wide_err = wide_string());
Requires: For the first and second constructors, pcvt != nullptr.
Effects: The first constructor shall store pcvt in cvtptr and default values in cvtstate, byte_­err_­string, and wide_­err_­string.
The second constructor shall store pcvt in cvtptr, state in cvtstate, and default values in byte_­err_­string and wide_­err_­string; moreover the stored state shall be retained between calls to from_­bytes and to_­bytes.
The third constructor shall store new Codecvt in cvtptr, state_­type() in cvtstate, byte_­err in byte_­err_­string, and wide_­err in wide_­err_­string.
~wstring_convert();
Effects: The destructor shall delete cvtptr.