# Standard library header <syncstream>

From cppreference.com
< cpp‎ | header

This header is part of the Input/Output library.

### Includes
`<ostream>`
### Classes
basic_syncbuf (C++20) | synchronized output device wrapper (class template)
basic_osyncstream (C++20) | synchronized output stream wrapper (class template)
### Typedefs
`syncbuf` | basic_syncbuf<char>
`wsyncbuf` | basic_syncbuf<wchar_t>
`osyncstream` | basic_osyncstream<char>
`wosyncstream` | basic_osyncstream<wchar_t>
### Functions
std::swap(std::basic_syncbuf) (C++20) | specializes the std::swap algorithm (function template)

### Synopsis

    namespace std {
    template <class CharT,
              class Traits = char_traits<CharT>,
              class Allocator = allocator<CharT>>
      class basic_syncbuf;

    using syncbuf  = basic_syncbuf<char>;
    using wsyncbuf = basic_syncbuf<wchar_t>;

    template <class CharT,
              class Traits = char_traits<CharT>,
              class Allocator = allocator<CharT>>
      class basic_osyncstream;

    using osyncstream  = basic_osyncstream<char>;
    using wosyncstream = basic_osyncstream<wchar_t>;

    template <class CharT, class Traits, class Allocator>
      void swap( std::basic_syncbuf<CharT, Traits, Allocator>& lhs,
                 std::basic_syncbuf<CharT, Traits, Allocator>& rhs );

    }

#### Class std::basic_syncbuf

    template <class CharT,
              class Traits = char_traits<CharT>,
              class Allocator = allocator<CharT>>
    class basic_syncbuf
      : public basic_streambuf<CharT, Traits> {

    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;
      using allocator_type = Allocator;

      using streambuf_type = basic_streambuf<CharT, Traits>;

      // Constructors/destructor:
      explicit
      basic_syncbuf(streambuf_type* obuf = nullptr)
        : basic_syncbuf(obuf, Allocator()) {}
      basic_syncbuf(streambuf_type* ,
                    const Allocator&);
      basic_syncbuf(basic_syncbuf&&);
      ~basic_syncbuf();

      // Assign/swap:
      basic_syncbuf& operator=(basic_syncbuf&&);
      void swap(basic_syncbuf &);

      // Members:
      bool emit();
      streambuf_type* get_wrapped()   const noexcept;
      allocator_type  get_allocator() const noexcept;
      void            set_emit_on_sync(bool) noexcept;

    protected:
      // Overridden virtual functions:
      int sync() override;

    private:
      streambuf_type *wrapped;       // exposition only
      bool            emit_on_sync{};// exposition only
    };

#### Class std::basic_osyncstream

    template <class CharT,
              class Traits = char_traits<CharT>,
              class Allocator = allocator<CharT>>
    class basic_osyncstream
      : public basic_ostream<CharT, Traits>
    {
    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;
      using allocator_type = Allocator;
      using streambuf_type = basic_streambuf<CharT, Traits>;
      using syncbuf_type   = basic_syncbuf<CharT, Traits, Allocator>;

      // Constructors/destructor:
      basic_osyncstream(streambuf_type *, const Allocator &);
      explicit basic_osyncstream(streambuf_type *obuf)
        : basic_osyncstream(obuf, Allocator()) {}
      basic_osyncstream(basic_ostream<CharT,Traits> &os, const Allocator &allocator)
        : basic_osyncstream(os.rdbuf(), allocator){}
      explicit basic_osyncstream(basic_ostream<CharT,Traits> &os)
        : basic_osyncstream(os, Allocator()) {}
      basic_osyncstream(basic_osyncstream&&) noexcept;
      ~basic_osyncstream();

      // Assign:
      basic_osyncstream& operator=(basic_osyncstream&&) noexcept;

      // Members:
      void emit();
      streambuf_type* get_wrapped() const noexcept;
      syncbuf_type* rdbuf() const noexcept { return &sb ; }

    private:
      syncbuf_type sb; // exposition only
    };

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/syncstream&oldid=107858"