libstdc++-v3/include/std/ostream

   1 // Output streams -*- C++ -*-
   2
   3 // Copyright (C) 1997-2017 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file include/ostream
  26  *  This is a Standard C++ Library header.
  27  */
  28
  29 //
  30 // ISO C++ 14882: 27.6.2  Output streams
  31 //
  32
  33 #ifndef _GLIBCXX_OSTREAM
  34 #define _GLIBCXX_OSTREAM 1
  35
  36 #pragma GCC system_header
  37
  38 #include <ios>
  39 #include <bits/ostream_insert.h>
  40
  41 namespace std _GLIBCXX_VISIBILITY(default)
  42 {
  43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  44
  45   /**
  46    *  @brief  Template class basic_ostream.
  47    *  @ingroup io
  48    *
  49    *  @tparam _CharT  Type of character stream.
  50    *  @tparam _Traits  Traits for character type, defaults to
  51    *                   char_traits<_CharT>.
  52    *
  53    *  This is the base class for all output streams.  It provides text
  54    *  formatting of all builtin types, and communicates with any class
  55    *  derived from basic_streambuf to do the actual output.
  56   */
  57   template<typename _CharT, typename _Traits>
  58     class basic_ostream : virtual public basic_ios<_CharT, _Traits>
  59     {
  60     public:
  61       // Types (inherited from basic_ios):
  62       typedef _CharT                                    char_type;
  63       typedef typename _Traits::int_type                int_type;
  64       typedef typename _Traits::pos_type                pos_type;
  65       typedef typename _Traits::off_type                off_type;
  66       typedef _Traits                                   traits_type;
  67
  68       // Non-standard Types:
  69       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
  70       typedef basic_ios<_CharT, _Traits>                __ios_type;
  71       typedef basic_ostream<_CharT, _Traits>            __ostream_type;
  72       typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
  73                                                         __num_put_type;
  74       typedef ctype<_CharT>                             __ctype_type;
  75
  76       /**
  77        *  @brief  Base constructor.
  78        *
  79        *  This ctor is almost never called by the user directly, rather from
  80        *  derived classes' initialization lists, which pass a pointer to
  81        *  their own stream buffer.
  82       */
  83       explicit
  84       basic_ostream(__streambuf_type* __sb)
  85       { this->init(__sb); }
  86
  87       /**
  88        *  @brief  Base destructor.
  89        *
  90        *  This does very little apart from providing a virtual base dtor.
  91       */
  92       virtual
  93       ~basic_ostream() { }
  94
  95       /// Safe prefix/suffix operations.
  96       class sentry;
  97       friend class sentry;
  98
  99       //@{
 100       /**
 101        *  @brief  Interface for manipulators.
 102        *
 103        *  Manipulators such as @c std::endl and @c std::hex use these
 104        *  functions in constructs like "std::cout << std::endl".  For more
 105        *  information, see the iomanip header.
 106       */
 107       __ostream_type&
 108       operator<<(__ostream_type& (*__pf)(__ostream_type&))
 109       {
 110         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 111         // DR 60. What is a formatted input function?
 112         // The inserters for manipulators are *not* formatted output functions.
 113         return __pf(*this);
 114       }
 115
 116       __ostream_type&
 117       operator<<(__ios_type& (*__pf)(__ios_type&))
 118       {
 119         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 120         // DR 60. What is a formatted input function?
 121         // The inserters for manipulators are *not* formatted output functions.
 122         __pf(*this);
 123         return *this;
 124       }
 125
 126       __ostream_type&
 127       operator<<(ios_base& (*__pf) (ios_base&))
 128       {
 129         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 130         // DR 60. What is a formatted input function?
 131         // The inserters for manipulators are *not* formatted output functions.
 132         __pf(*this);
 133         return *this;
 134       }
 135       //@}
 136
 137       //@{
 138       /**
 139        *  @name Inserters
 140        *
 141        *  All the @c operator<< functions (aka <em>formatted output
 142        *  functions</em>) have some common behavior.  Each starts by
 143        *  constructing a temporary object of type std::basic_ostream::sentry.
 144        *  This can have several effects, concluding with the setting of a
 145        *  status flag; see the sentry documentation for more.
 146        *
 147        *  If the sentry status is good, the function tries to generate
 148        *  whatever data is appropriate for the type of the argument.
 149        *
 150        *  If an exception is thrown during insertion, ios_base::badbit
 151        *  will be turned on in the stream's error state without causing an
 152        *  ios_base::failure to be thrown.  The original exception will then
 153        *  be rethrown.
 154       */
 155
 156       //@{
 157       /**
 158        *  @brief Integer arithmetic inserters
 159        *  @param  __n A variable of builtin integral type.
 160        *  @return  @c *this if successful
 161        *
 162        *  These functions use the stream's current locale (specifically, the
 163        *  @c num_get facet) to perform numeric formatting.
 164       */
 165       __ostream_type&
 166       operator<<(long __n)
 167       { return _M_insert(__n); }
 168
 169       __ostream_type&
 170       operator<<(unsigned long __n)
 171       { return _M_insert(__n); }
 172
 173       __ostream_type&
 174       operator<<(bool __n)
 175       { return _M_insert(__n); }
 176
 177       __ostream_type&
 178       operator<<(short __n);
 179
 180       __ostream_type&
 181       operator<<(unsigned short __n)
 182       {
 183         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 184         // 117. basic_ostream uses nonexistent num_put member functions.
 185         return _M_insert(static_cast<unsigned long>(__n));
 186       }
 187
 188       __ostream_type&
 189       operator<<(int __n);
 190
 191       __ostream_type&
 192       operator<<(unsigned int __n)
 193       {
 194         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 195         // 117. basic_ostream uses nonexistent num_put member functions.
 196         return _M_insert(static_cast<unsigned long>(__n));
 197       }
 198
 199 #ifdef _GLIBCXX_USE_LONG_LONG
 200       __ostream_type&
 201       operator<<(long long __n)
 202       { return _M_insert(__n); }
 203
 204       __ostream_type&
 205       operator<<(unsigned long long __n)
 206       { return _M_insert(__n); }
 207 #endif
 208       //@}
 209
 210       //@{
 211       /**
 212        *  @brief  Floating point arithmetic inserters
 213        *  @param  __f A variable of builtin floating point type.
 214        *  @return  @c *this if successful
 215        *
 216        *  These functions use the stream's current locale (specifically, the
 217        *  @c num_get facet) to perform numeric formatting.
 218       */
 219       __ostream_type&
 220       operator<<(double __f)
 221       { return _M_insert(__f); }
 222
 223       __ostream_type&
 224       operator<<(float __f)
 225       {
 226         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 227         // 117. basic_ostream uses nonexistent num_put member functions.
 228         return _M_insert(static_cast<double>(__f));
 229       }
 230
 231       __ostream_type&
 232       operator<<(long double __f)
 233       { return _M_insert(__f); }
 234       //@}
 235
 236       /**
 237        *  @brief  Pointer arithmetic inserters
 238        *  @param  __p A variable of pointer type.
 239        *  @return  @c *this if successful
 240        *
 241        *  These functions use the stream's current locale (specifically, the
 242        *  @c num_get facet) to perform numeric formatting.
 243       */
 244       __ostream_type&
 245       operator<<(const void* __p)
 246       { return _M_insert(__p); }
 247
 248       /**
 249        *  @brief  Extracting from another streambuf.
 250        *  @param  __sb  A pointer to a streambuf
 251        *
 252        *  This function behaves like one of the basic arithmetic extractors,
 253        *  in that it also constructs a sentry object and has the same error
 254        *  handling behavior.
 255        *
 256        *  If @p __sb is NULL, the stream will set failbit in its error state.
 257        *
 258        *  Characters are extracted from @p __sb and inserted into @c *this
 259        *  until one of the following occurs:
 260        *
 261        *  - the input stream reaches end-of-file,
 262        *  - insertion into the output sequence fails (in this case, the
 263        *    character that would have been inserted is not extracted), or
 264        *  - an exception occurs while getting a character from @p __sb, which
 265        *    sets failbit in the error state
 266        *
 267        *  If the function inserts no characters, failbit is set.
 268       */
 269       __ostream_type&
 270       operator<<(__streambuf_type* __sb);
 271       //@}
 272
 273       //@{
 274       /**
 275        *  @name Unformatted Output Functions
 276        *
 277        *  All the unformatted output functions have some common behavior.
 278        *  Each starts by constructing a temporary object of type
 279        *  std::basic_ostream::sentry.  This has several effects, concluding
 280        *  with the setting of a status flag; see the sentry documentation
 281        *  for more.
 282        *
 283        *  If the sentry status is good, the function tries to generate
 284        *  whatever data is appropriate for the type of the argument.
 285        *
 286        *  If an exception is thrown during insertion, ios_base::badbit
 287        *  will be turned on in the stream's error state.  If badbit is on in
 288        *  the stream's exceptions mask, the exception will be rethrown
 289        *  without completing its actions.
 290       */
 291
 292       /**
 293        *  @brief  Simple insertion.
 294        *  @param  __c  The character to insert.
 295        *  @return  *this
 296        *
 297        *  Tries to insert @p __c.
 298        *
 299        *  @note  This function is not overloaded on signed char and
 300        *         unsigned char.
 301       */
 302       __ostream_type&
 303       put(char_type __c);
 304
 305       /**
 306        *  @brief  Core write functionality, without sentry.
 307        *  @param  __s  The array to insert.
 308        *  @param  __n  Maximum number of characters to insert.
 309       */
 310       void
 311       _M_write(const char_type* __s, streamsize __n)
 312       {
 313         const streamsize __put = this->rdbuf()->sputn(__s, __n);
 314         if (__put != __n)
 315           this->setstate(ios_base::badbit);
 316       }
 317
 318       /**
 319        *  @brief  Character string insertion.
 320        *  @param  __s  The array to insert.
 321        *  @param  __n  Maximum number of characters to insert.
 322        *  @return  *this
 323        *
 324        *  Characters are copied from @p __s and inserted into the stream until
 325        *  one of the following happens:
 326        *
 327        *  - @p __n characters are inserted
 328        *  - inserting into the output sequence fails (in this case, badbit
 329        *    will be set in the stream's error state)
 330        *
 331        *  @note  This function is not overloaded on signed char and
 332        *         unsigned char.
 333       */
 334       __ostream_type&
 335       write(const char_type* __s, streamsize __n);
 336       //@}
 337
 338       /**
 339        *  @brief  Synchronizing the stream buffer.
 340        *  @return  *this
 341        *
 342        *  If @c rdbuf() is a null pointer, changes nothing.
 343        *
 344        *  Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
 345        *  sets badbit.
 346       */
 347       __ostream_type&
 348       flush();
 349
 350       /**
 351        *  @brief  Getting the current write position.
 352        *  @return  A file position object.
 353        *
 354        *  If @c fail() is not false, returns @c pos_type(-1) to indicate
 355        *  failure.  Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
 356       */
 357       pos_type
 358       tellp();
 359
 360       /**
 361        *  @brief  Changing the current write position.
 362        *  @param  __pos  A file position object.
 363        *  @return  *this
 364        *
 365        *  If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos).  If
 366        *  that function fails, sets failbit.
 367       */
 368       __ostream_type&
 369       seekp(pos_type);
 370
 371       /**
 372        *  @brief  Changing the current write position.
 373        *  @param  __off  A file offset object.
 374        *  @param  __dir  The direction in which to seek.
 375        *  @return  *this
 376        *
 377        *  If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
 378        *  If that function fails, sets failbit.
 379       */
 380        __ostream_type&
 381       seekp(off_type, ios_base::seekdir);
 382
 383     protected:
 384       basic_ostream()
 385       { this->init(0); }
 386
 387 #if __cplusplus >= 201103L
 388       // Non-standard constructor that does not call init()
 389       basic_ostream(basic_iostream<_CharT, _Traits>&) { }
 390
 391       basic_ostream(const basic_ostream&) = delete;
 392
 393       basic_ostream(basic_ostream&& __rhs)
 394       : __ios_type()
 395       { __ios_type::move(__rhs); }
 396
 397       // 27.7.3.3 Assign/swap
 398
 399       basic_ostream& operator=(const basic_ostream&) = delete;
 400
 401       basic_ostream&
 402       operator=(basic_ostream&& __rhs)
 403       {
 404         swap(__rhs);
 405         return *this;
 406       }
 407
 408       void
 409       swap(basic_ostream& __rhs)
 410       { __ios_type::swap(__rhs); }
 411 #endif
 412
 413       template<typename _ValueT>
 414         __ostream_type&
 415         _M_insert(_ValueT __v);
 416     };
 417
 418   /**
 419    *  @brief  Performs setup work for output streams.
 420    *
 421    *  Objects of this class are created before all of the standard
 422    *  inserters are run.  It is responsible for <em>exception-safe prefix and
 423    *  suffix operations</em>.
 424   */
 425   template <typename _CharT, typename _Traits>
 426     class basic_ostream<_CharT, _Traits>::sentry
 427     {
 428       // Data Members.
 429       bool                              _M_ok;
 430       basic_ostream<_CharT, _Traits>&   _M_os;
 431
 432     public:
 433       /**
 434        *  @brief  The constructor performs preparatory work.
 435        *  @param  __os  The output stream to guard.
 436        *
 437        *  If the stream state is good (@a __os.good() is true), then if the
 438        *  stream is tied to another output stream, @c is.tie()->flush()
 439        *  is called to synchronize the output sequences.
 440        *
 441        *  If the stream state is still good, then the sentry state becomes
 442        *  true (@a okay).
 443       */
 444       explicit
 445       sentry(basic_ostream<_CharT, _Traits>& __os);
 446
 447       /**
 448        *  @brief  Possibly flushes the stream.
 449        *
 450        *  If @c ios_base::unitbuf is set in @c os.flags(), and
 451        *  @c std::uncaught_exception() is true, the sentry destructor calls
 452        *  @c flush() on the output stream.
 453       */
 454       ~sentry()
 455       {
 456         // XXX MT
 457         if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
 458           {
 459             // Can't call flush directly or else will get into recursive lock.
 460             if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
 461               _M_os.setstate(ios_base::badbit);
 462           }
 463       }
 464
 465       /**
 466        *  @brief  Quick status checking.
 467        *  @return  The sentry state.
 468        *
 469        *  For ease of use, sentries may be converted to booleans.  The
 470        *  return value is that of the sentry state (true == okay).
 471       */
 472 #if __cplusplus >= 201103L
 473       explicit
 474 #endif
 475       operator bool() const
 476       { return _M_ok; }
 477     };
 478
 479   //@{
 480   /**
 481    *  @brief  Character inserters
 482    *  @param  __out  An output stream.
 483    *  @param  __c  A character.
 484    *  @return  out
 485    *
 486    *  Behaves like one of the formatted arithmetic inserters described in
 487    *  std::basic_ostream.  After constructing a sentry object with good
 488    *  status, this function inserts a single character and any required
 489    *  padding (as determined by [22.2.2.2.2]).  @c __out.width(0) is then
 490    *  called.
 491    *
 492    *  If @p __c is of type @c char and the character type of the stream is not
 493    *  @c char, the character is widened before insertion.
 494   */
 495   template<typename _CharT, typename _Traits>
 496     inline basic_ostream<_CharT, _Traits>&
 497     operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
 498     { return __ostream_insert(__out, &__c, 1); }
 499
 500   template<typename _CharT, typename _Traits>
 501     inline basic_ostream<_CharT, _Traits>&
 502     operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
 503     { return (__out << __out.widen(__c)); }
 504
 505   // Specialization
 506   template <class _Traits>
 507     inline basic_ostream<char, _Traits>&
 508     operator<<(basic_ostream<char, _Traits>& __out, char __c)
 509     { return __ostream_insert(__out, &__c, 1); }
 510
 511   // Signed and unsigned
 512   template<class _Traits>
 513     inline basic_ostream<char, _Traits>&
 514     operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
 515     { return (__out << static_cast<char>(__c)); }
 516
 517   template<class _Traits>
 518     inline basic_ostream<char, _Traits>&
 519     operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
 520     { return (__out << static_cast<char>(__c)); }
 521   //@}
 522
 523   //@{
 524   /**
 525    *  @brief  String inserters
 526    *  @param  __out  An output stream.
 527    *  @param  __s  A character string.
 528    *  @return  out
 529    *  @pre  @p __s must be a non-NULL pointer
 530    *
 531    *  Behaves like one of the formatted arithmetic inserters described in
 532    *  std::basic_ostream.  After constructing a sentry object with good
 533    *  status, this function inserts @c traits::length(__s) characters starting
 534    *  at @p __s, widened if necessary, followed by any required padding (as
 535    *  determined by [22.2.2.2.2]).  @c __out.width(0) is then called.
 536   */
 537   template<typename _CharT, typename _Traits>
 538     inline basic_ostream<_CharT, _Traits>&
 539     operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
 540     {
 541       if (!__s)
 542         __out.setstate(ios_base::badbit);
 543       else
 544         __ostream_insert(__out, __s,
 545                          static_cast<streamsize>(_Traits::length(__s)));
 546       return __out;
 547     }
 548
 549   template<typename _CharT, typename _Traits>
 550     basic_ostream<_CharT, _Traits> &
 551     operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
 552
 553   // Partial specializations
 554   template<class _Traits>
 555     inline basic_ostream<char, _Traits>&
 556     operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
 557     {
 558       if (!__s)
 559         __out.setstate(ios_base::badbit);
 560       else
 561         __ostream_insert(__out, __s,
 562                          static_cast<streamsize>(_Traits::length(__s)));
 563       return __out;
 564     }
 565
 566   // Signed and unsigned
 567   template<class _Traits>
 568     inline basic_ostream<char, _Traits>&
 569     operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
 570     { return (__out << reinterpret_cast<const char*>(__s)); }
 571
 572   template<class _Traits>
 573     inline basic_ostream<char, _Traits> &
 574     operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
 575     { return (__out << reinterpret_cast<const char*>(__s)); }
 576   //@}
 577
 578   // Standard basic_ostream manipulators
 579
 580   /**
 581    *  @brief  Write a newline and flush the stream.
 582    *
 583    *  This manipulator is often mistakenly used when a simple newline is
 584    *  desired, leading to poor buffering performance.  See
 585    *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
 586    *  for more on this subject.
 587   */
 588   template<typename _CharT, typename _Traits>
 589     inline basic_ostream<_CharT, _Traits>&
 590     endl(basic_ostream<_CharT, _Traits>& __os)
 591     { return flush(__os.put(__os.widen('\n'))); }
 592
 593   /**
 594    *  @brief  Write a null character into the output sequence.
 595    *
 596    *  <em>Null character</em> is @c CharT() by definition.  For CharT
 597    *  of @c char, this correctly writes the ASCII @c NUL character
 598    *  string terminator.
 599   */
 600   template<typename _CharT, typename _Traits>
 601     inline basic_ostream<_CharT, _Traits>&
 602     ends(basic_ostream<_CharT, _Traits>& __os)
 603     { return __os.put(_CharT()); }
 604
 605   /**
 606    *  @brief  Flushes the output stream.
 607    *
 608    *  This manipulator simply calls the stream's @c flush() member function.
 609   */
 610   template<typename _CharT, typename _Traits>
 611     inline basic_ostream<_CharT, _Traits>&
 612     flush(basic_ostream<_CharT, _Traits>& __os)
 613     { return __os.flush(); }
 614
 615 #if __cplusplus >= 201103L
 616   template<typename _Ch, typename _Up>
 617     basic_ostream<_Ch, _Up>&
 618     __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);
 619
 620   template<typename _Tp, typename = void>
 621     struct __is_convertible_to_basic_ostream_impl
 622     {
 623       using __ostream_type = void;
 624     };
 625
 626   template<typename _Tp>
 627     using __do_is_convertible_to_basic_ostream_impl =
 628     decltype(__is_convertible_to_basic_ostream_test
 629              (declval<typename remove_reference<_Tp>::type*>()));
 630
 631   template<typename _Tp>
 632     struct __is_convertible_to_basic_ostream_impl
 633     <_Tp,
 634      __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
 635     {
 636       using __ostream_type =
 637         __do_is_convertible_to_basic_ostream_impl<_Tp>;
 638     };
 639
 640   template<typename _Tp>
 641     struct __is_convertible_to_basic_ostream
 642     : __is_convertible_to_basic_ostream_impl<_Tp>
 643     {
 644     public:
 645       using type = __not_<is_void<
 646         typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
 647       constexpr static bool value = type::value;
 648     };
 649
 650   template<typename _Ostream, typename _Tp, typename = void>
 651     struct __is_insertable : false_type {};
 652
 653   template<typename _Ostream, typename _Tp>
 654     struct __is_insertable<_Ostream, _Tp,
 655                            __void_t<decltype(declval<_Ostream&>()
 656                                              << declval<const _Tp&>())>>
 657                                     : true_type {};
 658
 659   template<typename _Ostream>
 660     using __rvalue_ostream_type =
 661       typename __is_convertible_to_basic_ostream<
 662         _Ostream>::__ostream_type;
 663
 664   /**
 665    *  @brief  Generic inserter for rvalue stream
 666    *  @param  __os  An input stream.
 667    *  @param  __x  A reference to the object being inserted.
 668    *  @return  os
 669    *
 670    *  This is just a forwarding function to allow insertion to
 671    *  rvalue streams since they won't bind to the inserter functions
 672    *  that take an lvalue reference.
 673   */
 674   template<typename _Ostream, typename _Tp>
 675     inline
 676     typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
 677                               __is_convertible_to_basic_ostream<_Ostream>,
 678                               __is_insertable<
 679                                 __rvalue_ostream_type<_Ostream>,
 680                                 const _Tp&>>::value,
 681                        __rvalue_ostream_type<_Ostream>>::type
 682     operator<<(_Ostream&& __os, const _Tp& __x)
 683     {
 684       __rvalue_ostream_type<_Ostream> __ret_os = __os;
 685       __ret_os << __x;
 686       return __ret_os;
 687     }
 688 #endif // C++11
 689
 690 _GLIBCXX_END_NAMESPACE_VERSION
 691 } // namespace std
 692
 693 #include <bits/ostream.tcc>
 694
 695 #endif  /* _GLIBCXX_OSTREAM */