C++ boost-asio-async\u-read：读取消息会添加到自身中

我用我的电脑作为服务器。客户端发送诸如“PART1:Part2”之类的消息，服务器执行必要的操作。我使用boost的asio作为服务器代码

    void start_read()
    {
        boost::asio::async_read(socket_, input_buffer_,
            boost::asio::transfer_at_least(1),
            boost::bind(&tcp_connection::handle_read, shared_from_this(),
            boost::asio::placeholders::error));
    }

    // When stream is received handle the message from the client
    void handle_read(const boost::system::error_code& error)
    {
        if (!error)
        {
            boost::asio::streambuf::const_buffers_type bufs = input_buffer_.data();
            std::string msgstr(boost::asio::buffers_begin(bufs),
                               boost::asio::buffers_begin(bufs) +
                               input_buffer_.size());

            std::vector<std::string> msgVector;
            boost::split(msgVector, msgstr, boost::is_any_of(":"));

            messageFromClient_ = msgVector[0];
            valueFromClient_ = msgVector[1];
};

这不是我想要的。我不想包含来自上一个缓冲区的数据，即，我希望：

PART1:part2a
PART1:part2b
PART1:part2c
PART1:part2d

我知道问题很可能在于：

            std::string msgstr(boost::asio::buffers_begin(bufs),
                               boost::asio::buffers_begin(bufs) +
                               input_buffer_.size());

但是，我找不到适用于我的情况的正确代码

编辑： 尝试这样做：

std::istream response_istream(&input_buffer_);
std::string msgstr;
response_istream >> msgstr;

前三次，我得到了我所需要的，但随后信息成倍增加。事情总是这样的：

PART1:part2a
PART1:part2bPART1:part2b
PART1:part2cPART1:part2cPART1:part2c
PART1:part2dPART1:part2dPART1:part2dPART1:part2d

PART1:part2a
PART1:part2b
PART1:part2c
PART1:part2dPART1:part2d
PART1:part2ePART1:part2e
PART1:part2fPART1:part2fPART1:part2fPART1:part2f
PART1:part2gPART1:part2g

先谢谢你

成员函数返回表示输入序列的缓冲区。为了避免再次访问数据，可以使用member函数从输入序列的开头删除字符。在这种情况下，一旦数据从

input\u buffer\u

复制到

msgstr

，输入序列可通过以下方式清除：

输入缓冲区消耗（输入缓冲区大小（））；

---

下面是一个关于

consume（）

行为的完整示例：

#包括
#包括
#包括
#包括
//本例对处理程序不感兴趣，因此提供一个noop函数
//将传递给bind以满足处理程序概念要求。
void noop（）{}
int main（）
{
使用boost:：asio:：ip:：tcp；
boost:：asio:：io_服务io_服务；
//创建所有I/O对象。
tcp:：acceptor acceptor（io_服务，tcp:：endpoint（tcp:：v4（），0））；
tcp：：套接字服务器\u套接字（io\u服务）；
tcp:：socket客户端\u套接字（io\u服务）；
//连接客户端和服务器套接字。
acceptor.async_accept（server_socket，boost:：bind（&noop））；
client_socket.async_connect（acceptor.local_endpoint（），boost:：bind（&noop））；
io_service.run（）；
//没有消费案例。
{ 
std:：cout成员函数返回表示输入序列的缓冲区。为了避免再次访问数据，可以使用成员函数从输入序列的开头删除字符。在这种情况下，一旦数据从
input\u buffer\ucode>复制到
msgstr
，就可以使用h:

输入缓冲区消耗（输入缓冲区大小（））；


下面是一个关于
consume（）
行为的完整示例：

#包括
#包括
#包括
#包括
//本例对处理程序不感兴趣，因此提供一个noop函数
//将传递给bind以满足处理程序概念要求。
void noop（）{}
int main（）
{
使用boost:：asio:：ip:：tcp；
boost:：asio:：io_服务io_服务；
//创建所有I/O对象。
tcp:：acceptor acceptor（io_服务，tcp:：endpoint（tcp:：v4（），0））；
tcp：：套接字服务器\u套接字（io\u服务）；
tcp:：socket客户端\u套接字（io\u服务）；
//连接客户端和服务器套接字。
acceptor.async_accept（server_socket，boost:：bind（&noop））；
client_socket.async_connect（acceptor.local_endpoint（），boost:：bind（&noop））；
io_service.run（）；
//没有消费案例。
{ 
std:：cout成员函数返回表示输入序列的缓冲区。为了避免再次访问数据，可以使用成员函数从输入序列的开头删除字符。在这种情况下，一旦数据从
input\u buffer\ucode>复制到
msgstr
，就可以使用h:

输入缓冲区消耗（输入缓冲区大小（））；


下面是一个关于
consume（）
行为的完整示例：

#包括
#包括
#包括
#包括
//本例对处理程序不感兴趣，因此提供一个noop函数
//将传递给bind以满足处理程序概念要求。
void noop（）{}
int main（）
{
使用boost:：asio:：ip:：tcp；
boost:：asio:：io_服务io_服务；
//创建所有I/O对象。
tcp:：acceptor acceptor（io_服务，tcp:：endpoint（tcp:：v4（），0））；
tcp：：套接字服务器\u套接字（io\u服务）；
tcp:：socket客户端\u套接字（io\u服务）；
//连接客户端和服务器套接字。
acceptor.async_accept（server_socket，boost:：bind（&noop））；
client_socket.async_connect（acceptor.local_endpoint（），boost:：bind（&noop））；
io_service.run（）；
//没有消费案例。
{ 
std:：cout成员函数返回表示输入序列的缓冲区。为了避免再次访问数据，可以使用成员函数从输入序列的开头删除字符。在这种情况下，一旦数据从
input\u buffer\ucode>复制到
msgstr
，就可以使用h:

输入缓冲区消耗（输入缓冲区大小（））；


下面是一个关于
consume（）
行为的完整示例：

#包括
#包括
#包括
#包括
//本例对处理程序不感兴趣，因此提供一个noop函数
//将传递给bind以满足处理程序概念要求。
void noop（）{}
int main（）
{
使用boost:：asio:：ip:：tcp；
boost:：asio:：io_服务io_服务；
//创建所有I/O对象。
tcp:：acceptor acceptor（io_服务，tcp:：endpoint（tcp:：v4（），0））；
tcp：：套接字服务器\u套接字（io\u服务）；
tcp:：socket客户端\u套接字（io\u服务）；
//连接客户端和服务器套接字。
acceptor.async_accept（server_socket，boost:：bind（&noop））；
client_socket.async_connect（acceptor.local_endpoint（），boost:：bind（&noop））；
io_service.run（）；
//没有消费案例。
{ 
std:：cout非常感谢，Tanner。我现在有了这个：`boost:：asio:：streambuf:：const\u buffers\u type bufs=input\u buffer\u.data（）`
std:：string msgstr（boost:：asio:：buffers\u begin（bufs），boost:：asio:：buffers\u begin（bufs）+input\u buffer\u.size（）；
input\u buffer\u.Consumer（input\u buffer\u.size（））
这使它成为一个问题，正如我在编辑后的文本中所显示的那样，即前三次，字符串是正常的，但随后它是这样的：PART1:part2aPart1:part2a。每隔一段时间，字符串中有三个组件。嗯……谢谢！e