使用 boost：：asio 库进行文件传输

您永远不会发送大小。你为什么会期望阅读它？send_file_contents

即使你这样做了，你也需要确保你以可移植的方式发送它（例如，考虑到字节序），例如使用

 using NetworkSize = boost::endian::big_uint64_t;

我会简化发送，并包括大小：

static std::vector<char> read_file(path const& fspec) {
    std::ifstream file(fspec, std::ios::binary);
    return std::vector<char>(std::istreambuf_iterator<char>(file), {});
}

void send_file_content_over_tcp(path const& fspec, tcp::socket& socket) {
    auto const contents = read_file(fspec);
    std::cout << "File read successfully. File size: " << contents.size() << " bytes." << std::endl;

    // Send the file content
    NetworkSize fileSize = contents.size();

    std::vector<asio::const_buffer> payload{
        asio::buffer(&fileSize, sizeof(fileSize)),
        asio::buffer(contents),
    };
    error_code ec;
    auto       n = write(socket, payload, ec);

    std::cout << "Content bytes sent: " << n << " (" << ec.message() << ")\n";
}

现在您可以完全对称地接收它：

void receive_file_content_over_tcp(path fspec, tcp::socket& socket) {
    error_code  ec;
    NetworkSize expected = 0;
    read(socket, asio::buffer(&expected, sizeof(expected)), ec);
    std::cout << "Expected file size: " << expected << " bytes (" << ec.message() << ")" << std::endl;

    if (!ec.failed()) {
        std::vector<char> data(expected);
        size_t actual = read(socket, asio::buffer(data), ec);

        std::cout << "Received " << actual << "/" << expected << ": " << ec.message();

        if (!ec || (actual == expected && ec == asio::error::eof)) {
            std::cout << "File content received successfully." << std::endl;
            std::ofstream(fspec, std::ios::binary | std::ios::trunc) //
                .write(data.data(), data.size());
        }
    }
}

这可以测试是否有效： 住在科里鲁

int main() {
    asio::io_context ioc;

    std::thread server([ex = ioc.get_executor()] {
        auto s = tcp::acceptor(ex, {{}, 7878}).accept();
        send_file_content_over_tcp("main.cpp", s);
    });

    ::sleep(1); // make sure server is accepting
    {
        tcp::socket client(ioc);
        client.connect({{}, 7878});
        receive_file_content_over_tcp("main-clone.cpp", client);
    }

    server.join();
}

印刷：

g++ -std=c++20 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
md5sum *.cpp
File read successfully. File size: 2265 bytes.
Content bytes sent: 2273 (Success)
Expected file size: 2265 bytes (Success)
Received 2265/2265: SuccessFile content received successfully.
d47f7c90dfe3ca271f81ca203d53798e  main-clone.cpp
d47f7c90dfe3ca271f81ca203d53798e  main.cpp

流

您的发送不是流媒体，所以我认为这并不重要。如果是，只需按块阅读：Live On Coliru

std::ofstream ofs(fspec, std::ios::trunc);
// ofs.exceptions(std::ios::badbit | std::ios::failbit);

for (std::array<char, 1024> buf; expected && !ec;) {
    size_t actual = read(socket, asio::buffer(buf), ec);
    assert(actual <= expected);

    std::cout << "Received " << actual << "/" << expected << ": " << ec.message() << "\n";
    ofs.write(buf.data(), actual);

    expected -= actual;
}
if (ofs.good() && expected == 0 && (!ec || ec == asio::error::eof))
    std::cout << "File content received successfully." << std::endl;

印刷

g++ -std=c++20 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
md5sum *.cpp
File read successfully. File size: 2342 bytes.
Content bytes sent: 2350 (Success)
Expected file size: 2342 bytes (Success)
Received 1024/2342: Success
Received 1024/1318: Success
Received 294/294: End of file
File content received successfully.
fc9f108bcee2fd7f711ab7a63d81baae  main-clone.cpp
fc9f108bcee2fd7f711ab7a63d81baae  main.cpp

怎么样？streambuf

它不是适合这项工作的工具。您当然应该对所有读取使用单个缓冲区。如果必须的话，我认为以下几点是不错的：

void receive_file_content_over_tcp(path fspec, tcp::socket& socket) {
    asio::streambuf buf;
    NetworkSize     expected = 0;

    error_code ec;
    auto       n = read(socket, buf, asio::transfer_exactly(sizeof(expected)), ec);
    std::memcpy(&expected, buf.data().data(), n);
    buf.consume(n);

    std::cout << "Expected file size: " << expected << " bytes (" << ec.message() << "), REMAINING "
              << buf.size() << std::endl;

    std::ofstream ofs(fspec, std::ios::trunc);
    // ofs.exceptions(std::ios::badbit | std::ios::failbit);

    while (expected && !ec) {
        size_t actual = read(socket, buf, asio::transfer_at_least(1024), ec);
        assert(actual <= expected);
        assert(buf.size() == actual);

        std::cout << "Received " << actual << "/" << expected << ": " << ec.message() << "\n";
        ofs << &buf;

        expected -= actual;
    }
    if (ofs.good() && expected == 0 && (!ec || ec == asio::error::eof))
        std::cout << "File content received successfully." << std::endl;
}