boost::bind 函数的最大缓冲区大小

Question

我对 boost::bind 方法中调用的处理函数中缓冲区的最大大小有疑问。 我有一个 tcp 套接字客户端：

chat_client(boost::asio::io_service& io_service,
  tcp::resolver::iterator endpoint_iterator)
: io_service_(io_service),
  socket_(io_service),
  t(io_service)
{
    boost::asio::async_connect(socket_, endpoint_iterator,
           boost::bind(&chat_client::handle_connect, this,
           boost::asio::placeholders::error));
}

在 chat_client 类中，我创建了一个将请求写入套接字缓冲区的方法

 void set_timer(boost::posix_time::ptime time, boost::function<void(const 
      boost::system::error_code&)> handler)
 {
     t.expires_at(time);
     t.async_wait(handler);
 }
void write(const chat_message& msg)
{
     set_timer(boost::posix_time::microsec_clock::universal_time() + 
          boost::posix_time::seconds(1),
          boost::bind(&chat_client::do_write, this, msg, 
          boost::asio::placeholders::error));
     io_service_.run();
}
void do_write(chat_message msg, const boost::system::error_code& error)
{
     std::cout << "dcm" << std::endl;
     bool write_in_progress = !write_msgs_.empty();
     write_msgs_.push_back(msg);
     if (!write_in_progress)
     {
          boost::asio::async_write(socket_,
                            boost::asio::buffer(write_msgs_.front().data(),
                            write_msgs_.front().length()),
                            boost::bind(&chat_client::handle_write, this,
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
     }
}

void handle_write(const boost::system::error_code& error, size_t 
      bytes_transferred)
{
    if (!error)
    {
         write_msgs_.pop_front();
         if (!write_msgs_.empty())
         {
              boost::asio::async_write(socket_,
                             boost::asio::buffer(write_msgs_.front().data(),
                             write_msgs_.front().length()),
                             boost::bind(&chat_client::handle_write, this,
                             boost::asio::placeholders::error,
                             boost::asio::placeholders::bytes_transferred));
         }
    }
    else
    {
         do_close();
    }
}

我的请求内容被打包在一个 chat_message 类的实例中。这里是 chat_message 类：

class chat_message
{
public:
    enum { header_length = 7 };
    enum { max_body_length = 0x1FFFFF };

    chat_message()
    : body_length_(0)
    {
    }

    const char* data() const
    {
        return data_;
    }

    char* data()
    {
        return data_;
    }

    size_t length() const
    {
        return header_length + body_length_;
    }

    const char* body() const
    {
        return data_ + header_length;
    }

    char* body()
    {
        return data_ + header_length;
    }

    size_t body_length() const
    {
        return body_length_;
    }

    void body_length(size_t new_length)
    {
        body_length_ = new_length;
        if (body_length_ > max_body_length)
            body_length_ = max_body_length;
    }

    bool decode_header()
    {
        using namespace std; // For strncat and atoi.
        char header[header_length + 1] = "";
        strncat(header, data_, header_length);
        body_length_ = atoi(header);
        if (body_length_ > max_body_length)
        {
            body_length_ = 0;
            return false;
        }
        return true;
    }

    void encode_header()
    {
        using namespace std; // For sprintf and memcpy.
        char header[header_length + 1] = "";
        sprintf(header, "%4d", static_cast<int>(body_length_));
        memcpy(data_, header, header_length);
    }

private:
    char data_[header_length + max_body_length];
    size_t body_length_;
};

我的问题是当我设置 max_body_length > 0xFFFFF 时，write() 函数中的 boost::bind() 方法会导致分段错误。所以我怀疑 boost::bind() 方法有最大的缓冲区大小。有人可以为我解释一下吗？谢谢

Answer 1

问题不在于boost::bind()，而在于以下：

char data_[header_length + max_body_length];

这一行可以正常编译，但在访问元素时可能会崩溃。我强烈建议不要在这里使用如此庞大的字符数组。作为保留它的方法之一，您可能会考虑动态分配。或者根本从数组中移动。 STL 和 BOOST 库提供了很多工具来安全地处理字符串和集合。