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

Files changed (1) hide show

tmp/tmp9uwic4ig/{from.md → to.md} +139 -54

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

@@ -9,22 +9,22 @@ that inserts into stream rvalues.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from basic_ios ([ios])):
     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;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
-    // [ostream::sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
@@ -61,15 +61,15 @@ namespace std {
     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& rhs) = delete;
     basic_ostream(basic_ostream&& rhs);
     // [ostream.assign], assign and swap
-    basic_ostream& operator=(const basic_ostream& rhs) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
   // [ostream.inserters.character], character inserters
@@ -83,10 +83,28 @@ namespace std {
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, signed char);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, unsigned char);
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const charT*);
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const char*);
   template<class traits>
@@ -94,10 +112,32 @@ namespace std {
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const signed char*);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const unsigned char*);
 }
 ```
 The class template `basic_ostream` defines a number of member function
 signatures that assist in formatting and writing output to output
@@ -110,26 +150,29 @@ output functions.* Both groups of output functions generate (or
 `rdbuf()->sputc(int_type)`. They may use other public members of
 `basic_ostream` except that they shall not invoke any virtual members of
 `rdbuf()` except `overflow()`, `xsputn()`, and `sync()`.
 If one of these called functions throws an exception, then unless
-explicitly noted otherwise the output function sets `badbit` in error
-state. If `badbit` is on in `exceptions()`, the output function rethrows
-the exception without completing its actions, otherwise it does not
-throw anything and treat as an error.
-##### `basic_ostream` constructors <a id="ostream.cons">[[ostream.cons]]</a>
 ``` cpp
 explicit basic_ostream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_ostream`, initializing
-the base class subobject with
-`basic_ios<charT, traits>::init(sb)` ([[basic.ios.cons]]).
-*Postconditions:* `rdbuf() == sb`.
 ``` cpp
 basic_ostream(basic_ostream&& rhs);
 ```
@@ -139,31 +182,29 @@ by default constructing the base class and calling
 ``` cpp
 virtual ~basic_ostream();
 ```
-*Effects:* Destroys an object of class `basic_ostream`.
 *Remarks:* Does not perform any operations on `rdbuf()`.
-##### Class `basic_ostream` assign and swap <a id="ostream.assign">[[ostream.assign]]</a>
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
-*Effects:* As if by `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(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 {
@@ -190,11 +231,11 @@ 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();
 ```
@@ -207,11 +248,11 @@ sets `badbit` in `os.rdstate()` without propagating an exception.
 explicit operator bool() const;
 ```
 *Effects:* Returns `ok_`.
-##### `basic_ostream` seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
 ``` cpp
@@ -250,12 +291,12 @@ function calls `setstate(failbit)` (which may throw
 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::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`.
@@ -396,13 +437,13 @@ in  [[ostream.formatted.reqmts]]).
 ``` 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:
@@ -410,14 +451,14 @@ read from `sb` and inserted until any of the following occurs:
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs while getting a character from `sb`.
 If the function inserts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])). If an
-exception was thrown while extracting a character, the function sets
-`failbit` in error state, and if `failbit` is on in `exceptions()` the
-caught exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
 basic_ostream<charT, traits>& operator<<(nullptr_t);
@@ -427,11 +468,11 @@ basic_ostream<charT, traits>& operator<<(nullptr_t);
 ``` cpp
 return *this << s;
 ```
-where `s` is an *implementation-defined* NTCTS ([[defns.ntcts]]).
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
@@ -447,16 +488,16 @@ template<class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);
 ```
 *Effects:* Behaves as a formatted output
-function ([[ostream.formatted.reqmts]]) of `out`. Constructs a
-character sequence `seq`. If `c` has type `char` and the character type
-of the stream is not `char`, then `seq` consists of `out.widen(c)`;
-otherwise `seq` consists of `c`. Determines padding for `seq` as
-described in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`.
-Calls `os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
@@ -470,17 +511,17 @@ template<class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out,
                                           const unsigned char* s);
 ```
-*Requires:* `s` shall not be a null pointer.
 *Effects:* Behaves like a formatted inserter (as described
 in  [[ostream.formatted.reqmts]]) of `out`. Creates a character sequence
 `seq` of `n` characters starting at `s`, each widened using
-`out.widen()` ([[basic.ios.members]]), where `n` is the number that
-would be computed as if by:
 - `traits::length(s)` for the overload where the first argument is of
   type `basic_ostream<charT, traits>&` and the second is of type
   `const charT*`, and also for the overload where the first argument is
   of type `basic_ostream<char, traits>&` and the second is of type
@@ -501,11 +542,11 @@ in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 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::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.
@@ -515,12 +556,12 @@ 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`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
@@ -532,12 +573,12 @@ 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]])).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& flush();
@@ -545,17 +586,20 @@ 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 `basic_ostream` manipulators <a id="ostream.manip">[[ostream.manip]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
 ```
@@ -581,19 +625,60 @@ template <class charT, class traits>
 *Effects:* Calls `os.flush()`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
 ``` cpp
-template <class charT, class traits, class T>
- basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
 ```
 *Effects:* As if by: `os << x;`
-*Returns:* `os`.
-*Remarks:* This function shall not participate in overload resolution
-unless the expression `os << x` is well-formed.

 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
+    // types (inherited from basic_ios[ios])
     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;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
+    // [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>& 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);
   };
   // [ostream.inserters.character], character inserters
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, signed char);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, unsigned char);
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, wchar_t) = delete;
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char8_t) = delete;
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char16_t) = delete;
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char32_t) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, char8_t) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, char16_t) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete;
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const charT*);
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const char*);
   template<class traits>
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const signed char*);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const unsigned char*);
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete;
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const char8_t*) = delete;
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const char16_t*) = delete;
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const char32_t*) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete;
 }
 ```
 The class template `basic_ostream` defines a number of member function
 signatures that assist in formatting and writing output to output
 `rdbuf()->sputc(int_type)`. They may use other public members of
 `basic_ostream` except that they shall not invoke any virtual members of
 `rdbuf()` except `overflow()`, `xsputn()`, and `sync()`.
 If one of these called functions throws an exception, then unless
+explicitly noted otherwise the output function sets `badbit` in the
+error state. If `badbit` is set in `exceptions()`, the output function
+rethrows the exception without completing its actions, otherwise it does
+not throw anything and proceeds as if the called function had returned a
+failure indication.
+[*Note 1*: The deleted overloads of `operator<<` prevent formatting
+characters as integers and strings as pointers. — *end note*]
+##### Constructors <a id="ostream.cons">[[ostream.cons]]</a>
 ``` cpp
 explicit basic_ostream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Initializes the base class subobject with
+`basic_ios<charT, traits>::init(sb)` [[basic.ios.cons]].
+*Ensures:* `rdbuf() == sb`.
 ``` cpp
 basic_ostream(basic_ostream&& rhs);
 ```
 ``` cpp
 virtual ~basic_ostream();
 ```
 *Remarks:* Does not perform any operations on `rdbuf()`.
+##### Assignment and swap <a id="ostream.assign">[[ostream.assign]]</a>
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
+*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(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 {
 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();
 ```
 explicit operator bool() const;
 ```
 *Effects:* Returns `ok_`.
+##### Seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
 ``` cpp
 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`.
 ``` 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:
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs while getting a character from `sb`.
 If the function inserts no characters, it calls `setstate(failbit)`
+(which may throw `ios_base::failure` [[iostate.flags]]). If an exception
+was thrown while extracting a character, the function sets `failbit` in
+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);
 ``` cpp
 return *this << s;
 ```
