[output.streams] - C++20 → C++23

Files changed (1) hide show

tmp/tmpqjo2jslz/{from.md → to.md} +210 -86

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

@@ -1,13 +1,21 @@
 ### Output streams <a id="output.streams">[[output.streams]]</a>
-The header `<ostream>` defines a type and several function signatures
-that control output to a stream buffer along with a function template
-that inserts into stream rvalues.
 #### Class template `basic_ostream` <a id="ostream">[[ostream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
@@ -24,51 +32,50 @@ namespace std {
     // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
-    basic_ostream<charT, traits>&
- operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
-    basic_ostream<charT, traits>&
-      operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
-    basic_ostream<charT, traits>&
-      operator<<(ios_base& (*pf)(ios_base&));
-    basic_ostream<charT, traits>& operator<<(bool n);
-    basic_ostream<charT, traits>& operator<<(short n);
-    basic_ostream<charT, traits>& operator<<(unsigned short n);
-    basic_ostream<charT, traits>& operator<<(int n);
-    basic_ostream<charT, traits>& operator<<(unsigned int n);
-    basic_ostream<charT, traits>& operator<<(long n);
-    basic_ostream<charT, traits>& operator<<(unsigned long n);
-    basic_ostream<charT, traits>& operator<<(long long n);
-    basic_ostream<charT, traits>& operator<<(unsigned long long n);
-    basic_ostream<charT, traits>& operator<<(float f);
-    basic_ostream<charT, traits>& operator<<(double f);
-    basic_ostream<charT, traits>& operator<<(long double f);
-    basic_ostream<charT, traits>& operator<<(const void* p);
-    basic_ostream<charT, traits>& operator<<(nullptr_t);
-    basic_ostream<charT, traits>& operator<<(basic_streambuf<char_type, traits>* sb);
     // [ostream.unformatted], unformatted output
-    basic_ostream<charT, traits>& put(char_type c);
-    basic_ostream<charT, traits>& write(const char_type* s, streamsize n);
-    basic_ostream<charT, traits>& flush();
     // [ostream.seeks], seeks
     pos_type tellp();
-    basic_ostream<charT, traits>& seekp(pos_type);
-    basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
     basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
-    // [ostream.assign], assign and swap
     basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
@@ -204,15 +211,16 @@ void swap(basic_ostream& rhs);
 ##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>>
   class basic_ostream<charT, traits>::sentry {
     bool ok_;       // exposition only
   public:
-    explicit sentry(basic_ostream<charT, traits>& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
@@ -222,20 +230,20 @@ namespace std {
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
-explicit sentry(basic_ostream<charT, traits>& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
-If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^31]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` [[iostate.flags]]).[^32]
 ``` cpp
 ~sentry();
 ```
@@ -261,22 +269,22 @@ pos_type tellp();
 *Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
 failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
-basic_ostream<charT, traits>& seekp(pos_type pos);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
@@ -287,20 +295,22 @@ function calls `setstate(failbit)` (which may throw
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 ##### Common requirements <a id="ostream.formatted.reqmts">[[ostream.formatted.reqmts]]</a>
 Each formatted output function begins execution by constructing an
-object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
-function does `setstate(ios_base::failbit)`, which might throw an
 exception. If an exception is thrown during output, then
-`ios_base::badbit` is turned on[^33] in `*this`’s error state. If
-`(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
-not an exception is thrown, the `sentry` object is destroyed before
-leaving the formatted output function. If no exception is thrown, the
-result of the formatted output function is `*this`.
 The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
 If a formatted output function of a stream `os` determines padding, it
@@ -313,23 +323,23 @@ the fill characters are placed after the character sequence; otherwise,
 they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
-operator<<(bool val);
-operator<<(short val);
-operator<<(unsigned short val);
-operator<<(int val);
-operator<<(unsigned int val);
-operator<<(long val);
-operator<<(unsigned long val);
-operator<<(long long val);
-operator<<(unsigned long long val);
-operator<<(float val);
-operator<<(double val);
-operator<<(long double val);
-operator<<(const void* val);
 ```
 *Effects:* The classes `num_get<>` and `num_put<>` handle
 locale-dependent numeric formatting and parsing. These inserter
 functions use the imbued `locale` value to perform numeric formatting.
@@ -400,49 +410,90 @@ It provides formatting specifications such as field width, and a locale
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
-basic_ostream<charT, traits>&
-  operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^34]
 ``` cpp
-basic_ostream<charT, traits>&
-  operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
-*Returns:* `*this`.[^35]
 ``` cpp
-basic_ostream<charT, traits>& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& operator<<(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted output
-function [[ostream.unformatted]]. After the sentry object is
 constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
@@ -459,11 +510,11 @@ the error state, and if `failbit` is set in `exceptions()` the caught
 exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& operator<<(nullptr_t);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -536,29 +587,98 @@ Determines padding for `seq` as described
 in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 `width(0)`.
 *Returns:* `out`.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
-object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
-`ios_base::badbit` is turned on[^36] in `*this`’s error state. If
-`(exceptions() & badbit) != 0` then the exception is rethrown. In any
-case, the unformatted output function ends by destroying the sentry
-object, then, if no exception was thrown, returning the value specified
-for the unformatted output function.
 ``` cpp
-basic_ostream<charT, traits>& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). After constructing a sentry object, inserts the character `c`,
-if possible.[^37]
 Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 [[iostate.flags]]).
 *Returns:* `*this`.
@@ -566,14 +686,15 @@ Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). After constructing a sentry object, obtains characters to insert
-from successive locations of an array whose first element is designated
-by `s`.[^38] Characters are inserted until either of the following
-occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]).
@@ -583,15 +704,15 @@ occurs:
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). If `rdbuf()` is not a null pointer, constructs a sentry object.
-If this object returns `true` when converted to a value of type `bool`
-the function calls `rdbuf()->pubsync()`. If that function returns -1
-calls `setstate(badbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]). Otherwise, if the sentry object returns `false`,
 does nothing.
 *Returns:* `*this`.
 #### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
@@ -661,11 +782,14 @@ template<class charT, class traits>
   basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
 `basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
