[locales] - C++11 → C++14

Files changed (1) hide show

tmp/tmpkyzmhuri/{from.md → to.md} +45 -34

tmp/tmpkyzmhuri/{from.md → to.md} RENAMED Viewed

@@ -209,20 +209,20 @@ The provided implementation of members of facets `num_get<charT>` and
 `num_put<charT>` calls `use_facet <F> (l)` only for facet `F` of types
 `numpunct<charT>` and `ctype<charT>`, and for locale `l` the value
 obtained by calling member `getloc()` on the `ios_base&` argument to
 these functions.
-In declarations of facets, a template formal parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that satisfy the requirements of an Input
 Iterator or an Output Iterator, respectively (
-[[iterator.requirements]]). A template formal parameter with name `C`
 represents the set of types containing `char`, `wchar_t`, and any other
 implementation-defined character types that satisfy the requirements for
 a character on which any of the iostream components can be instantiated.
-A template formal parameter with name `International` represents the set
-of all possible specializations on a bool parameter.
 ##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
@@ -312,14 +312,10 @@ value for arguments of functions that take a `const locale&` argument.
 locale(const locale& other) noexcept;
 ```
 *Effects:* Constructs a locale which is a copy of `other`.
-*Effects:* Creates a copy of `other`, replacing the current value.
-*Returns:* `*this`
 ``` cpp
 explicit locale(const char* std_name);
 ```
 *Effects:* Constructs a locale using standard C locale names, e.g.,
@@ -379,10 +375,14 @@ arguments have names.
 ``` cpp
 const locale& operator=(const locale& other) noexcept;
 ```
 ``` cpp
 ~locale();
 ```
 A non-virtual destructor that throws no exceptions.
@@ -560,18 +560,17 @@ template <class charT> charT tolower(charT c, const locale& loc);
 ##### `string` conversions <a id="conversions.string">[[conversions.string]]</a>
 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. 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, but
-you don’t want to alter the locale for `cout`. You can write something
-like:
 ``` cpp
-wstring_convert<codecvt_utf8<wchar_t>> myconv;
 std::string mbstring = myconv.to_bytes(L"Hello\n");
 std::cout << mbstring;
 ```
 ``` cpp
@@ -583,27 +582,30 @@ template<class Codecvt, class Elem = wchar_t,
     typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
     typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
     typedef typename Codecvt::state_type state_type;
     typedef typename wide_string::traits_type::int_type int_type;
-    wstring_convert(Codecvt *pcvt = new Codecvt);
     wstring_convert(Codecvt* pcvt, state_type state);
-    wstring_convert(const byte_string& byte_err,
                              const wide_string& wide_err = wide_string());
     ~wstring_convert();
     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;
     state_type state() const;
   private:
     byte_string byte_err_string;    // exposition only
     wide_string wide_err_string;    // exposition only
     Codecvt* cvtptr;                // exposition only
@@ -616,15 +618,14 @@ template<class Codecvt, class Elem = wchar_t,
 The class template describes an object that controls conversions between
 wide string objects of class `std::basic_string<Elem, char_traits<Elem>,
 Wide_alloc>` and byte string objects of class `std::\\basic_string<char,
 char_traits<char>, Byte_alloc>`. 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<Elem, char, std::mbstate_t>`,
-which meets the requirements of the standard code-conversion facet
-`std::codecvt<Elem,
 char, std::mbstate_t>`.
 An object of this class template stores:
 - `byte_err_string` — a byte string to display on errors
@@ -633,17 +634,18 @@ An object of this class template stores:
   freed when the `wstring_convert` object is destroyed)
 - `cvtstate` — a conversion state object
 - `cvtcount` — a conversion count
 ``` cpp
-typedef std::basic_string<char> byte_string;
 ```
-The type shall be a synonym for `std::basic_string<char>`
 ``` cpp
-size_t converted() const;
 ```
 *Returns:* `cvtcount`.
 ``` cpp
@@ -719,22 +721,25 @@ 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 `std::range_error`.
 ``` cpp
-typedef std::basic_string<Elem> wide_string;
 ```
-The type shall be a synonym for `std::basic_string<Elem>`.
 ``` cpp
-wstring_convert(Codecvt *pcvt = new Codecvt);
 wstring_convert(Codecvt* pcvt, state_type state);
-wstring_convert(const byte_string& byte_err,
     const wide_string& wide_err = wide_string());
 ```
 *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
