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

Files changed (1) hide show

tmp/tmpdq5nbbhc/{from.md → to.md} +14 -22

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

@@ -148,11 +148,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.
@@ -292,27 +292,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`,
@@ -479,25 +471,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
@@ -506,28 +498,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`).

 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`).

Diff to HTML by rtfpessoa