-of exposition, calls `buf->emit()`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>

 ### Output streams <a id="output.streams">[[output.streams]]</a>
+#### General <a id="output.streams.general">[[output.streams.general]]</a>
+The header `<ostream>` defines a class template and several function
+templates that control output to a stream buffer, along with a function
+template that inserts into stream rvalues.
 #### Class template `basic_ostream` <a id="ostream">[[ostream]]</a>
+##### General <a id="ostream.general">[[ostream.general]]</a>
+When a function has a parameter type `extended-floating-point-type`, the
+implementation provides overloads for all cv-unqualified extended
+floating-point types [[basic.fundamental]].
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
+    basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
+    basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
+    basic_ostream& operator<<(bool n);
+    basic_ostream& operator<<(short n);
+    basic_ostream& operator<<(unsigned short n);
+    basic_ostream& operator<<(int n);
+    basic_ostream& operator<<(unsigned int n);
+    basic_ostream& operator<<(long n);
+    basic_ostream& operator<<(unsigned long n);
+    basic_ostream& operator<<(long long n);
+    basic_ostream& operator<<(unsigned long long n);
+    basic_ostream& operator<<(float f);
+    basic_ostream& operator<<(double f);
+    basic_ostream& operator<<(long double f);
+    basic_ostream& operator<<(extended-floating-point-type f);
+    basic_ostream& operator<<(const void* p);
+    basic_ostream& operator<<(const volatile void* p);
+    basic_ostream& operator<<(nullptr_t);
+    basic_ostream& operator<<(basic_streambuf<char_type, traits>* sb);
     // [ostream.unformatted], unformatted output
+    basic_ostream& put(char_type c);
+    basic_ostream& write(const char_type* s, streamsize n);
+    basic_ostream& flush();
     // [ostream.seeks], seeks
     pos_type tellp();
+    basic_ostream& seekp(pos_type);
+    basic_ostream& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
     basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
