# Standard library header <syncstream> (C++20)

From cppreference.com
< cpp‎ | header

This header is part of the Input/Output library.

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

### Synopsis

    #include <ostream>

    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>;
    }

#### Class template std::basic_syncbuf

    namespace std {
      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>;

        // construction and destruction
        basic_syncbuf()
          : basic_syncbuf(nullptr) {}
        explicit basic_syncbuf(streambuf_type* obuf)
          : basic_syncbuf(obuf, Allocator()) {}
        basic_syncbuf(streambuf_type*, const Allocator&);
        basic_syncbuf(basic_syncbuf&&);
        ~basic_syncbuf();

        // assignment and swap
        basic_syncbuf& operator=(basic_syncbuf&&);
        void swap(basic_syncbuf&);

        // member functions
        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
      };

      // specialized algorithms
      template<class CharT, class Traits, class Allocator>
        void swap(basic_syncbuf<CharT, Traits, Allocator>&,
                  basic_syncbuf<CharT, Traits, Allocator>&);
    }

#### Class template std::basic_osyncstream

    namespace std {
      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>;

        // construction and destruction
        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();

        // assignment
        basic_osyncstream& operator=(basic_osyncstream&&) noexcept;

        // member functions
        void emit();
        streambuf_type* get_wrapped() const noexcept;
        syncbuf_type* rdbuf() const noexcept
        { return const_cast<syncbuf_type*>(addressof(sb)); }

      private:
        syncbuf_type sb;    // exposition only
      };
    }

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