Boost Asio：尝试调用写入函数时管道破裂"externaly"

我正在尝试实现一个简单的客户机-服务器应用程序，在该应用程序中，我将为客户机引入简单的API，以便与服务器交互。问题是，当我尝试使用那个API时，客户端会抱怨system:32错误，它代表管道破裂。然而，如果我从类内部调用该函数，那么一切都可以完美地工作。

    #include <boost/bind.hpp>
#include <cstdio> /* sprintf */
#include "client.hpp"
#include "commands.hpp"
Client::Client(boost::asio::io_service& io_service, 
    boost::asio::ip::tcp::resolver::iterator endpoint_iterator):
    io_service_(io_service),
    socket_(io_service)
{
    boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
    socket_.async_connect(endpoint,
        boost::bind(&Client::handle_connect, this, endpoint_iterator, 
            boost::asio::placeholders::error
        )
    );
}
void Client::handle_connect(boost::asio::ip::tcp::resolver::iterator 
    endpoint_iterator, const boost::system::error_code& error)
{
    if(!error)
    {
        //Client::read_header(read_.header(), read_.header_length());
        Client::identify_user("User", "Password");
    }
    else if(endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
    {
        socket_.close();
        boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
        socket_.async_connect(endpoint, 
            boost::bind(&Client::handle_connect, this, ++endpoint_iterator,
                boost::asio::placeholders::error
            )
        );
    }
}
void Client::handle_readheader(size_t bytes_transferred, 
    const boost::system::error_code& error)
{
    if(bytes_transferred)
    {
        if(read_.decode_command() == IDENTIFY)
        {
            Client::identify_user("Username", "Password");
        }
    }
    else
    {
        Client::read_header(read_.header(), read_.header_length());
    }
}
void Client::handle_read(size_t bytes_transferred, 
    const boost::system::error_code& error)
{
    if(bytes_transferred)
    {
        Client::read_header(read_.header(), read_.header_length());
    }
    else if(error)
    {
    }
    else
    {
        Client::read_header(read_.header(), read_.header_length());
    }
}
void Client::handle_write(size_t bytes_transferred, 
    const boost::system::error_code& error)
{
    if(bytes_transferred)
    {
        Client::read_header(read_.header(), read_.header_length());
    }
    else if(error)
    {
    }
    else
    {
        Client::read_header(read_.header(), read_.header_length());
    }
}

void Client::handle_writeheader(size_t bytes_transferred, 
    const boost::system::error_code& error)
{
    if(bytes_transferred)
    {
        if(write_.decode_command() == AUTHENTICATE)
        {
            std::cout << "Bodylen:" << write_.decode_size() << std::endl;
            std::cout << write_.body() << std::endl;
            Client::write(write_.body(), write_.decode_size());
        }
    }
    else if(error)
    {
        std::cout << "Error HWH: " << error << std::endl;
    }
    else
    {
        Client::read_header(read_.header(), read_.header_length());
    }
}
void Client::identify_user(const char* username, const char* password)
{
    size_t tmplen = (strlen(username) + strlen(password) + 2);
    char tmpbody[tmplen];
    std::sprintf(tmpbody, "%s:%s", username, password);
    write_.body(tmpbody);
    std::cout << write_.body() << std::endl;
    write_.encode_header(11, tmplen);
    std::cout << write_.header() << std::endl;
    Client::write_header(write_.header(), write_.header_length());
}
void Client::read(char* buffer, size_t len)
{
    boost::asio::async_read(socket_, boost::asio::buffer(buffer, len),
        boost::bind(&Client::handle_read, this,
            boost::asio::placeholders::bytes_transferred,
            boost::asio::placeholders::error
        )
    );
}
void Client::read_header(char* buffer, size_t len)
{
    boost::asio::async_read(socket_, boost::asio::buffer(buffer, len),
        boost::bind(&Client::handle_readheader, this,
            boost::asio::placeholders::bytes_transferred,
            boost::asio::placeholders::error
        )
    );
}
void Client::write_header(char* buffer, size_t len)
{
    boost::asio::async_write(socket_, boost::asio::buffer(buffer, len),
        boost::bind(&Client::handle_writeheader, this,
            boost::asio::placeholders::bytes_transferred,
            boost::asio::placeholders::error
        )
    );
}
void Client::write(char* buffer, size_t len)
{
    boost::asio::async_write(socket_, boost::asio::buffer(buffer, len),
        boost::bind(&Client::handle_write, this,
            boost::asio::placeholders::bytes_transferred,
            boost::asio::placeholders::error
        )
    );
}
int main(){
    boost::asio::io_service io_service;
    boost::asio::ip::tcp::resolver resolver(io_service);
    boost::asio::ip::tcp::resolver::query query("localhost", "5000");
    boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
    Client client(io_service, iterator);
    //client.identify_user("User", "Password");
    io_service.run();
    return(0);
}

理论上，行为应该如下：客户端通过identity_client-向服务器发送身份验证标头，指示之后要发送的字节数，并等待，直到收到调用read_header（…）--的ACK。服务器发送确认ACK，确认已准备好处理客户端发送的任何内容。客户端发送用户和密码。

然而，正如我上面所说，它似乎只有在我通过handle_connect调用identify_client时才起作用，这是完全无用和静态的。我做错了什么？

事先非常感谢。

EDIT:消息类与此类非常相似，它可以帮助我操作和轻松解释协议的消息。

第2版：我会试着更好地解释它。我认为main函数"在类之外"是独立的。然后，main函数创建一个Client对象，该对象包含API，用于从服务器发送和接收数据-我附加了.hpp文件，希望这能帮助您更好地理解-。

因此，如果我有一个像下面这样的循环。。。

        /* ... */
    for(;;)
    {
        /* ... */
        // Do something here
        /* If a condition, then authenticate the user */
        //client.identify_user("User", "Password");
        // Do something there
        /* ... */
    }
    /* ... */

使用创建的对象，我应该能够调用对象的特定成员函数，这将触发进一步的写入或读取。我现在的问题是，我无法做到这一点。

如果我从Client类的handle_connect(...)函数调用identify_user——如上面的原始代码所示——它就可以工作了。当然，我不能实现我想要的。

如果为了从main调用函数而对此进行注释，则会出现管道破裂错误。

    if(!error)
{
    //Client::read_header(read_.header(), read_.header_length());
    //Client::identify_user("User", "Password");
}

如果我留下这样的代码，我会得到同样的管道破裂错误。

if(!error)
{
    Client::read_header(read_.header(), read_.header_length());
    //Client::identify_user("User", "Password");
}

当我学习asio时，我读到如果io_service没有工作，那么应用程序就会结束。也许我的问题与此有关。

第4版：我喜欢说我要附加一些东西，然后完全忘记它。

    #ifndef CLIENT_HPP
#define CLIENT_HPP
#include <boost/asio.hpp>
#include "message.hpp"
class Client
{
public:
    Client(boost::asio::io_service& io_service, 
           boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
    void identify_user(const char* username, const char* password);
private:
    void handle_connect(
        boost::asio::ip::tcp::resolver::iterator endpoint_iterator,
        const boost::system::error_code& error);
    void handle_read(size_t bytes_transferred, 
        const boost::system::error_code& error);
    void handle_readheader(size_t bytes_transferred, 
        const boost::system::error_code& error);
    void handle_write(size_t bytes_transferred,
        const boost::system::error_code& error);
    void handle_writeheader(size_t bytes_transferred,
        const boost::system::error_code& error);
    void read(char* buffer, size_t len);
    void read_header(char* buffer, size_t len);
    void write_header(char* buffer, size_t len);
    void write(char* buffer, size_t len);
    boost::asio::io_service& io_service_;
    boost::asio::ip::tcp::socket socket_;
    Message read_;
    Message write_;
};
#endif /* client.hpp */

第5版：这似乎奏效了。它肯定与io_service:有关

for(;;)
{
    io_service.poll();
client.identify_user("User", "Password");
}