在 C++20 标准中，Concepts 的引入彻底改变了模板编程的风格和可维护性。它们不仅让编译器在模板实例化时能够给出更精准的错误信息，还让代码更加自文档化。本文从概念的基本语法、使用场景、与 SFINAE 的关系，到实际项目中的最佳实践，逐步展开讨论。
一、Concept 的基本语法
template<typename T>
concept Integral = std::is_integral_v <T>;
template<Integral T>
T add(T a, T b) { return a + b; }上面代码声明了一个名为 Integral 的概念，要求类型 T 满足 `std::is_integral_v
在 C++20 标准中，协程（Coroutines）被正式纳入语言层面，为异步编程提供了更直观、更高效的方式。本文将从协程的基本概念、语法细节、实现机制以及实际应用场景进行系统阐述，并给出完整代码示例。
协程是一种轻量级的“挂起”和“恢复”函数。与线程不同，协程在同一线程中运行，切换成本极低，适合需要频繁切换执行状态的场景，例如网络 I/O、游戏循环、动画渲染等。
C++20 协程的核心在于 co_await、co_yield、co_return 三个关键字，以及 generator、task 等模板封装。协程的生命周期由awaiter对象管理，awaiter 定义了何时挂起、何时恢复、何时结束。
#include <coroutine>
#include <iostream>
struct Generator {
struct promise_type {
int current_value;
std::suspend_always yield_value(int value) {
current_value = value;
return {};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Generator get_return_object() {
return Generator{std::coroutine_handle <promise_type>::from_promise(*this)};
}
void return_void() {}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle <promise_type> handle;
explicit Generator(std::coroutine_handle <promise_type> h) : handle(h) {}
~Generator() { if (handle) handle.destroy(); }
bool next() {
if (!handle.done()) handle.resume();
return !handle.done();
}
int value() const { return handle.promise().current_value; }
};
Generator range(int start, int end) {
for (int i = start; i < end; ++i) {
co_yield i;
}
}#include <coroutine>
#include <iostream>
#include <future>
template<typename T>
struct Task {
struct promise_type {
T value;
std::exception_ptr eptr;
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return Task{std::coroutine_handle <promise_type>::from_promise(*this)};
}
void return_value(T v) { value = v; }
void unhandled_exception() { eptr = std::current_exception(); }
};
std::coroutine_handle <promise_type> handle;
explicit Task(std::coroutine_handle <promise_type> h) : handle(h) {}
~Task() { if (handle) handle.destroy(); }
T get() {
if (handle.promise().eptr) std::rethrow_exception(handle.promise().eptr);
return handle.promise().value;
}
};
Task <int> async_add(int a, int b) {
co_return a + b;
}C++20 协程本质上是对 state machine 的编译器支持。每个协程被编译成：
co_await、co_yield 的对象，决定挂起、恢复逻辑。编译器负责把 co_yield 生成 yield_value 调用，将 co_return 生成 return_value 调用，并在生成器中插入 initial_suspend 与 final_suspend 逻辑。
协程在 栈上 运行，只有 promise 对象在堆上。挂起时，调用者可以通过 std::coroutine_handle 控制恢复，保证切换成本几乎等同于普通函数调用。
在网络编程中，使用协程可避免回调地狱。示例代码：
#include <asio.hpp>
#include <iostream>
asio::awaitable <void> read_socket(asio::ip::tcp::socket& sock) {
std::array<char, 1024> buffer;
while (true) {
std::size_t n = co_await sock.async_read_some(asio::buffer(buffer), asio::use_awaitable);
std::cout << "Received: " << std::string(buffer.data(), n) << '\n';
}
}GUI 框架可以把 UI 更新包装成协程，使事件处理逻辑更直观。
async void animate() {
for (int frame = 0; frame < 60; ++frame) {
update_frame(frame);
co_await std::this_thread::sleep_for(std::chrono::milliseconds(16));
}
}协程用于实现脚本行为、状态机、路径规划等。其低切换成本使游戏逻辑更易维护。
co_yield 在极高性能路径。std::unique_ptr。编译器会在 final_suspend 之后自动销毁。promise_type::unhandled_exception 捕获，并在 get() 时 rethrow_exception。C++20 协程为语言带来了异步编程的新语义，既保持了 C++ 的高性能特性，又提供了更直观的控制流模型。随着标准化和库的成熟，协程将在网络、图形、游戏、嵌入式等领域发挥越来越重要的作用。希望本文能帮助你快速上手协程，并在项目中灵活运用。
C++17 引入了模板折叠表达式（template fold expressions），它让我们在编写变长模板函数时，能够更简洁、高效地对参数包进行操作。下面以“求和”为例，演示如何利用折叠表达式完成此任务，并说明其工作原理和使用场景。
在 C++11/14 中，如果想用递归方式对参数包进行求和，代码往往需要显式的递归函数和基准情形：
template<typename T>
T sum(T x) { return x; }
template<typename T, typename... Rest>
T sum(T first, Rest... rest) {
return first + sum(rest...);
}虽然能工作，但代码相对冗长，而且每一次递归都涉及到函数调用和模板实例化，效率稍低。
折叠表达式的核心形式：
(args op ...)(... op args)(args op ... op ...)op 可以是任何二元运算符，如 +, *, &&, || 等。
注意：折叠表达式只能用于参数包与二元运算符，不能直接与三元运算符结合。
template<typename... Args>
auto sum(Args... args) {
return (args + ...); // 左折叠，等价于 ((a + b) + c) + d ...
}template<>
int sum<>() { return 0; } // 空参数包时返回 0或者在函数内部使用 if constexpr 判断参数包是否为空。
折叠表达式会根据第一个参数的类型推断返回类型，但如果想让返回类型与任意参数类型一致，可显式指定：
template<typename T, typename... Rest>
T sum(T first, Rest... rest) {
return (first + ... + rest); // 先把 first 和 rest 组合成参数包
}此时返回类型为 T，即第一个参数的类型。
折叠表达式在编译期展开为一系列简单的加法指令，编译器可以很容易地进行常量折叠、寄存器分配等优化。与递归实现相比：
print()、max()、min() 等。template<typename... Args>
auto product(Args... args) {
return (args * ...); // 乘积折叠
}同样可以为空参数包提供默认值：
template<>
int product<>() { return 1; }模板折叠表达式是 C++17 中非常强大的特性之一，尤其适用于需要对可变参数做重复操作的场景。通过少量代码即可实现既简洁又高效的功能，让模板编程变得更加直观。建议在新项目中优先考虑使用折叠表达式，既能减少代码冗余，又能让编译器发挥更好的优化能力。
在 C++ 20 版本中，协程（coroutines）被正式纳入标准库，提供了一套完整而高效的异步编程模型。相比传统的回调或线程池，协程让异步代码更易读、易维护。本文将介绍协程的基本概念、关键类、常见使用场景，并提供一份可直接运行的示例代码，帮助你快速上手。
协程是一种轻量级的函数，它在执行过程中可以被暂停（co_await 或 co_yield），随后在需要时恢复。协程内部的状态会被保存在协程帧（coroutine frame）中，编译器会为协程生成一套隐藏的状态机。
co_await：等待一个 awaitable 对象完成，并在完成后恢复协程。co_yield：将一个值返回给调用者，挂起协程，等待下一次调用。co_return：返回一个最终值，结束协程。协程需要等待的对象必须满足 awaitable 接口。最常见的是 std::future、std::shared_future、std::promise 或自定义的 awaitable。awaitable 会产生一个 awaiter 对象，awaiter 必须提供 await_ready()、await_suspend()、await_resume() 三个成员。
C++ 20 标准库提供了一些协程相关的模板，简化了常见需求。
| 模板 | 作用 | 典型使用场景 |
|---|---|---|
| `std::generator | ||
| 用于实现可迭代的协程，支持co_yield` |
生成序列、懒加载 | |
| `std::task | ||
| 用于异步任务，支持co_return` |
IO、网络请求 | |
std::suspend_always / std::suspend_never |
简单的挂起策略 | 基础控制 |
std::experimental::generator |
早期实现，兼容旧编译器 | 兼容性 |
下面给出一个完整的协程实现示例：一个异步下载器，使用 std::task<std::string> 下载网页内容，并在下载完成后打印。我们通过自定义 simple_http_get 来模拟异步 HTTP 请求。
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>
#include <coroutine>
#include <experimental/generator>
#include <optional>
// 简单的 awaitable：模拟异步 HTTP GET
struct async_http_get {
std::string url;
std::optional<std::string> result;
struct awaiter {
async_http_get& self;
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> h) noexcept {
std::thread([this, h]() {
// 模拟网络延迟
std::this_thread::sleep_for(std::chrono::seconds(2));
self.result = "Content from " + self.url;
h.resume(); // 继续执行协程
}).detach();
}
std::string await_resume() const noexcept { return *self.result; }
};
awaiter operator co_await() { return { *this }; }
};
// 异步任务返回字符串
template<typename T>
struct task {
struct promise_type {
T value_;
std::exception_ptr eptr_;
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_value(T val) { value_ = std::move(val); }
void unhandled_exception() { eptr_ = std::current_exception(); }
task get_return_object() {
return task{ std::coroutine_handle <promise_type>::from_promise(*this) };
}
};
std::coroutine_handle <promise_type> coro_;
task(std::coroutine_handle <promise_type> h) : coro_(h) {}
task(task&& other) noexcept : coro_(std::exchange(other.coro_, {})) {}
~task() { if (coro_) coro_.destroy(); }
std::future <T> result() {
return std::async(std::launch::async, [this]() {
if (coro_.promise().eptr_) std::rethrow_exception(coro_.promise().eptr_);
return coro_.promise().value_;
});
}
};
// 协程函数：异步下载
task<std::string> download(const std::string& url) {
async_http_get req{ url };
std::string body = co_await req; // 等待下载完成
co_return body;
}
int main() {
auto fut = download("https://example.com").result();
std::cout << "Download started...\n";
std::cout << "Result: " << fut.get() << stdn::endl;
return 0;
}运行结果示例
Download started...
Result: Content from https://example.com该示例演示了：
async_http_get) 并实现 awaiter 接口。std::future 方式等待结果。co_yield 产生大量值时可考虑 std::generator，减少复制成本。promise_type 中使用 unhandled_exception() 捕获异常，并通过 std::future 传播。std::atomic 或互斥锁保护共享状态。cppcoro、folly 或 libuv 的协程实现，提供更丰富的 IO、网络、线程池支持。C++ 20 的协程为异步编程带来了更接近同步代码的可读性和维护性。掌握 awaitable 接口、标准库协程工具以及正确的错误处理策略，你就能在 C++ 项目中快速构建高效、可扩展的异步功能。欢迎在评论区分享你使用协程的经验或遇到的坑！
在 C++20 中，概念（Concepts）被引入为一种强大的工具，用于在模板参数中指定约束条件，从而在编译阶段进行更严格的类型检查。相比传统的 SFINAE（Substitution Failure Is Not An Error）技巧，概念提供了更清晰、更易维护的语法，并使得错误信息更具可读性。下面我们从概念的定义、实现方式以及实际应用三个角度，深入探讨如何在 C++20 模板化编程中利用概念来提升代码质量。
template<typename T>
concept Integral = std::is_integral_v <T>;
template<Integral T>
T add(T a, T b) {
return a + b;
}上例中，Integral 是一个概念，使用 `std::is_integral_v
正文：
随着网络编程的日益普及，传统的多线程或基于事件循环的设计模式已经无法满足高并发、低延迟的需求。C++20 引入的协程（co_await, co_yield, co_return）为编写高效、可读性强的异步代码提供了新的工具。本文将以实现一个简单的 HTTP 服务器为例，展示如何利用 C++20 协程构建轻量级网络服务，并探讨性能优化、错误处理和可扩展性。
| 概念 | 说明 |
|---|---|
std::coroutine_handle |
协程句柄，控制协程的执行 |
std::suspend_always / std::suspend_never |
协程暂停策略 |
| `awaitable | |
| ` | 自定义 awaitable 类型，包装异步操作 |
co_await |
等待 awaitable 完成 |
co_yield |
返回一个值给调用方（类似生成器） |
co_return |
结束协程并返回值 |
使用 epoll（Linux）或 kqueue（BSD/macOS）实现多路复用。为了与协程配合，提供一个 IOAwaiter：
struct IOAwaiter {
int fd;
int events;
std::coroutine_handle<> awaiting;
bool await_ready() noexcept { return false; }
void await_suspend(std::coroutine_handle<> h) noexcept {
awaiting = h;
// 注册到 epoll
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
}
void await_resume() noexcept { /* epoll 会唤醒协程 */ }
};awaitable<std::string> async_read(int fd, size_t n) {
std::string buf(n, '\0');
int bytes = 0;
while (bytes < static_cast<int>(n)) {
int ret = recv(fd, &buf[bytes], n - bytes, 0);
if (ret > 0) {
bytes += ret;
} else if (ret == 0) {
break; // 对方关闭
} else if (errno == EAGAIN) {
co_await IOAwaiter{fd, EPOLLIN};
} else {
throw std::system_error(errno, std::generic_category());
}
}
co_return buf;
}awaitable <void> handle_connection(int client_fd) {
try {
auto request = co_await async_read(client_fd, 4096);
std::string response = process_request(request); // 业务逻辑
co_await async_write(client_fd, response);
} catch (const std::exception& e) {
std::cerr << "Error: " << e.what() << '\n';
close(client_fd);
}
}int main() {
// 1. 创建 listening socket，非阻塞
int listen_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
bind(listen_fd, ...);
listen(listen_fd, SOMAXCONN);
// 2. epoll 句柄
epoll_fd = epoll_create1(0);
// 3. 注册监听 socket
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &listen_ev);
while (true) {
int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
for (int i = 0; i < n; ++i) {
if (events[i].data.fd == listen_fd) {
int client_fd = accept4(listen_fd, nullptr, nullptr, SOCK_NONBLOCK);
// 启动协程处理
handle_connection(client_fd);
} else {
// 已准备好的 socket，唤醒对应协程
auto h = /* 取出关联的 coroutine_handle */;
h.resume();
}
}
}
}try/catch 包裹业务代码，保证协程不被异常泄露。TimeoutAwaiter，在指定时间内无事件则返回错误。process_request 提升为可插拔模块，使用 std::function 或 std::any 传递上下文。std::async 与协程结合实现。C++20 协程为网络编程提供了高效、简洁的异步模型。通过以上示例，你可以快速搭建一个高性能的 HTTP 服务，并在此基础上扩展更多协议。未来随着标准库进一步完善（如 std::experimental::coroutine 的稳定化），协程将在 C++ 社区占据更加核心的地位。希望本文能为你在实际项目中使用 C++20 协程提供参考与启发。
类型擦除是一种编程技巧，用于隐藏模板参数的具体类型，从而实现对不同类型对象的统一接口。它在实现“任意类型容器”“类型无关接口”“多态”时非常有用。下面我们通过一个完整的例子，展示在C++17/20中实现类型擦除的步骤。
首先，定义一个抽象基类，声明我们想要的公共行为。例如，一个可以打印自身的接口：
struct Printable {
virtual ~Printable() = default;
virtual void print() const = 0;
virtual std::unique_ptr <Printable> clone() const = 0; // 需要 clone 支持
};接下来，编写一个模板类 `TypeErased
`，把任意类型 `T` 适配到 `Printable` 接口。该包装器实现 `print()` 和 `clone()`。 “`cpp template class TypeErased : public Printable { public: explicit TypeErased(T value) : value_(std::move(value)) {} void print() const override { std::cout << value_ << '\n'; } std::unique_ptr clone() const override { return std::make_unique<typeerased>(*this); } private: T value_; }; “` > **注意**：为了让 `print()` 能直接输出 `value_`，要求 `T` 必须支持 `operator<<`。如果你想支持更复杂的行为，只需在 `TypeErased` 内部添加对应逻辑即可。 ### 3. 设计容器或包装类 现在可以用 `std::unique_ptr ` 存储任意类型对象： “`cpp class AnyPrintable { public: template AnyPrintable(T&& val) : ptr_(std::make_unique<typeerased<std::decay_t>>(std::forward(val))) {} void print() const { ptr_->print(); } AnyPrintable(const AnyPrintable& other) : ptr_(other.ptr_->clone()) {} AnyPrintable& operator=(const AnyPrintable& other) { if (this != &other) ptr_ = other.ptr_->clone(); return *this; } private: std::unique_ptr ptr_; }; “` ### 4. 使用示例 “`cpp int main() { AnyPrintable a = 42; // int AnyPrintable b = std::string(“hello”); // std::string AnyPrintable c = 3.14; // double a.print(); // 输出 42 b.print(); // 输出 hello c.print(); // 输出 3.14 // 复制 AnyPrintable d = a; d.print(); // 42 } “` ### 5. 进阶：支持更多接口 如果你想让类型擦除支持多种接口，可以让抽象基类继承自多个纯虚基类，或者使用 `std::variant` 结合类型擦除来实现多态。 “`cpp struct Drawable { virtual void draw() const = 0; }; struct Cloneable { virtual std::unique_ptr clone() const = 0; }; struct Any { std::unique_ptr d; std::unique_ptr c; // … }; “` ### 6. 性能与安全注意 – **内存分配**：每个 `AnyPrintable` 对象会产生一次堆分配。若性能敏感，可使用 `std::pmr::memory_resource` 或自定义分配器。 – **移动语义**：如果你的包装器不需要复制，可以删除 `clone()`，并提供移动构造/赋值，从而避免不必要的复制。 – **异常安全**：确保所有 `clone()` 实现都是 `noexcept` 或在需要时抛出异常。 ### 7. 小结 类型擦除使得 C++ 在保持类型安全的前提下，获得了类似动态语言的灵活性。通过抽象基类 + 模板包装器 + `std::unique_ptr`，可以轻松实现任意类型对象的统一接口。上述实现仅为一个最小可行例子，实际项目中可根据业务需求扩展更多功能。</typeerased<std::decay_t</typeerased在过去的 C++ 开发中，头文件（header files）一直是代码组织的核心，但它们也带来了不少问题：编译依赖过大、命名冲突、隐式导入、缺乏模块化语义等。C++20 引入的模块（Modules）正是针对这些痛点的解决方案。本文将从模块的概念、编译模型、语法使用以及实际应用场景四个方面，探讨 C++20 模块如何改变我们的编程习惯，并通过代码示例展示其实际效果。
module），在编译时会先生成模块接口文件（.ifc）和实现文件（.ixx），随后其他翻译单元可以直接导入这些接口，而不需要重复解析头文件。export 关键字显式声明哪些符号对外可见，减少不必要的全局暴露，增强代码安全性。| 传统头文件 | 模块化编译 |
|---|---|
每个源文件直接 #include 头文件 |
先编译模块接口文件生成 .ifc，随后源文件通过 import 引入 |
| 头文件可能被多次解析 | 只解析一次，生成二进制模块描述 |
| 编译器不区分接口与实现 | 明确分离，接口只含声明，实现隐藏在模块实现文件中 |
.ifc 或 .ixx）// math.ifx // 模块接口文件
module math; // 定义模块名
export module; // 导出整个模块
export int add(int a, int b) {
return a + b;
}.ixx）// math_impl.ixx // 模块实现文件
module math; // 同样使用模块名
int multiply(int a, int b) {
return a * b; // 未导出，默认不可见
}// main.cpp
import math; // 导入 math 模块
#include <iostream>
int main() {
std::cout << "3 + 5 = " << add(3, 5) << std::endl;
// std::cout << multiply(3, 5); // 错误：multiply 未被导出
return 0;
}# 使用 GCC 11+ 或 Clang 13+ 进行模块化编译
# 步骤 1：编译接口文件
g++ -std=c++20 -fmodules-ts -x c++-modules math.ifx -c -o math.ifc
# 步骤 2：编译实现文件
g++ -std=c++20 -fmodules-ts -x c++-modules math_impl.ixx -c -o math_impl.o
# 步骤 3：编译主程序并链接
g++ -std=c++20 -fmodules-ts main.cpp math.ifc math_impl.o -o demo现代编译器（如 MSVC）已经支持模块的编译，只需使用
-fmodules-ts或相应标志即可。
在大型项目中，头文件往往会被数百个翻译单元多次包含。通过模块化，只需一次编译产生 .ifc 文件，随后每个源文件仅需一次导入，编译时间可降至 30% 左右。
模块的命名空间与 C++ 的命名空间无关，但在同一个模块内的符号默认是可见的。通过 export 明确导出符号，可以避免全局暴露导致的冲突。
模块将接口与实现彻底分离，像库开发者可以将所有内部实现隐藏，只有 export 的函数或类对外公开。对于维护者来说，接口文件类似于 API 文档，而实现文件则是内部实现细节。
模块与预编译头文件（PCH）冲突
如果项目同时使用 PCH，建议将 PCH 用作模块接口，或者彻底切换到模块化。
跨平台编译
由于不同编译器对模块的支持进度不同，建议使用像 cmake 这样的构建系统统一编译流程。
第三方库的模块化
许多第三方库（如 Boost、Poco）正在逐步支持模块。使用时请确保库已编译为模块形式，否则仍需使用传统头文件。
模块重构成本
对现有代码进行模块化重构需要对文件依赖关系进行分析，建议先在小型子模块中尝试，再逐步扩展。
C++20 模块为我们提供了更清晰、更安全、更高效的代码组织方式。通过显式 export、一次性编译的二进制接口以及强大的命名空间管理，模块大幅提升了编译速度并减少了命名冲突。虽然初始学习成本略高，但随着编译器支持的完善，模块将成为未来 C++ 项目不可或缺的一部分。欢迎在实践中不断尝试，挖掘模块化带来的更大价值。
在 C++17 之前，模板编程的类型约束往往通过 SFINAE（Substitution Failure Is Not An Error）实现，导致代码既难以阅读又容易产生编译错误。C++20 引入了 Concepts，一种在编译期对类型进行约束的语法，彻底改变了我们编写泛型代码的方式。本文将从概念的基本语法、实战案例以及常见陷阱四个方面，全面剖析 Concepts 的应用价值与实现细节。
Concepts 本质上是对类型约束的一种声明，类似于接口，但更轻量。它们让编译器在模板参数满足某些条件时才能实例化，且错误信息更易读。Concepts 的核心语法如下：
template<typename T>
concept ConceptName = /* boolean constant expression */;例如：
template<typename T>
concept Incrementable = requires(T a) {
{ ++a } -> std::same_as<T&>;
{ a++ } -> std::same_as <T>;
};上述 Incrementable Concept 判断类型 T 是否支持前置和后置递增操作。
template<Incrementable T>
T add_one(T value) {
return ++value;
}如果你尝试传递 std::string 给 add_one，编译器会给出“Concept Incrementable not satisfied”之类的错误，而不是隐晦的 SFINAE 失效。
C++20 允许使用逻辑运算符组合概念：
template<typename T>
concept Arithmetic = std::integral <T> || std::floating_point<T>;
template<Arithmetic T>
T multiply(T a, T b) {
return a * b;
}这样，multiply 只能接收整数或浮点数。
假设你想实现一个简化版本的哈希表，要求键类型必须是可比较且可哈希。使用 Concepts 可以做到：
#include <type_traits>
#include <unordered_map>
template<typename K>
concept HashableKey = requires(K a, K b) {
{ a == b } -> std::convertible_to <bool>;
{ std::hash <K>{}(a) } -> std::convertible_to<std::size_t>;
};
template<HashableKey K, typename V>
class SimpleMap {
public:
void insert(const K& key, const V& value) {
data_[key] = value;
}
V get(const K& key) const {
return data_.at(key);
}
private:
std::unordered_map<K, V> data_;
};此代码在编译期确保 K 既可比较又可哈希，从而避免了在使用 std::unordered_map 时出现的未定义行为。
Concepts 需要 C++20 兼容编译器支持（如 GCC 10+、Clang 11+、MSVC 16.10+）。开启 -std=c++20 或对应编译器标志即可。若使用旧编译器，最好用 -fconcepts 或等效选项开启实验性支持。
| 陷阱 | 说明 | 解决方案 |
|---|---|---|
| 概念与模板实例化顺序 | 若概念内部使用未定义的类型或概念，编译错误可能混乱 | 确保概念定义顺序正确，必要时使用 typename 或 requires 提前声明 |
| 概念误用导致编译失败 | 在不需要约束的位置写了概念，导致误报错误 | 仅在真正需要约束的函数/类上使用 Concepts |
| 可见性问题 | 在别名模板或类模板内部使用概念时未显式指定概念 | 通过 requires 子句或 ConceptName T 明确约束 |
Concepts 使 C++ 模板编程更加安全、易读、易维护。它们把类型约束提升到语言层面，避免了传统 SFINAE 的“隐式错误”问题。随着更多库（如 ranges、parallelism）对 Concepts 的广泛使用，掌握这门新语法已成为现代 C++ 开发者的必备技能。下一步，你可以尝试将 Concepts 与 std::ranges 结合，构建更通用、类型安全的算法库。祝你编码愉快！
在 C++17 之后，std::variant 成为处理多类型值的一种强大工具。它是一个类型安全的联合（union），类似于 std::optional，但可以容纳多种类型。本文将从基本语法、常用成员函数、与传统 std::variant 的区别、以及实际应用场景进行详细阐述，帮助你在项目中高效使用 std::variant。
#include <variant>
#include <iostream>
#include <string>
using Result = std::variant<int, double, std::string>;
int main() {
Result r = 42; // 初始化为 int
std::cout << std::get<int>(r) << '\n';
r = std::string("Hello"); // 切换为 string
std::visit([](auto&& arg){ std::cout << arg << '\n'; }, r);
}std::variant<Ts...>：接受一个或多个类型参数。| 函数 | 说明 |
|---|---|
value() |
访问当前类型值；若类型不匹配则抛出 std::bad_variant_access。 |
value_or() |
若当前类型不是所请求的，返回默认值。 |
index() |
返回当前持有的类型索引（从 0 开始）。 |
| `holds_alternative | |
()| 判断是否持有T` 类型。 |
|
| `emplace | |
(args…)| 直接构造T` 并替换当前值。 |
|
operator= |
赋值或移动操作。 |
swap() |
与另一个 variant 交换内容。 |
小技巧：在访问时使用 `std::get_if
(&variant)` 可以获得指针，避免异常抛出。
std::any 的区别| 特点 | std::variant |
std::any |
|---|---|---|
| 类型安全 | 在编译期检查；只能是指定类型 | 运行时检查 |
| 性能 | 小且常量时间 | 动态分配 |
| 用途 | 用于已知有限类型集合 | 用于任意类型 |
当你需要处理一组已知类型的值时，优先使用
std::variant。
union MyUnion {
int i;
double d;
std::string s; // 不能使用非平凡类型
};std::variant 内部维护了类型信息，避免了错误的类型访问。using Arg = std::variant<int, std::string, bool>;
std::map<std::string, Arg> config;
config["threads"] = 4;
config["verbose"] = true;
config["output"] = std::string("log.txt");struct MouseEvent { int x, y; };
struct KeyEvent { char key; };
using Event = std::variant<MouseEvent, KeyEvent>;
void handleEvent(const Event& e) {
std::visit([](auto&& event){
using T = std::decay_t<decltype(event)>;
if constexpr (std::is_same_v<T, MouseEvent>)
std::cout << "Mouse at (" << event.x << ',' << event.y << ")\n";
else if constexpr (std::is_same_v<T, KeyEvent>)
std::cout << "Key pressed: " << event.key << '\n';
}, e);
}struct Literal { double value; };
struct Add { std::shared_ptr <Expr> left, right; };
using Expr = std::variant<Literal, Add>;
double evaluate(const Expr& expr) {
return std::visit([](auto&& node){
using T = std::decay_t<decltype(node)>;
if constexpr (std::is_same_v<T, Literal>)
return node.value;
else if constexpr (std::is_same_v<T, Add>)
return evaluate(*node.left) + evaluate(*node.right);
}, expr);
}index() 的返回值从 0 开始，可能导致误解。最好使用 `holds_alternative
()`。std::visit 的类型擦除会产生函数指针开销。可以使用 std::visit 的函数指针表或 std::variant_alternative_t 手动实现。struct，请确保 struct 具有默认构造、复制、移动构造。std::variant 是 C++17 之后处理多态值的首选工具。它提供了类型安全、性能友好、易于使用的接口，能够替代传统联合和 std::any。掌握其基本语法、成员函数以及常见的使用模式后，你可以在项目中大幅提升代码的可维护性和安全性。希望本文能帮助你快速上手并充分利用 std::variant 的优势。