C++ boost asio: простой сервер/клиент с boost:asio::read и boost::asio::write, передающий вектор int

вы портите размер буфера при чтении

boost::asio::read(s, boost::asio::buffer(&data, sizeof(data)));

неправильно, вероятно, должно быть:

boost::asio::read(s, boost::asio::buffer(data));

вы передаете размер векторного объекта, а не размер векторного хранилища.

Кстати, с повышением вам не нужно устанавливать размер, поскольку он может считывать его из самого вектора.

ПРИМЕЧАНИЕ: ваш код все равно не будет работать, потому что вы на самом деле отправляете целое число 9 и пытаетесь получить 10, поэтому вы получите исключение «конец файла» при чтении, но это другая история.

"Но могу ли я знать, как получить вектор неизвестного размера?" - использовать сериализацию (Boost Serialization, json или что-то еще) и включить протокол обработки сообщений — sehe 5 часов назад

Поскольку я верю в принцип «покажи, а не говори», вот пример, в котором используется C++20 с ускоренной сериализацией для реализации службы эха данных, которая отправляет следующую структуру (и обратно):

struct ApplicationData {
    std::vector<int>              ints;
    std::map<std::string, double> map;
};

Сериализация

Для сериализации достаточно поставить:

    void serialize(auto& ar, unsigned) { ar & ints & map; }

Сериализация Boost знает, как работать со строками, картами и векторами.

Давайте также упростим использование Boost Serialization для заданных asio::streambuf объектов:

static constexpr auto FRAME = "FRAME_SEPARATOR"sv;
static inline auto& as_frame(auto const& data, asio::streambuf& buf) {
    std::ostream os(&buf);
    boost::archive::text_oarchive(os) << data;
    os << FRAME << std::flush;
    return buf;
}

template <typename T> static inline T from_frame(asio::streambuf& buf) {
    T obj;
    std::istream is(&buf);
    boost::archive::text_iarchive ia(is);
    ia >> obj;
    if (std::string frame; is >> frame && frame == FRAME)
        return obj;
    throw std::runtime_error("Stream error");
}

Корутины

Используя несколько удобных определений, мы можем написать сопрограммы в один миг:

using Void     = asio::awaitable<void>;
using Acceptor = asio::use_awaitable_t<>::as_default_on_t<tcp::acceptor>;
using Socket   = asio::use_awaitable_t<>::as_default_on_t<tcp::socket>;

Сервер

Сервер может быть вот таким:

Void server(uint16_t port) {
    auto ex = co_await asio::this_coro::executor;
    
    for (Acceptor acc(ex, {{}, port});;)
        co_spawn(ex, echo_data(co_await acc.async_accept()), detached);
}

Конечно, нам нужно реализовать echo_data:

Void echo_data(Socket s) {
    asio::streambuf buf;
    co_await async_read_until(s, buf, FRAME);
    auto request = from_frame<ApplicationData>(buf);

    std::cout << "server echo to " << s.remote_endpoint() << ", " << request << std::endl;
    co_await async_write(s, as_frame(request, buf));
}

Клиент

Теперь пришло время написать код клиента:

Void client(uint16_t port, ApplicationData const data) {
    auto ex = co_await asio::this_coro::executor;
    Socket s(ex);
    co_await s.async_connect({{}, port});

    asio::streambuf buf, received;
    co_await async_write(s, as_frame(data, buf));
    co_await async_read_until(s, received, FRAME);
    auto response = from_frame<ApplicationData>(received);
    std::cout << "client response " << response << std::endl;
    std::cout << "client roundtrip " << std::boolalpha << (response == data) << std::endl;
}

Чтобы разрешить отладочный вывод, мы добавили operator== и operator<< до ApplicationData:

bool operator==(ApplicationData const&) const = default;
friend std::ostream& operator<<(std::ostream& os, ApplicationData const& ad) {
    return os << fmt::format("{{ints:{} complex:{}}}", ad.ints, ad.map);
}

Полная демоверсия В прямом эфире на Coliru

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>

#include <boost/asio.hpp>
#include <iostream>
namespace asio = boost::asio;
using asio::detached;
using asio::ip::tcp;

#include <fmt/ranges.h>
using namespace std::literals;

struct ApplicationData {
    std::vector<int>              ints;
    std::map<std::string, double> map;

    void serialize(auto& ar, unsigned) { ar & ints & map; }
    bool operator==(ApplicationData const&) const = default;
    friend std::ostream& operator<<(std::ostream& os, ApplicationData const& ad) {
        return os << fmt::format("{{ints:{} complex:{}}}", ad.ints, ad.map);
    }
};

static constexpr auto FRAME = "FRAME_SEPARATOR"sv;
static inline auto& as_frame(auto const& data, asio::streambuf& buf) {
    std::ostream os(&buf);
    boost::archive::text_oarchive(os) << data;
    os << FRAME << std::flush;
    return buf;
}

template <typename T> static inline T from_frame(asio::streambuf& buf) {
    T obj;
    std::istream is(&buf);
    boost::archive::text_iarchive ia(is);
    ia >> obj;
    if (std::string frame; is >> frame && frame == FRAME)
        return obj;
    throw std::runtime_error("Stream error");
}

using Void     = asio::awaitable<void>;
using Acceptor = asio::use_awaitable_t<>::as_default_on_t<tcp::acceptor>;
using Socket   = asio::use_awaitable_t<>::as_default_on_t<tcp::socket>;

Void echo_data(Socket s) {
    asio::streambuf buf;
    co_await async_read_until(s, buf, FRAME);
    auto request = from_frame<ApplicationData>(buf);

    std::cout << "server echo to " << s.remote_endpoint() << ", " << request << std::endl;
    co_await async_write(s, as_frame(request, buf));
}

Void server(uint16_t port) {
    auto ex = co_await asio::this_coro::executor;
    
    for (Acceptor acc(ex, {{}, port});;)
        co_spawn(ex, echo_data(co_await acc.async_accept()), detached);
}

Void client(uint16_t port, ApplicationData const data) {
    auto ex = co_await asio::this_coro::executor;
    Socket s(ex);
    co_await s.async_connect({{}, port});

    asio::streambuf buf, received;
    co_await async_write(s, as_frame(data, buf));
    co_await async_read_until(s, received, FRAME);
    auto response = from_frame<ApplicationData>(received);
    std::cout << "client response " << response << std::endl;
    std::cout << "client roundtrip " << std::boolalpha << (response == data) << std::endl;
}

int main() {
    boost::asio::io_context ioc;
    co_spawn(ioc, server(2233), detached);
    co_spawn(ioc,
             client(2233, {{3, 4, 5}, {{"one third", 1. / 3}, {"one fourth", 1. / 4}}}),
             detached);
    co_spawn(ioc, client(2233, {{42}, {{"LtUaE^2", 1.764e3}}}), detached);

    ioc.run_for(3s);
}

При запуске с

g++ -std=c++20 -O2 -Wall -pedantic -pthread main.cpp -lfmt -lboost_serialization && ./a.out

Отпечатки

server echo to 127.0.0.1:57782, {ints:[3, 4, 5] complex:{"one fourth": 0.25, "one third": 0.3333333333333333}}
server echo to 127.0.0.1:57784, {ints:[42] complex:{"LtUaE^2": 1764}}
client response {ints:[3, 4, 5] complex:{"one fourth": 0.25, "one third": 0.3333333333333333}}
client roundtrip true
client response {ints:[42] complex:{"LtUaE^2": 1764}}
client roundtrip true