[locale.num.get] - C++14 → C++17

Files changed (1) hide show

tmp/tmpolq6r251/{from.md → to.md} +37 -29

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

@@ -3,12 +3,12 @@
 ``` cpp
 namespace std {
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
-    typedef charT            char_type;
-    typedef InputIterator    iter_type;
       explicit num_get(size_t refs = 0);
       iter_type get(iter_type in, iter_type end, ios_base&,
                     ios_base::iostate& err, bool& v) const;
@@ -180,12 +180,12 @@ as indicated in Table [[tab:localization.length.modifier.in]].
 | `double`             | `l`             |
 | `long double`        | `L`             |
 - **Stage 2:**
-If `in==end` then stage 2 terminates. Otherwise a `charT` is taken from
-`in` and local variables are initialized as if by
 ``` cpp
 char_type ct = *in;
 char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms];
 if (ct == use_facet<numpunct<charT>>(loc).decimal_point())
@@ -203,11 +203,11 @@ char_type atoms[sizeof(src)];
 use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms);
 ```
 for this value of `loc`.
-If `discard` is true, then if `’.’` has not yet been accumulated, then
 the position of the character is remembered, but the character is
 otherwise ignored. Otherwise, if `’.’` has already been accumulated, the
 character is discarded and Stage 2 terminates. If it is not discarded,
 then a check is made to determine if `c` is allowed as the next
 character of an input field of the conversion specifier returned by
@@ -224,54 +224,60 @@ header `<cstdlib>`:
 - For a signed integer value, the function `strtoll`.
 - For an unsigned integer value, the function `strtoull`.
-- For a floating-point value, the function `strtold`.
 The numeric value to be stored can be one of:
-- zero, if the conversion function fails to convert the entire field.
-  `ios_base::failbit` is assigned to `err`.
-- the most positive representable value, if the field represents a value
- too large positive to be represented in `val`. `ios_base::failbit` is
- assigned to `err`.
-- the most negative representable value or zero for an unsigned integer
- type, if the field represents a value too large negative to be
- represented in `val`. `ios_base::failbit` is assigned to `err`.
 - the converted value, otherwise.
-The resultant numeric value is stored in `val`.
 Digit grouping is checked. That is, the positions of discarded
 separators is examined for consistency with
-`use_facet<numpunct<charT> >(loc).grouping()`. If they are not
-consistent then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
 ``` cpp
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
                  ios_base::iostate& err, bool& val) const;
 ```
-*Effects:* If `(str``.flags()&ios_base::boolalpha)==0` then input
 proceeds as it would for a `long` except that if a value is being stored
 into `val`, the value is determined according to the following: If the
-value to be stored is 0 then `false` is stored. If the value is 1 then
 `true` is stored. Otherwise `true` is stored and `ios_base::failbit` is
 assigned to `err`.
 Otherwise target sequences are determined “as if” by calling the members
 `falsename()` and `truename()` of the facet obtained by
-`use_facet<numpunct<charT> >(str.getloc())`. Successive characters in
-the range \[`in`, `end`) (see  [[sequence.reqmts]]) are obtained and
-matched against corresponding positions in the target sequences only as
 necessary to identify a unique match. The input iterator `in` is
 compared to `end` only when necessary to obtain a character. If a target
 sequence is uniquely matched, `val` is set to the corresponding value.
 Otherwise `false` is stored and `ios_base::failbit` is assigned to
 `err`.
@@ -279,15 +285,17 @@ Otherwise `false` is stored and `ios_base::failbit` is assigned to
 The `in` iterator is always left pointing one position beyond the last
 character successfully matched. If `val` is set, then `err` is set to
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
-for the failure was that `(in == end)`. For targets `true`: `"a"` and
-`false`: `"abb"`, the input sequence `"a"` yields `val == true` and
-`err == str.eofbit`; the input sequence `"abc"` yields
-`err = str.failbit`, with `in` ending at the `’c’` element. For targets
-`true`: `"1"` and `false`: `"0"`, the input sequence `"1"` yields
-`val == true` and `err == str.goodbit`. For empty targets `("")`, any
-input sequence yields `err == str.failbit`.
 *Returns:* `in`.

 ``` cpp
 namespace std {
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
+      using char_type = charT;
+      using iter_type = InputIterator;
       explicit num_get(size_t refs = 0);
       iter_type get(iter_type in, iter_type end, ios_base&,
                     ios_base::iostate& err, bool& v) const;
 | `double`             | `l`             |
 | `long double`        | `L`             |
 - **Stage 2:**
+If `in == end` then stage 2 terminates. Otherwise a `charT` is taken
+from `in` and local variables are initialized as if by
 ``` cpp
 char_type ct = *in;
 char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms];
 if (ct == use_facet<numpunct<charT>>(loc).decimal_point())
 use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms);
 ```
 for this value of `loc`.
+If `discard` is `true`, then if `’.’` has not yet been accumulated, then
 the position of the character is remembered, but the character is
 otherwise ignored. Otherwise, if `’.’` has already been accumulated, the
 character is discarded and Stage 2 terminates. If it is not discarded,
 then a check is made to determine if `c` is allowed as the next
 character of an input field of the conversion specifier returned by
 - For a signed integer value, the function `strtoll`.
 - For an unsigned integer value, the function `strtoull`.
+- For a `float` value, the function `strtof`.
+- For a `double` value, the function `strtod`.
+- For a `long double` value, the function `strtold`.
 The numeric value to be stored can be one of:
+- zero, if the conversion function does not convert the entire field.
+- the most positive (or negative) representable value, if the field to
+ be converted to a signed integer type represents a value too large
+ positive (or negative) to be represented in `val`.
+- the most positive representable value, if the field to be converted to
+ an unsigned integer type represents a value that cannot be represented
+  in `val`.
 - the converted value, otherwise.
+The resultant numeric value is stored in `val`. If the conversion
+function does not convert the entire field, or if the field represents a
+value outside the range of representable values, `ios_base::failbit` is
+assigned to `err`.
 Digit grouping is checked. That is, the positions of discarded
 separators is examined for consistency with
+`use_facet<numpunct<charT>>(loc).grouping()`. If they are not consistent
+then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
 ``` cpp
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
                  ios_base::iostate& err, bool& val) const;
 ```
+*Effects:* If `(str.flags()&ios_base::boolalpha) == 0` then input
 proceeds as it would for a `long` except that if a value is being stored
 into `val`, the value is determined according to the following: If the
+value to be stored is 0 then `false` is stored. If the value is `1` then
 `true` is stored. Otherwise `true` is stored and `ios_base::failbit` is
 assigned to `err`.
 Otherwise target sequences are determined “as if” by calling the members
 `falsename()` and `truename()` of the facet obtained by
+`use_facet<numpunct<charT>>(str.getloc())`. Successive characters in the
+range \[`in`, `end`) (see  [[sequence.reqmts]]) are obtained and matched
+against corresponding positions in the target sequences only as
 necessary to identify a unique match. The input iterator `in` is
 compared to `end` only when necessary to obtain a character. If a target
 sequence is uniquely matched, `val` is set to the corresponding value.
 Otherwise `false` is stored and `ios_base::failbit` is assigned to
 `err`.
 The `in` iterator is always left pointing one position beyond the last
 character successfully matched. If `val` is set, then `err` is set to
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
+for the failure was that `(in == end)`.
+[*Example 1*: For targets `true`: `"a"` and `false`: `"abb"`, the input
+sequence `"a"` yields `val == true` and `err == str.eofbit`; the input
+sequence `"abc"` yields `err = str.failbit`, with `in` ending at the
+`’c’` element. For targets `true`: `"1"` and `false`: `"0"`, the input
+sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
+targets `("")`, any input sequence yields
+`err == str.failbit`. — *end example*]
 *Returns:* `in`.

Diff to HTML by rtfpessoa