[iostreams.base] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpbkxjc13i/{from.md → to.md} +28 -30

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

@@ -4,15 +4,19 @@
 ``` cpp
 #include <iosfwd>   // see [iosfwd.syn]
 namespace std {
   using streamoff  = implementation-defined;
   using streamsize = implementation-defined;
   template<class stateT> class fpos;
   class ios_base;
   template<class charT, class traits = char_traits<charT>>
     class basic_ios;
   // [std.ios.manip], manipulators
   ios_base& boolalpha  (ios_base& str);
@@ -214,11 +218,11 @@ namespace std {
 An implementation is permitted to define `ios_base::failure` as a
 synonym for a class with equivalent functionality to class
 `ios_base::failure` shown in this subclause.
 [*Note 1*: When `ios_base::failure` is a synonym for another type, that
-type is required to provide a nested type `failure` to emulate the
 injected-class-name. — *end note*]
 The class `failure` defines the base class for the types of all objects
 thrown as exceptions, by functions in the iostreams library, to report
 errors detected during stream buffer operations.
@@ -358,27 +362,19 @@ namespace std {
   public:
     Init();
     Init(const Init&) = default;
     ~Init();
     Init& operator=(const Init&) = default;
-  private:
-    static int init_cnt;        // exposition only
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
 construction of the eight objects declared in `<iostream>`
 [[iostream.objects]] that associate file stream buffers with the
 standard C streams provided for by the functions declared in `<cstdio>`.
-For the sake of exposition, the maintained data is presented here as:
-- `static int init_cnt`, counts the number of constructor and destructor
-  calls for class `Init`, initialized to zero.
 ``` cpp
 Init();
 ```
 *Effects:* Constructs and initializes the objects `cin`, `cout`, `cerr`,
@@ -545,25 +541,25 @@ for any sequence of characters.[^5]
 ``` cpp
 static int xalloc();
 ```
-*Returns:* `index` `++`.
 *Remarks:* Concurrent access to this function by multiple threads does
 not result in a data race [[intro.multithread]].
 ``` cpp
 long& iword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `xalloc`.
-*Effects:* If `iarray` is a null pointer, allocates an array of `long`
 of unspecified size and stores a pointer to its first element in
-`iarray`. The function then extends the array pointed at by `iarray` as
-necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
 invalid after any other operation on the object.[^6]
 However, the value of the storage referred to is retained, so that until
 the next call to `copyfmt`, calling `iword` with the same index yields
@@ -572,28 +568,28 @@ another reference to the same value. If the function fails[^7]
 and `*this` is a base class subobject of a `basic_ios<>` object or
 subobject, the effect is equivalent to calling
 `basic_ios<>::setstate(badbit)` on the derived object (which may throw
 `failure`).
