【C++网络编程】第6篇：Boost.Asio介绍

前置

跨平台C++包管理利器vcpkg完全指南
官方文档：Boost.Asio Official Docs

一、Boost.Asio简介

1. 什么是Boost.Asio？

跨平台网络库：提供异步I/O模型，支持TCP/UDP/串口等协议。
​核心优势：

• 基于事件驱动的异步模型，高性能。
• 简化多线程并发编程。
• 支持C++20协程（Coroutines TS），代码更简洁。

2. 适用场景

• 高并发服务器（如游戏后端、实时通信）。
• 需要跨平台支持（Windows/Linux/macOS）。

---

二、环境配置

1. 安装Boost库（通过vcpkg）

# 安装Boost.Asio及其依赖
vcpkg install boost-asio:x64-windows

# 安装C++20协程支持（MSVC需2022 17.5+）
vcpkg install boost-coroutine:x64-windows

# 集成到系统目录
vcpkg integrate install

2. VS2022项目属性修改

---

三、核心概念与API

1. 核心类

• io_context：事件循环，驱动异步操作。
• ip::tcp::socket：TCP Socket封装。
• ip::tcp::acceptor：服务器端监听连接。
• steady_timer：定时器，用于超时控制。

2. 异步操作模式

• 回调函数：传统方式，需手动管理状态。
• 协程（C++20）​：用同步写法实现异步逻辑（推荐）。

---

四、实战示例

1. 异步TCP Echo服务器（C++20协程）

#include <boost/asio.hpp>
#include <boost/asio/experimental/awaitable_operators.hpp>
#include <iostream>

using namespace boost::asio;
using namespace boost::asio::experimental::awaitable_operators;
using ip::tcp;

awaitable<void> HandleClient(tcp::socket sock) {
    try {
        char data[1024];

        while (true) {
            // 每次循环创建新的定时器（生命周期绑定到当前循环）
            steady_timer timer(sock.get_executor());
            timer.expires_after(std::chrono::seconds(10));

            // 同时等待读操作和定时器
            auto result = co_await(
                sock.async_read_some(buffer(data), use_awaitable) ||
                timer.async_wait(use_awaitable)
                );

            // 处理结果
            if (result.index() == 1) { // 定时器触发
                std::cout << "Client timeout. Disconnecting." << std::endl;
                break;
            }

            // 处理数据读取
            size_t bytes_read = std::get<0>(result);
            co_await async_write(sock, buffer(data, bytes_read), use_awaitable);
        }
    }
    catch (const boost::system::system_error& e) {
        if (e.code() != error::operation_aborted) { // 过滤主动取消的警告
            std::cerr << "Client error: " << e.what() << std::endl;
        }
    }
    catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    // 确保关闭socket
    if (sock.is_open()) {
        boost::system::error_code ec;
        sock.shutdown(tcp::socket::shutdown_both, ec);
        sock.close(ec);
    }
}

awaitable<void> Listen(tcp::acceptor acceptor) {
    for (;;) {
        tcp::socket sock = co_await acceptor.async_accept(use_awaitable);
        std::cout << "New client: " << sock.remote_endpoint() << std::endl;
        co_spawn(acceptor.get_executor(), HandleClient(std::move(sock)), detached);
    }
}

int main() {
    try {
        io_context io_ctx;
        tcp::acceptor acceptor(io_ctx, { tcp::v4(), 8080 });
        co_spawn(io_ctx, Listen(std::move(acceptor)), detached);
        io_ctx.run();
    }
    catch (const std::exception& e) {
        std::cerr << "Fatal error: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}

2. 异步TCP Echo服务端（C++20协程）

#include <boost/asio.hpp>
#include <boost/asio/experimental/awaitable_operators.hpp>
#include <iostream>

using namespace boost::asio;
using namespace boost::asio::experimental::awaitable_operators;
using ip::tcp;

// 协程：客户端逻辑（接收 executor 作为参数）
awaitable<void> AsyncClient(any_io_executor executor) {
    try {
        tcp::socket sock(executor); // 使用传入的 executor 创建 socket

        // 连接到服务器
        co_await sock.async_connect(
            { ip::make_address("127.0.0.1"), 8080 }, use_awaitable);

        std::cout << "Connected to server." << std::endl;

        // 发送数据
        std::string message = "Hello Boost.Asio!";
        co_await async_write(sock, buffer(message), use_awaitable);
        std::cout << "Sent: " << message << std::endl;

        // 接收回显
        char response[1024];
        size_t bytes_read = co_await sock.async_read_some(buffer(response), use_awaitable);
        std::cout << "Received echo: " << std::string(response, bytes_read) << std::endl;

        // 关闭连接
        sock.shutdown(tcp::socket::shutdown_both);
        sock.close();
    }
    catch (const std::exception& e) {
        std::cerr << "Client error: " << e.what() << std::endl;
    }
}

int main() {
    try {
        io_context io_ctx;

        // 启动客户端协程（绑定到 io_context 的 executor）
        co_spawn(io_ctx, AsyncClient(io_ctx.get_executor()), detached);

        // 运行事件循环
        io_ctx.run();
    }
    catch (const std::exception& e) {
        std::cerr << "Main error: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}

3. 测试结果