@@ -764,14 +769,19 @@ template<class Codecvt,
   class wbuffer_convert
     : public std::basic_streambuf<Elem, Tr> {
   public:
     typedef typename Codecvt::state_type state_type;
-    wbuffer_convert(std::streambuf *bytebuf = 0,
                              Codecvt* pcvt = new Codecvt,
                              state_type state = state_type());
     std::streambuf* rdbuf() const;
     std::streambuf* rdbuf(std::streambuf* bytebuf);
     state_type state() const;
@@ -785,13 +795,12 @@ template<class Codecvt,
 The class template describes a stream buffer that controls the
 transmission of elements of type `Elem`, whose character traits are
 described by the class `Tr`, to and from a byte stream buffer of type
 `std::streambuf`. Conversion between a sequence of `Elem` values and
-multibyte sequences is performed by an object of class
-`Codecvt<Elem, char, std::mbstate_t>`, which shall meet the requirements
-of the standard code-conversion facet
 `std::codecvt<Elem, char, std::mbstate_t>`.
 An object of this class template stores:
 - `bufptr` — a pointer to its underlying byte stream buffer
@@ -824,14 +833,16 @@ typedef typename Codecvt::state_type state_type;
 ```
 The type shall be a synonym for `Codecvt::state_type`.
 ``` cpp
-wbuffer_convert(std::streambuf *bytebuf = 0,
     Codecvt* pcvt = new Codecvt, state_type state = state_type());
 ```
 *Effects:* The constructor constructs a stream buffer object,
 initializes `bufptr` to `bytebuf`, initializes `cvtptr` to `pcvt`, and
 initializes `cvtstate` to `state`.
 ``` cpp

 `num_put<charT>` calls `use_facet <F> (l)` only for facet `F` of types
 `numpunct<charT>` and `ctype<charT>`, and for locale `l` the value
 obtained by calling member `getloc()` on the `ios_base&` argument to
 these functions.
+In declarations of facets, a template parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that satisfy the requirements of an Input
 Iterator or an Output Iterator, respectively (
+[[iterator.requirements]]). A template parameter with name `C`
 represents the set of types containing `char`, `wchar_t`, and any other
 implementation-defined character types that satisfy the requirements for
 a character on which any of the iostream components can be instantiated.
+A template parameter with name `International` represents the set of all
+possible specializations on a bool parameter.
 ##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
 locale(const locale& other) noexcept;
 ```
 *Effects:* Constructs a locale which is a copy of `other`.
 ``` cpp
 explicit locale(const char* std_name);
 ```
 *Effects:* Constructs a locale using standard C locale names, e.g.,
 ``` cpp
 const locale& operator=(const locale& other) noexcept;
 ```
+*Effects:* Creates a copy of `other`, replacing the current value.
+*Returns:* `*this`
 ``` cpp
 ~locale();
 ```
 A non-virtual destructor that throws no exceptions.
 ##### `string` conversions <a id="conversions.string">[[conversions.string]]</a>
 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. 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:
 ``` cpp
+wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
 std::string mbstring = myconv.to_bytes(L"Hello\n");
 std::cout << mbstring;
 ```
 ``` cpp
     typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
     typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
     typedef typename Codecvt::state_type state_type;
     typedef typename wide_string::traits_type::int_type int_type;
+ explicit wstring_convert(Codecvt* pcvt = new Codecvt);
     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
 The class template describes an object that controls conversions between
 wide string objects of class `std::basic_string<Elem, char_traits<Elem>,
 Wide_alloc>` and byte string objects of class `std::\\basic_string<char,
 char_traits<char>, Byte_alloc>`. 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 `std::codecvt<Elem,
 char, std::mbstate_t>`.
 An object of this class template stores:
 - `byte_err_string` — a byte string to display on errors
   freed when the `wstring_convert` object is destroyed)
 - `cvtstate` — a conversion state object
 - `cvtcount` — a conversion count
 ``` cpp
+typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
 ```
+The type shall be a synonym for
+`std::basic_string<char, char_traits<char>, Byte_alloc>`
 ``` cpp
+size_t converted() const noexcept;
 ```
 *Returns:* `cvtcount`.
 ``` cpp
 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 `std::range_error`.
 ``` cpp
+typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
 ```
+The type shall be a synonym for
+`std::basic_string<Elem, char_traits<Elem>, Wide_alloc>`.
 ``` cpp
+explicit wstring_convert(Codecvt* pcvt = new Codecvt);
 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
   class wbuffer_convert
     : public std::basic_streambuf<Elem, Tr> {
   public:
     typedef typename Codecvt::state_type state_type;
+ explicit wbuffer_convert(std::streambuf* bytebuf = 0,
                              Codecvt* pcvt = new Codecvt,
                              state_type state = state_type());
+    ~wbuffer_convert();
+    wbuffer_convert(const wbuffer_convert&) = delete;
+    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
     std::streambuf* rdbuf() const;
     std::streambuf* rdbuf(std::streambuf* bytebuf);
     state_type state() const;
 The class template describes a stream buffer that controls the
 transmission of elements of type `Elem`, whose character traits are
 described by the class `Tr`, to and from a byte stream buffer of type
 `std::streambuf`. Conversion between a sequence of `Elem` values and
+multibyte sequences is performed by an object of class `Codecvt`, which
+shall meet the requirements of the standard code-conversion facet
 `std::codecvt<Elem, char, std::mbstate_t>`.
 An object of this class template stores:
 - `bufptr` — a pointer to its underlying byte stream buffer
 ```
 The type shall be a synonym for `Codecvt::state_type`.
 ``` cpp
+explicit wbuffer_convert(std::streambuf* bytebuf = 0,
     Codecvt* pcvt = new Codecvt, state_type state = state_type());
 ```
+*Requires:* `pcvt != nullptr`.
 *Effects:* The constructor constructs a stream buffer object,
 initializes `bufptr` to `bytebuf`, initializes `cvtptr` to `pcvt`, and
 initializes `cvtstate` to `state`.
 ``` cpp

Diff to HTML by rtfpessoa