使用 C++20 Modules 导入 Boost 模块的方法

我的项目案例地址：https://github.com/yudaichen/coroutine_blog

引言

C++20 引入的 Modules 特性为 C++ 开发带来了诸多好处，如加快编译速度、减少头文件重复包含等问题。Boost 作为一个广泛使用的 C++ 库集合，包含了许多强大的工具和库，例如 Boost.Asio、Boost.Beast、Boost.Redis 和 Boost.JSON。本文将详细介绍如何使用 C++20 Modules 导入这些 Boost 模块。

环境准备

在开始之前，你需要确保以下几点：

1. 编译器支持：使用支持 C++20 Modules 的编译器，例如 GCC 10 及以上版本、Clang 12 及以上版本。
2. CMake 支持：CMake 版本需要在 3.20 及以上，因为 CMake 3.20 开始对 C++20 Modules 有更好的支持。
3. Boost 库安装：确保已经正确安装了 Boost 库，并且可以被编译器找到。你可以从 Boost 官方网站 下载源码并进行编译安装。

项目结构

首先，我们创建一个简单的项目结构，如下所示：

project/
├── CMakeLists.txt
├── main.cpp

配置 CMakeLists.txt

在 CMakeLists.txt 文件中，我们需要进行一些配置以支持 C++20 Modules 和 Boost 库。以下是一个示例：

cmake_minimum_required(VERSION 3.20)
project(BoostModuleExample)# 设置 C++ 标准为 C++20
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)# 查找 Boost 库
find_package(Boost REQUIRED COMPONENTS asio beast redis json)# 添加可执行文件
add_executable(BoostModuleExample main.cpp)# 链接 Boost 库
target_link_libraries(BoostModuleExample PRIVATE Boost::asio Boost::beast Boost::redis Boost::json)# 设置编译器选项以支持 Modules
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")target_compile_options(BoostModuleExample PRIVATE -fmodules-ts)
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")target_compile_options(BoostModuleExample PRIVATE -fmodules -fcxx-modules)
endif()

代码解释：

1. find_package：用于查找 Boost 库，并指定需要的组件，这里包括 asio、beast、redis 和 json。
2. target_link_libraries：将 Boost 库链接到可执行文件中。
3. target_compile_options：根据不同的编译器，设置相应的编译选项以支持 C++20 Modules。

使用 C++20 Modules 导入 Boost 模块

实现boost.ixx