+where `s` is an *implementation-defined* NTCTS [[defns.ntcts]].
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);
 ```
 *Effects:* Behaves as a formatted output
+function [[ostream.formatted.reqmts]] of `out`. Constructs a character
+sequence `seq`. If `c` has type `char` and the character type of the
+stream is not `char`, then `seq` consists of `out.widen(c)`; otherwise
+`seq` consists of `c`. Determines padding for `seq` as described
+in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
+`os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out,
                                           const unsigned char* s);
 ```
+*Preconditions:* `s` is not a null pointer.
 *Effects:* Behaves like a formatted inserter (as described
 in  [[ostream.formatted.reqmts]]) of `out`. Creates a character sequence
 `seq` of `n` characters starting at `s`, each widened using
+`out.widen()` [[basic.ios.members]], where `n` is the number that would
+be computed as if by:
 - `traits::length(s)` for the overload where the first argument is of
   type `basic_ostream<charT, traits>&` and the second is of type
   `const charT*`, and also for the overload where the first argument is
   of type `basic_ostream<char, traits>&` and the second is of type
 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.
 *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`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 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]]).
 *Returns:* `*this`.
 ``` 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>
+Each instantiation of any of the function templates specified in this
+subclause is a designated addressable function [[namespace.std]].
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`.
 *Returns:* `os`.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>& emit_on_flush(basic_ostream<charT, traits>& os);
+```
+*Effects:* If `os.rdbuf()` is a
+`basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, calls `buf->set_emit_on_sync(true)`. Otherwise this
+manipulator has no effect.
+[*Note 1*: To work around the issue that the `Allocator` template
+argument cannot be deduced, implementations can introduce an
+intermediate base class to `basic_syncbuf` that manages its
+`emit_on_sync` flag. — *end note*]
+*Returns:* `os`.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
+```
+*Effects:* If `os.rdbuf()` is a
+`basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, calls `buf->set_emit_on_sync(false)`. Otherwise this
+manipulator has no effect.
+*Returns:* `os`.
+``` cpp
+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>
 ``` cpp
+template<class Ostream, class T>
+ Ostream&& operator<<(Ostream&& os, const T& x);
 ```
+*Constraints:* The expression `os << x` is well-formed when treated as
+an unevaluated operand and `Ostream` is publicly and unambiguously
+derived from `ios_base`.
 *Effects:* As if by: `os << x;`
+*Returns:* `std::move(os)`.

Diff to HTML by rtfpessoa