+    // [ostream.assign], assignment and swap
     basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
 ##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits>
   class basic_ostream<charT, traits>::sentry {
     bool ok_;       // exposition only
   public:
+    explicit sentry(basic_ostream& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
+explicit sentry(basic_ostream& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
+If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^29]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).[^30]
 ``` cpp
 ~sentry();
 ```
 *Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
 failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
+basic_ostream& seekp(pos_type pos);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 ##### Common requirements <a id="ostream.formatted.reqmts">[[ostream.formatted.reqmts]]</a>
 Each formatted output function begins execution by constructing an
+object of class `sentry`. If that object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
+function does `setstate(ios_base::failbit)`, which can throw an
 exception. If an exception is thrown during output, then
+`ios_base::badbit` is set[^31]
+in `*this`’s error state. If `(exceptions()&badbit) != 0` then the
+exception is rethrown. Whether or not an exception is thrown, the
+`sentry` object is destroyed before leaving the formatted output
+function. If no exception is thrown, the result of the formatted output
+function is `*this`.
 The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
 If a formatted output function of a stream `os` determines padding, it
 they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
+basic_ostream& operator<<(bool val);
+basic_ostream& operator<<(short val);
+basic_ostream& operator<<(unsigned short val);
+basic_ostream& operator<<(int val);
+basic_ostream& operator<<(unsigned int val);
+basic_ostream& operator<<(long val);
+basic_ostream& operator<<(unsigned long val);
+basic_ostream& operator<<(long long val);
+basic_ostream& operator<<(unsigned long long val);
+basic_ostream& operator<<(float val);
+basic_ostream& operator<<(double val);
+basic_ostream& operator<<(long double val);
+basic_ostream& operator<<(const void* val);
 ```
 *Effects:* The classes `num_get<>` and `num_put<>` handle
 locale-dependent numeric formatting and parsing. These inserter
 functions use the imbued `locale` value to perform numeric formatting.
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
+``` cpp
+basic_ostream& operator<<(const volatile void* p);
+```
+*Effects:* Equivalent to:
+`return operator<<(const_cast<const void*>(p));`
+``` cpp
+basic_ostream& operator<<(extended-floating-point-type val);
+```
+*Effects:* If the floating-point conversion rank of
+*`extended-floating-point-type`* is less than or equal to that of
+`double`, the formatting conversion occurs as if it performed the
+following code fragment:
+``` cpp
+bool failed = use_facet<
+  num_put<charT, ostreambuf_iterator<charT, traits>>
+    >(getloc()).put(*this, *this, fill(),
+      static_cast<double>(val)).failed();
+```
+Otherwise, if the floating-point conversion rank of
+*`extended-floating-point-type`* is less than or equal to that of
+`long double`, the formatting conversion occurs as if it performed the
+following code fragment:
+``` cpp
+bool failed = use_facet<
+  num_put<charT, ostreambuf_iterator<charT, traits>>
+    >(getloc()).put(*this, *this, fill(),
+      static_cast<long double>(val)).failed();
+```
+Otherwise, an invocation of the operator function is conditionally
+supported with *implementation-defined* semantics.
+If `failed` is `true` then does `setstate(badbit)`, which may throw an
+exception, and returns.
+*Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
+basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
+*Returns:* `pf(*this)`.[^32]
 ``` cpp
+basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
+*Returns:* `*this`.[^33]
 ``` cpp
+basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& operator<<(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted output
+function [[ostream.unformatted]]. After the `sentry` object is
 constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
 exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& operator<<(nullptr_t);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 `width(0)`.
 *Returns:* `out`.
+##### Print <a id="ostream.formatted.print">[[ostream.formatted.print]]</a>
+``` cpp
+template<class... Args>
+  void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
+equivalent to:
+``` cpp
+vprint_unicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+Otherwise, equivalent to:
+``` cpp
+vprint_nonunicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+``` cpp
+template<class... Args>
+  void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(os, "{}\n", format(fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void vprint_unicode(ostream& os, string_view fmt, format_args args);
+void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
+```
+*Effects:* Behaves as a formatted output
+function [[ostream.formatted.reqmts]] of `os`, except that:
+- failure to generate output is reported as specified below, and
+- any exception thrown by the call to `vformat` is propagated without
+  regard to the value of `os.exceptions()` and without turning on
+  `ios_base::badbit` in the error state of `os`.
+After constructing a `sentry` object, the function initializes an
+automatic variable via
+``` cpp
+string out = vformat(os.getloc(), fmt, args);
+```
+If the function is `vprint_unicode` and `os` is a stream that refers to
+a terminal capable of displaying Unicode which is determined in an
+implementation-defined manner, writes `out` to the terminal using the
+native Unicode API; if `out` contains invalid code units, the behavior
+is undefined and implementations are encouraged to diagnose it. If the
+native Unicode API is used, the function flushes `os` before writing
+`out`. Otherwise (if `os` is not such a stream or the function is
+`vprint_nonunicode`), inserts the character sequence \[`out.begin()`,
+`out.end()`) into `os`. If writing to the terminal or inserting into
+`os` fails, calls `os.setstate(ios_base::badbit)` (which may throw
+`ios_base::failure`).
+*Recommended practice:* For `vprint_unicode`, if invoking the native
+Unicode API requires transcoding, implementations should substitute
+invalid code units with U+fffd (replacement character) per the Unicode
+Standard, Chapter 3.9 ‘U+fffd‘ Substitution in Conversion.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
+object of class `sentry`. If that object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
+`ios_base::badbit` is set[^34]
+in `*this`’s error state. If `(exceptions() & badbit) != 0` then the
+exception is rethrown. In any case, the unformatted output function ends
+by destroying the `sentry` object, then, if no exception was thrown,
+returning the value specified for the unformatted output function.
 ``` cpp
+basic_ostream& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a `sentry` object, inserts the character `c`,
+if possible.[^35]
 Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 [[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a `sentry` object, obtains characters to
+insert from successive locations of an array whose first element is
+designated by `s`.[^36]
+Characters are inserted until either of the following occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]).
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). If `rdbuf()` is not a null pointer, constructs a `sentry`
+object. If that object returns `true` when converted to a value of type
+`bool` the function calls `rdbuf()->pubsync()`. If that function returns
+-1 calls `setstate(badbit)` (which may throw `ios_base::failure`
+[[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
 #### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
   basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
 `basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, behaves as an unformatted output
+function [[ostream.unformatted]] of `os`. After constructing a `sentry`
+object, calls `buf->emit()`. If that call returns `false`, calls
+`os.setstate(ios_base::badbit)`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>

Diff to HTML by rtfpessoa