标签: streambuf

istreambuf_iterator和之间有什么区别istream_iterator？一般来说,stream和streambufs有什么区别？我真的找不到任何明确的解释,所以决定在这里问.

显然boost::asio::async_read不喜欢字符串,因为唯一的重载boost::asio::buffer允许我创建const_buffers,所以我坚持将所有内容都读成streambuf.
现在我想将streambuf的内容复制到一个字符串中,但它显然只支持写入char*(sgetn()),使用streambuf创建一个istream并使用getline().

有没有其他方法可以创建一个带有streambufs内容的字符串,而无需过多的复制？

出于教育目的,我想创建一个ostream和流缓冲区来做:

1. 做<< myVar时修复endians;
2. 存储在deque容器中而不是使用std:cout或写入文件
3. 记录额外的数据,例如我做了多少次<<,我做了多少次.write,我写的字节数和flush()的次数.但我不需要所有的信息.

我尝试过载,但失败的可怕.我试着通过写入来重载

ostream& write( const char* s, streamsize n ) 

在我的basic_stringstream2类中(我复制粘贴basic_stringstream到我的cpp文件并修改它)但代码保持使用basic_ostream.我查看了代码,看起来我需要重载xsputn(这个页面上没有提到http://www.cplusplus.com/reference/iostream/ostream)但是我还需要重载多少？以及如何构建我的类(它需要继承什么等)？

我正在使用此代码进行阅读

  socket_.async_read_some(boost::asio::buffer(data_, max_length),
        boost::bind(&session::handle_read, this,
        boost::asio::placeholders::error,
        boost::asio::placeholders::bytes_transferred));

这是为了写作

boost::asio::async_write(socket_,
    boost::asio::buffer(data_, bytes_transferred),
    boost::bind(&session::handle_write, this,
    boost::asio::placeholders::error));

其中socket_是socket,max_length是枚举,值为1024,data_是char数组,长度为max_length.

但我想用streambuf替换char数组缓冲区.我试过了

  boost::asio::streambuf streamBuffer;
  socket_.async_read_some(boost::asio::buffer(streamBuffer),
        boost::bind(&session::handle_read, this,
        boost::asio::placeholders::error,
        boost::asio::placeholders::bytes_transferred));

但是没有用.我该怎么做 ？

我有一个内存块(不透明),我想通过他们的C++适配器存储在mySQL的Blob中.适配器需要一个istream:

virtual void setBlob(unsigned int parameterIndex, std::istream * blob) = 0;

所以我的问题是:如何从这个内存块创建一个std :: istream(键入为char*).它不是一个字符串,因为它不是以空值终止的(但我知道它的长度当然).

如果没有复制我的内存块,例如在std :: string中,我找不到一种方法.我认为这有点浪费.这样的东西不起作用:

    std::streambuf istringbuf(blockPtr, blockLength);
    std::istringstream tmp_blob(&istringbuf);

因为std :: streambuf没有这样的构造函数.我看到了以下建议.

    std:: istringstream       tmp_blob;
    tmp_blob.rdbuf()->pubsetbuf(blockPtr, blockLength);

这是正确的方法吗？

我正在尝试创建一个既是输入流又是输出流的类（如std::cout和std::cin）。我试图超负荷运营商<<和>>，但后来，我明白了写这样的代码是不明智的做（因为这将改写C ++流的方法）和维持是很辛苦的时候类喜欢std::basic_iostream，std::basic_ostream，std::basic_istream用C可++标准库，因为我必须为每种类型重载运算符。所以，我试图这样定义我的类：

#include <istream>

class MyStream : public std::basic_iostream<char> {
public:
    MyStream() : std::basic_iostream<char>(stream_buffer) {}
};

我的问题是std::basic_iostream<char>. 从cppreference 开始，std::basic_iostream::basic_iostream接受一个指向从 派生的流缓冲区的指针std::basic_streambuf：

explicit basic_iostream( std::basic_streambuf<CharT,Traits>* sb );

我已经阅读并尝试了Apache C++ 标准库用户指南第 38 章中的示例。它说我必须传递一个指向流缓冲区的指针，有三种方法可以这样做：

• 在类初始化之前创建流缓冲区
• 从另一个流中获取流缓冲区（使用rdbuf()或类似成员）
• 将basic_streambuf对象定义为受保护或私有成员

最后一个选项最适合我的目的，但如果我直接从std::basic_streambuf类创建一个对象，它什么也不做，是吗？所以我定义了另一个派生自std::basic_streambuf<char>. 但是这次我无法理解要定义哪些函数，因为我不知道在插入，提取和刷新数据时调用了哪个函数。

如何创建具有自定义功能的流？

_{请注意，这是尝试构建有关创建 C++ 流和流缓冲区的标准指南。}

假设我有一个带ostream &参数o并写入该ostream 的函数.的operator <<实现将是一个很好的例子.

ostream& operator << (ostream& o, const MyThing& t)
{
  // ... interesting code here ...
  return o;
}

在函数中,我可能想要在流上指定格式化选项.例如,我可能希望将数字打印为十六进制,无论在o传递给函数时如何配置.

其次,我可能希望能够对当前的格式化标志做出假设.例如,除非我另有要求,否则能够假设数字被格式化为十进制将是很好的.

最后,当函数退出时,我希望格式化选项o与调用函数之前的格式化选项相同,以便对调用者不变.这只是打电话者礼貌的问题.

到目前为止,我已经通过ostringstream在函数中创建一个本地,完成所有工作(包括设置格式化选项),并在函数结束时发送到目标.str()来实现o这一目标. 这里的StackOverflow问题表明,比我聪明的人采取相同的方法. 然而,令我困扰的是,我在ostringstreams中保留了大量数据,这些数据可能会更早地发送到输出(字符串可能变得非常大).

我有两个问题:

1)创建一个临时的(基于堆栈的)ostream 并在那个ostream上做我的工作是合法的,惯用的,良好的形式等o.rdbuf()吗？我自己的测试和cppreference.com上的页面似乎表明我可以.

