标准库头文件 <syncstream>

来自cppreference.com
< cpp‎ | header
 
 
 

此头文件是输入/输出库的一部分。

目录

包含

<ostream>

同步输出设备的包装
(类模板) [编辑]
同步输出流的包装
(类模板) [编辑]

typedef

syncbuf basic_syncbuf<char>
wsyncbuf basic_syncbuf<wchar_t>
osyncstream basic_osyncstream<char>
wosyncstream basic_osyncstream<wchar_t>

函数

特化 std::swap 算法
(函数模板) [编辑]

[编辑] 概要

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

[编辑] 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>;
 
  // 构造函数/析构函数:
  explicit
  basic_syncbuf(streambuf_type* obuf = nullptr)
    : basic_syncbuf(obuf, Allocator()) {}
  basic_syncbuf(streambuf_type*, const Allocator&);
  basic_syncbuf(basic_syncbuf&&);
  ~basic_syncbuf();
 
  // 赋值/交换:
  basic_syncbuf& operator=(basic_syncbuf&&);
  void swap(basic_syncbuf &);
 
  // 成员:
  bool emit();
  streambuf_type* get_wrapped()   const noexcept;
  allocator_type  get_allocator() const noexcept;
  void            set_emit_on_sync(bool) noexcept;
 
protected:
  // 覆写的虚函数:
  int sync() override;
 
private:
  streambuf_type *wrapped;       // 仅为说明
  bool            emit_on_sync{};// 仅为说明
};

[编辑] 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>;
 
  // 构造函数/析构函数:
  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();
 
  // 赋值:
  basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
 
  // 成员:
  void emit();
  streambuf_type* get_wrapped() const noexcept;
  syncbuf_type* rdbuf() const noexcept { return &sb ; }
 
private:
  syncbuf_type sb; // 仅为说明
};