Boost.Asio async_read 從套接字中讀取字符串

Question

我正在嘗試編寫一個 function async_read_string_n以從具有 Boost.Asio 1.78（和 GCC 11.2）的套接字中異步讀取正好n個字節的字符串。

這就是我想使用 function async_read_string_n的方式：

void run() {
  co_spawn (io_context_, [&]() -> awaitable<void> {
    auto executor = io_context_.get_executor();
    tcp::acceptor acceptor(executor, listen_endpoint_);

    auto [ec, socket] = co_await acceptor.async_accept(as_tuple(use_awaitable));
    co_spawn(executor, [&]() -> awaitable<void> {

      auto [ec, header] = co_await async_read_string_n(socket, 6, as_tuple(use_awaitable));
      std::cerr << "received string " << header << "\n";
      co_return;
    }
    , detached);
    co_return;
  }
  , detached);
}
  

這是我按照中的建議編寫async_read_string_n的嘗試

• https://www.boost.org/doc/libs/1_78_0/doc/html/boost_asio/reference/asynchronous_operations.html#boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type
• https://www.boost.org/doc/libs/1_78_0/doc/html/boost_asio/overview/core/cpp20_coroutines.html#boost_asio.overview.core.cpp20_coroutines.error_handling

（我不關心 memory 復制。這不應該很快；它應該有一個不錯的 API。）

template<class CompletionToken> auto async_read_string_n(tcp::socket& socket, int n, CompletionToken&& token) {
  async_completion<CompletionToken, void(boost::system::error_code, std::string)> init(token);
  asio::streambuf b;
  asio::streambuf::mutable_buffers_type bufs = b.prepare(n);
  auto [ec, bytes_transferred] = co_await asio::async_read(socket, bufs, asio::transfer_exactly(n), as_tuple(use_awaitable));
  b.commit(n);
  std::istream is(&b);
  std::string s;
  is >> s;
  b.consume(n);
  init.completion_handler(ec, s);
  return init.result.get();
}

編輯

（我有一個語法錯誤，我修復了它。）這是我堅持的async_read_string_n中的編譯器錯誤：

GCC 錯誤：

error: 'co_await' cannot be used in a function with a deduced return type

如何編寫 function async_read_string_n ？

Answer 1

您不必使用streambuf 。 無論如何，使用>>提取不會可靠地提取字符串（空格會停止輸入）。

更大的問題是你必須選擇是否要使用

• co_await （需要另一種簽名，因為您的第二個鏈接正確顯示）
• 或異步結果協議，這意味着調用者將決定使用什么機制（回調、未來、組、等待等）。

所以要么做到：

使用異步結果協議：

#include <boost/asio.hpp>
#include <boost/asio/awaitable.hpp>
#include <boost/asio/experimental/as_tuple.hpp>
#include <boost/asio/use_awaitable.hpp>
#include <iostream>
#include <iomanip>
namespace net = boost::asio;
using net::ip::tcp;
using boost::system::error_code;

template <typename CompletionToken>
auto async_read_string_n(tcp::socket& socket, int n, CompletionToken&& token)
{
    struct Op {
        net::async_completion<CompletionToken, void(error_code, std::string)>
            init;
        std::string buf;
        Op(CompletionToken token) : init(token) {}
    };
    auto op = std::make_shared<Op>(token);

    net::async_read(socket, net::dynamic_buffer(op->buf),
                    net::transfer_exactly(n), [op](error_code ec, size_t n) {
                        op->init.completion_handler(ec, std::move(op->buf));
                    });
    return op->init.result.get();
}

int main() {
    net::io_context ioc;
    tcp::socket s(ioc);
    s.connect({{}, 8989});

    async_read_string_n(s, 10, [](error_code ec, std::string s) {
        std::cout << "Read " << ec.message() << ": " << std::quoted(s)
                  << std::endl;
    });

    ioc.run();
}

印刷

或使用 co_await

類似於此處的示例：

boost::asio::awaitable<void> echo(tcp::socket socket)
{
  char data[1024];
  for (;;)
  {
    auto [ec, n] = co_await socket.async_read_some(boost::asio::buffer(data),
        boost::asio::experimental::as_tuple(boost::asio::use_awaitable));
    if (!ec)
    {
      // success
    }

    // ...
  }
}

Answer 2

感謝@sehe 的回答，它為我提供了編寫與async_read_string_n一起使用的co_await所需的信息：

asio::awaitable<std::tuple<boost::system::error_code, std::string>> async_read_string_n(tcp::socket& socket, int n) {
  std::string buf;
  auto [ec, bytes_transferred] = co_await asio::async_read(socket, asio::dynamic_buffer(buf), asio::transfer_exactly(n), as_tuple(use_awaitable));
  co_return make_tuple(ec, buf);
}

像這樣使用它：

auto [ec, string6] = co_await async_read_string_n(socket, 6);