ostream& operator << (ostream& o_, const MyThing& t)
{
  ostream o (o_.rdbuf());
  // write stuff to "o",
  // setting formatting options as I go.
  return o_; // …

寻找一个boost :: asio(以及自己的提升)决定编写异步服务器.要存储传入的数据,我使用boost :: asio :: streambuf.我有一个问题.当我从客户端收到第二条消息后,我发现缓冲区中包含来自先前消息的数据.虽然我在输入缓冲区调用Consume方法.怎么了？

class tcp_connection
// Using shared_ptr and enable_shared_from_this 
// because we want to keep the tcp_connection object alive 
// as long as there is an operation that refers to it.
: public boost::enable_shared_from_this<tcp_connection>
{
...

boost::asio::streambuf receive_buffer;

boost::asio::io_service::strand strand;
}

...

void tcp_connection::receive()
{
// Read the response status line. The response_ streambuf will
// automatically grow to accommodate the entire line. The growth may be
// limited by passing a maximum size to …

我想在实例之间有效地复制数据std::streambuf.也就是说,我想在它们之间铲除数据块,而不是执行逐字符复制.例如,这不是我想要的:

stringbuf in{ios_base::in};
stringbuf out{ios_base::out};
copy(istreambuf_iterator<char>{in},
     istreambuf_iterator<char>{},
     ostreambuf_iterator<char>{out});

这有一个语法糖,有更多的错误检查:

ostream os{&out};
os << &in;

这是operator<<(basic_streambuf<..>*)我标准库(Mac OS X,XCode 7)中实现的片段:

                typedef istreambuf_iterator<_CharT, _Traits> _Ip;
                typedef ostreambuf_iterator<_CharT, _Traits> _Op;
                _Ip __i(__sb);
                _Ip __eof;
                _Op __o(*this);
                size_t __c = 0;
                for (; __i != __eof; ++__i, ++__o, ++__c)
                {
                    *__o = *__i;
                    if (__o.failed())
                        break;
                }

底线是:这仍然是每个字符的复制.我希望标准库使用的算法依赖于streambuffers的块级成员函数,sputn而sgetn不是每个字符的传输.标准库是否提供了这样的算法,还是我必须自己编写？

我想编写一个我自己的日志库,它为日志条目的发送位置提供抽象.

C++的IO库已经用std::stringstream和提供了那种抽象std::fstream.我也希望能够从/向套接字读/写.

我读到扩展标准库的正确方法是继承std::basic_streambuf.我不明白的是,如果继承std::basic_streambuf像std::basic_filebuf呢,哪里是需要的std::ifsream,std::ofstream和std::fstream班？我不能只用一个子类的实例替换某些流的缓冲区,该子类的std::basic_streambuf输出输出到我想要的地方吗？

到目前为止,我已经完成了以下工作,但我真的不确定我在做什么.以下设计是否正确？

template< typename char_type, typename traits_type = std::char_traits< char_type > >
class basic_sock_streambuf : public std::basic_streambuf< char_type, traits_type >
{
public:

    basic_sock_streambuf()
    {

    }

    ~basic_sock_streambuf()
    {

    }

    int overflow (int c = EOF)
    {
        fputc( c, stdout ); // Temporary.
        return traits_type::to_int_type( c );
    }

    int underflow()
    {
        return fgetc( stdout ); // Temporary.
    }

    int sync()
    {
        return …