// boost.ixx
module; // 全局模块片段/*#include <boost/asio.hpp>*/
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/thread_pool.hpp>
#include <boost/asio/static_thread_pool.hpp>
#include <boost/asio/as_tuple.hpp>
#include <boost/asio/signal_set.hpp>
#include <boost/asio/awaitable.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ip/udp.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/asio/use_awaitable.hpp>// 引入 Boost.Beast 头文件
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/version.hpp>
#include <boost/beast/websocket.hpp>// 引入 Boost.MySQL 头文件
#include <boost/mysql.hpp>
#include <boost/mysql/connection.hpp>
#include <boost/mysql/handshake_params.hpp>
#include <boost/mysql/results.hpp>// 引入 Boost.Redis 头文件
#include <boost/redis.hpp>
#include <boost/redis/connection.hpp>
#include <boost/redis/request.hpp>
#include <boost/redis/response.hpp>// 引入 Boost.json 头文件
#include <boost/json/array.hpp>
#include <boost/json/object.hpp>
#include <boost/json/parse.hpp>
#include <boost/json/serialize.hpp>export module boost;// ==================== 主命名空间 ====================
export namespace asio {
// --- 核心组件导出 ---
using boost::asio::any_completion_executor;
using boost::asio::any_io_executor;
using boost::asio::async_connect;
using boost::asio::awaitable;
using boost::asio::bad_executor;
using boost::asio::buffer;
using boost::asio::cancellation_signal;
using boost::asio::cancellation_slot;
using boost::asio::cancellation_state;
using boost::asio::cancellation_type;
using boost::asio::co_spawn;
using boost::asio::connect;
using boost::asio::coroutine;
using boost::asio::deferred;
using boost::asio::detached;
using boost::asio::detached_t;
using boost::asio::dynamic_buffer;
using boost::asio::execution_context;
using boost::asio::executor;
using boost::asio::executor_arg_t;
using boost::asio::invalid_service_owner;
using boost::asio::io_context;
using boost::asio::multiple_exceptions;
using boost::asio::post;
using boost::asio::service_already_exists;
using boost::asio::socket_base;
using boost::asio::static_thread_pool;
using boost::asio::steady_timer;
using boost::asio::system_context;
using boost::asio::system_executor;
using boost::asio::thread_pool;
using boost::asio::ip::address;using boost::asio::append;
using boost::asio::as_tuple;
using boost::asio::async_compose;
using boost::asio::bind_cancellation_slot;
using boost::asio::cancel_after;
using boost::asio::consign;
using boost::asio::default_completion_token_t;
using boost::asio::detached;
using boost::asio::enable_terminal_cancellation;
using boost::asio::enable_total_cancellation;
using boost::asio::make_strand;
using boost::asio::signal_set;// --- 错误处理子命名空间 ---
namespace error {
using boost::asio::error::make_error_code;
}// --- 协程相关子命名空间 ---
namespace this_coro {BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::this_coro::cancellation_state_t cancellation_state;
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::this_coro::executor_texecutor;
// using boost::asio::this_coro::cancellation_state;
// using boost::asio::this_coro::executor;
using boost::asio::this_coro::reset_cancellation_state;
using boost::asio::this_coro::throw_if_cancelled;
} // namespace this_coro// ==================== 封装 use_awaitable ====================
#if defined(GENERATING_DOCUMENTATION)
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::use_awaitable_t<>use_awaitable;
#else
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::use_awaitable_t<>use_awaitable(0, 0, 0);
#endif// ==================== 网络支持 ====================
namespace net {
namespace ip {
address make_address(const std::string &str) {return boost::asio::ip::make_address(str);
}
} // namespace ip// --- TCP 协议实现 ---
namespace tcp {
using boost::asio::ip::tcp::socket::shutdown_send;// 使用 Boost.Asio 的 tcp 类
using protocol = boost::asio::ip::tcp;// 核心套接字类型
template <typename Protocol = protocol>
using basic_socket = boost::asio::basic_socket<Protocol>;template <typename Protocol = protocol>
using basic_socket_acceptor = boost::asio::basic_socket_acceptor<Protocol>;template <typename Protocol = protocol>
using basic_stream_socket = boost::asio::basic_stream_socket<Protocol>;template <typename Protocol = protocol>
using basic_resolver = boost::asio::ip::basic_resolver<Protocol>;// 预定义实例
using socket = basic_stream_socket<protocol>;
using acceptor = basic_socket_acceptor<protocol>;
using endpoint = boost::asio::ip::basic_endpoint<protocol>;
using resolver = basic_resolver<protocol>;
using resolver_query = boost::asio::ip::basic_resolver_query<protocol>;
using resolver_results = boost::asio::ip::basic_resolver_results<protocol>;// 工厂函数
inline socket make_socket(io_context &ctx) { return socket(ctx); }inline acceptor make_acceptor(io_context &ctx, const endpoint &ep) {acceptor a(ctx);a.open(ep.protocol());a.set_option(socket_base::reuse_address(true));a.bind(ep);a.listen();return a;
}// 增强操作函数
template <typename Protocol, typename... Args>
auto async_connect(basic_stream_socket<Protocol> &sock, Args &&...args) {return boost::asio::async_connect(sock, std::forward<Args>(args)...);
}// 封装 async_read_until
template <typename AsyncReadStream, typename DynamicBuffer,typename CompletionToken>
auto async_read_until(AsyncReadStream &stream, DynamicBuffer &&buffer,const std::string &delim, CompletionToken &&token) {return boost::asio::async_read_until(stream, std::forward<DynamicBuffer>(buffer), delim,std::forward<CompletionToken>(token));
}// 封装 async_write
template <typename AsyncWriteStream, typename ConstBufferSequence,typename CompletionToken>
auto async_write(AsyncWriteStream &stream, const ConstBufferSequence &buffers,CompletionToken &&token) {return boost::asio::async_write(stream, buffers,std::forward<CompletionToken>(token));
}// 导出 no_delay 选项
#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined no_delay;
#else
typedef boost::asio::detail::socket_option::boolean<BOOST_ASIO_OS_DEF(IPPROTO_TCP), BOOST_ASIO_OS_DEF(TCP_NODELAY)>no_delay;
#endif
} // namespace tcp// --- UDP 协议实现 ---
namespace udp {
using protocol = boost::asio::ip::udp;template <typename Protocol = protocol>
using basic_socket = boost::asio::basic_socket<Protocol>;template <typename Protocol = protocol>
using basic_endpoint = boost::asio::ip::basic_endpoint<Protocol>;using socket = basic_socket<protocol>;
using endpoint = basic_endpoint<protocol>;
} // namespace udp
} // namespace net// ==================== SSL/TLS 支持 ====================
namespace ssl {
using boost::asio::ssl::context;
using boost::asio::ssl::context_base;
using boost::asio::ssl::host_name_verification;
using boost::asio::ssl::stream;
using boost::asio::ssl::stream_base;
using boost::asio::ssl::verify_context;// SSL over TCP 特化类型
template <typename Protocol = net::tcp::protocol>
using ssl_socket = stream<net::tcp::basic_stream_socket<Protocol>>;// SSL 工厂函数
template <typename Protocol>
ssl_socket<Protocol>
make_ssl_socket(net::tcp::basic_stream_socket<Protocol> &sock, context &ctx) {return ssl_socket<Protocol>(std::move(sock), ctx);
}// SSL 错误处理
namespace error {
using boost::asio::ssl::error::make_error_code;
using boost::asio::ssl::error::stream_errors;
} // namespace error
} // namespace ssl
} // namespace asio// ==================== Boost.Beast 支持 ====================
export namespace beast {
// --- 核心组件导出 ---
using boost::beast::error_code;
using boost::beast::file_mode;
using boost::beast::flat_buffer;
using boost::beast::role_type;
using boost::beast::string_view;
using boost::beast::tcp_stream;using boost::beast::buffers_to_string;
using boost::beast::get_lowest_layer;// --- HTTP 支持 ---
namespace http {
using boost::beast::http::dynamic_body;
using boost::beast::http::empty_body;
using boost::beast::http::field;
using boost::beast::http::file_body;
using boost::beast::http::request;
using boost::beast::http::response;
using boost::beast::http::status;
using boost::beast::http::string_body;
using boost::beast::http::verb;
using boost::beast::http::basic_fields;
using boost::beast::http::request_parser;
// HTTP 工厂函数
template <typename Body = string_body,typename Fields = boost::beast::http::fields>
auto make_request(verb method, std::string target, unsigned version = 11) {return request<Body, Fields>(method, target, version);
}// HTTP 异步操作
template <typename Stream, typename Request, typename CompletionToken>
auto async_write(Stream &stream, Request &&req, CompletionToken &&token) {return boost::beast::http::async_write(stream, std::forward<Request>(req),std::forward<CompletionToken>(token));
}template <typename Stream, typename Request>
auto async_write(Stream &stream, Request &&req) {return boost::beast::http::async_write(stream, std::forward<Request>(req),asio::use_awaitable);
}template <typename Stream, typename Response, typename CompletionToken>
auto async_read(Stream &stream, flat_buffer &buffer, Response &res,CompletionToken &&token) {return boost::beast::http::async_read(stream, buffer, res,std::forward<CompletionToken>(token));
}template <typename Stream, typename Response>
auto async_read(Stream &stream, flat_buffer &buffer, Response &res) {return boost::beast::http::async_read(stream, buffer, res,asio::use_awaitable);
}
} // namespace http// --- WebSocket 支持 ---
namespace websocket {
using boost::beast::role_type;
using boost::beast::websocket::close_code;
using boost::beast::websocket::is_upgrade;
using boost::beast::websocket::request_type;
using boost::beast::websocket::response_type;
using boost::beast::websocket::stream;
using boost::beast::websocket::stream_base;// WebSocket 工厂函数
template <typename NextLayer>
auto make_websocket_stream(NextLayer &next_layer) {return stream<NextLayer>(next_layer);
}
} // namespace websocket// --- SSL 支持 ---
namespace ssl {
using boost::beast::ssl_stream;// SSL 工厂函数
template <typename Protocol>
auto make_ssl_stream(asio::net::tcp::basic_stream_socket<Protocol> &sock,asio::ssl::context &ctx) {return ssl_stream<asio::net::tcp::basic_stream_socket<Protocol>>(std::move(sock), ctx);
}
} // namespace ssl
} // namespace beast// ==================== Boost.MySQL 支持 ====================
export namespace mysql {
using boost::mysql::connection;
using boost::mysql::connection_pool;
using boost::mysql::datetime;
using boost::mysql::diagnostics;
using boost::mysql::error_code;
using boost::mysql::handshake_params;
using boost::mysql::pool_params;
using boost::mysql::pooled_connection;
using boost::mysql::results;
using boost::mysql::row_view;
using boost::mysql::ssl_mode;
using boost::mysql::statement;
using boost::mysql::tcp_ssl_connection;
using boost::mysql::with_params;// MySQL 工厂函数
inline auto
make_connection(connection<connection<boost::asio::ssl::stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp>>>>ctx) {return connection<tcp_ssl_connection>(std::move(ctx));
}// MySQL 异步操作
template <typename CompletionToken>
auto async_connect(connection<tcp_ssl_connection> &conn,const std::string &host, const std::string &user,const std::string &password, const std::string &database,CompletionToken &&token) {return conn.async_connect(host, user, password, database,std::forward<CompletionToken>(token));
}template <typename CompletionToken>
auto async_execute(connection<tcp_ssl_connection> &conn,const std::string &query, results &result,CompletionToken &&token) {return conn.async_execute(query, result,std::forward<CompletionToken>(token));
}
} // namespace mysql// ==================== Boost.Redis 支持 ====================
export namespace redis {
using boost::redis::connection;
using boost::redis::request;
using boost::redis::response;// Redis 工厂函数
inline auto make_connection(asio::io_context &ctx) { return connection(ctx); }// Redis 异步操作
template <typename CompletionToken>
auto async_execute(connection &conn, const request &req,boost::redis::response<boost::redis::ignore_t> &res,CompletionToken &&token) {return conn.async_exec(req, res, std::forward<CompletionToken>(token));
}
} // namespace redisexport namespace boost {
namespace json {
using boost::json::array;
using boost::json::object;
using boost::json::parse;
using boost::json::serialize;
using boost::json::value;
} // namespace json
} // namespace boost

代码解释：

1. import 语句：使用 import 语句导入 Boost 模块，这样可以避免传统头文件包含的一些问题。
2. 使用 Boost 库：在 main 函数中，我们演示了如何使用 Boost.Asio 和 Boost.JSON 库。

注意事项

1. 模块可用性：确保你安装的 Boost 版本支持 C++20 Modules，有些较旧的版本可能不支持。
2. 编译选项：不同的编译器对 C++20 Modules 的支持可能有所不同，需要根据实际情况调整编译选项。

总结

通过使用 C++20 Modules 导入 Boost 模块，我们可以提高编译效率，减少头文件重复包含带来的问题。同时，利用 Boost 库丰富的功能，我们可以更高效地开发 C++ 应用程序。希望本文能帮助你顺利使用 C++20 Modules 导入 Boost 模块。

以上就是使用 C++20 Modules 导入 Boost 模块的详细方法，如果你在实践过程中遇到任何问题，欢迎在评论区留言讨论。

我的项目案例地址：https://github.com/yudaichen/coroutine_blog