-*Returns:* On success `iarray[idx]`. On failure, a valid `long&`
 initialized to 0.
 ``` cpp
 void*& pword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `xalloc`.
-*Effects:* If `parray` is a null pointer, allocates an array of pointers
 to `void` of unspecified size and stores a pointer to its first element
-in `parray`. The function then extends the array pointed at by `parray`
-as necessary to include the element `parray[idx]`. Each newly allocated
-element of the array is initialized to a null pointer. The reference
-returned is invalid after any other operation on the object. However,
-the value of the storage referred to is retained, so that until the next
-call to `copyfmt`, calling `pword` with the same index yields another
-reference to the same value. If the function fails[^8]
 and `*this` is a base class subobject of a `basic_ios<>` object or
 subobject, the effect is equivalent to calling
 `basic_ios<>::setstate(badbit)` on the derived object (which may throw
 `failure`).
@@ -642,10 +638,12 @@ destroyed, whichever comes first; otherwise the behavior is undefined.
 that any `ios_base` member function called from within `fn` has
 well-defined results. Then, any memory obtained is deallocated.
 ### Class template `fpos` <a id="fpos">[[fpos]]</a>
 ``` cpp
 namespace std {
   template<class stateT> class fpos {
   public:
     // [fpos.members], members
@@ -662,17 +660,17 @@ namespace std {
 ``` cpp
 void state(stateT s);
 ```
-*Effects:* Assigns `s` to `st`.
 ``` cpp
 stateT state() const;
 ```
-*Returns:* Current value of `st`.
 #### Requirements <a id="fpos.operations">[[fpos.operations]]</a>
 An `fpos` type specifies file position information. It holds a state
 object whose type is equal to the template parameter `stateT`. Type
@@ -713,13 +711,13 @@ function is undefined.
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ios : public ios_base {
   public:
     using char_type   = charT;
-    using int_type    = typename traits::int_type;
-    using pos_type    = typename traits::pos_type;
-    using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [iostate.flags], flags functions
     explicit operator bool() const;
     bool operator!() const;
@@ -865,17 +863,17 @@ locale imbue(const locale& loc);
 ``` cpp
 char narrow(char_type c, char dfault) const;
 ```
-*Returns:* `use_facet<ctype<char_type>>(getloc()).narrow(c, dfault)`
 ``` cpp
 char_type widen(char c) const;
 ```
-*Returns:* `use_facet<ctype<char_type>>(getloc()).widen(c)`
 ``` cpp
 char_type fill() const;
 ```
@@ -1011,11 +1009,11 @@ void setstate(iostate state);
 ``` cpp
 bool good() const;
 ```
-*Returns:* `rdstate() == 0`
 ``` cpp
 bool eof() const;
 ```

 ``` cpp
 #include <iosfwd>   // see [iosfwd.syn]
 namespace std {
+  // [stream.types], types
   using streamoff  = implementation-defined;
   using streamsize = implementation-defined;
+  // [fpos], class template fpos
   template<class stateT> class fpos;
+  // [ios.base], class ios_base
   class ios_base;
+  // [ios], class template basic_ios
   template<class charT, class traits = char_traits<charT>>
     class basic_ios;
   // [std.ios.manip], manipulators
   ios_base& boolalpha  (ios_base& str);
 An implementation is permitted to define `ios_base::failure` as a
 synonym for a class with equivalent functionality to class
 `ios_base::failure` shown in this subclause.
 [*Note 1*: When `ios_base::failure` is a synonym for another type, that
+type needs to provide a nested type `failure` to emulate the
 injected-class-name. — *end note*]
 The class `failure` defines the base class for the types of all objects
 thrown as exceptions, by functions in the iostreams library, to report
 errors detected during stream buffer operations.
   public:
     Init();
     Init(const Init&) = default;
     ~Init();
     Init& operator=(const Init&) = default;
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
 construction of the eight objects declared in `<iostream>`
 [[iostream.objects]] that associate file stream buffers with the
 standard C streams provided for by the functions declared in `<cstdio>`.
 ``` cpp
 Init();
 ```
 *Effects:* Constructs and initializes the objects `cin`, `cout`, `cerr`,
 ``` cpp
 static int xalloc();
 ```
+*Returns:* *index* `++`.
 *Remarks:* Concurrent access to this function by multiple threads does
 not result in a data race [[intro.multithread]].
 ``` cpp
 long& iword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `xalloc`.
+*Effects:* If *iarray* is a null pointer, allocates an array of `long`
 of unspecified size and stores a pointer to its first element in
+*iarray*. The function then extends the array pointed at by *iarray* as
+necessary to include the element *`iarray`*`[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
 invalid after any other operation on the object.[^6]
 However, the value of the storage referred to is retained, so that until
 the next call to `copyfmt`, calling `iword` with the same index yields
 and `*this` is a base class subobject of a `basic_ios<>` object or
 subobject, the effect is equivalent to calling
 `basic_ios<>::setstate(badbit)` on the derived object (which may throw
 `failure`).
+*Returns:* On success *`iarray`*`[idx]`. On failure, a valid `long&`
 initialized to 0.
 ``` cpp
 void*& pword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `xalloc`.
+*Effects:* If *parray* is a null pointer, allocates an array of pointers
 to `void` of unspecified size and stores a pointer to its first element
+in *parray*. The function then extends the array pointed at by *parray*
+as necessary to include the element *`parray`*`[idx]`. Each newly
+allocated element of the array is initialized to a null pointer. The
+reference returned is invalid after any other operation on the object.
+However, the value of the storage referred to is retained, so that until
+the next call to `copyfmt`, calling `pword` with the same index yields
+another reference to the same value. If the function fails[^8]
 and `*this` is a base class subobject of a `basic_ios<>` object or
 subobject, the effect is equivalent to calling
 `basic_ios<>::setstate(badbit)` on the derived object (which may throw
 `failure`).
 that any `ios_base` member function called from within `fn` has
 well-defined results. Then, any memory obtained is deallocated.
 ### Class template `fpos` <a id="fpos">[[fpos]]</a>
+#### General <a id="fpos.general">[[fpos.general]]</a>
 ``` cpp
 namespace std {
   template<class stateT> class fpos {
   public:
     // [fpos.members], members
 ``` cpp
 void state(stateT s);
 ```
+*Effects:* Assigns `s` to *st*.
 ``` cpp
 stateT state() const;
 ```
+*Returns:* Current value of *st*.
 #### Requirements <a id="fpos.operations">[[fpos.operations]]</a>
 An `fpos` type specifies file position information. It holds a state
 object whose type is equal to the template parameter `stateT`. Type
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ios : public ios_base {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [iostate.flags], flags functions
     explicit operator bool() const;
     bool operator!() const;
 ``` cpp
 char narrow(char_type c, char dfault) const;
 ```
+*Returns:* `use_facet<ctype<char_type>>(getloc()).narrow(c, dfault)`.
 ``` cpp
 char_type widen(char c) const;
 ```
+*Returns:* `use_facet<ctype<char_type>>(getloc()).widen(c)`.
 ``` cpp
 char_type fill() const;
 ```
 ``` cpp
 bool good() const;
 ```
+*Returns:* `rdstate() == 0`.
 ``` cpp
 bool eof() const;
 ```

Diff to HTML by rtfpessoa