Cpp Concept
Concept 是 C++20 对模板参数的命名约束。它解决了模板编程的核心痛点：错误信息晦涩、约束表达隐式、SFINAE 代码难以维护。
1. 核心语法
template<typename T>
concept ConceptName = constraint_expression;定义示例：
template<typename T>
concept Addable = requires(T a, T b) {
a + b; // 表达式必须合法
};
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
template<typename T>
concept Container = requires(T c) {
typename T::value_type; // 必须有嵌套类型
c.begin(); // 必须有成员函数
c.end();
requires std::same_as<typename T::iterator, decltype(c.begin())>;
};2. 使用方式
四种等价写法：
// 1. 模板参数约束
template<Addable T>
T add(T a, T b) { return a + b; }
// 2. requires 子句（函数声明后）
template<typename T>
requires Addable<T>
T add(T a, T b) { return a + b; }
// 3. requires 子句（函数签名中）
template<typename T>
T add(T a, T b) requires Addable<T> { return a + b; }
// 4. 简写语法（constrained auto）
Addable auto add(Addable auto a, Addable auto b) { return a + b; }3. requires 表达式
requires 表达式有四种形式：
template<typename T>
concept Example = requires(T t, T::value_type v) {
// 1. 简单要求：表达式必须合法
t.size();
// 2. 类型要求：嵌套类型必须存在
typename T::value_type;
typename T::iterator;
// 3. 复合要求：表达式结果约束
{ t.begin() } -> std::same_as<typename T::iterator>;
{ t.empty() } -> std::convertible_to<bool>;
{ t.size() } noexcept -> std::same_as<size_t>;
// 4. 嵌套要求：约束组合
requires std::default_initializable<T>;
requires std::copy_constructible<T>;
};复合要求语法：{ expression } noexcept -> type-constraint;
noexcept可选，要求表达式不抛异常-> type-constraint要求表达式结果满足约束
4. 标准 Concept 分类
<concepts> 头文件提供四类约束：
类型关系
std::same_as<T, U> // T 和 U 是同一类型
std::derived_from<D, B> // D 公有继承自 B
std::convertible_to<From, To> // From 可隐式转换为 To
std::common_with<T, U> // T 和 U 有公共类型类型属性
std::integral<T> // 整型
std::floating_point<T> // 浮点型
std::is_pointer<T> // 指针
std::is_array<T> // 数组对象属性
std::regular<T> // 可拷贝、可比较、可默认构造
std::semiregular<T> // 可拷贝、可默认构造
std::trivially_copyable<T> // 可平凡拷贝可调用
std::invocable<F, Args...> // F 可以用 Args... 调用
std::regular_invocable<F, Args...> // 相等输入产生相等输出
std::predicate<F, Args...> // 返回可转换为 bool5. Subsumption（概念包含）
Concept 支持重载决议时的包含关系：更严格的 concept 优先匹配。
template<typename T>
concept Integral = std::integral<T>;
template<typename T>
concept SignedIntegral = Integral<T> && std::is_signed_v<T>;
// SignedIntegral 包含 Integral，更严格
// 调用 SignedIntegral 版本时，signed 类型优先匹配
template<Integral T>
void process(T x) { std::print("Integral\n"); }
template<SignedIntegral T>
void process(T x) { std::print("SignedIntegral\n"); }
process(42); // int 是 signed，输出 SignedIntegral
process(42u); // unsigned int，输出 Integral规则：当 concept A 的约束蕴含 concept B（A 更严格），则 A 包含 B。重载决议时，更严格的 concept 优先。
6. 错误信息对比
SFINAE 时代的错误（数百行模板展开）：
error: no match for 'operator<<' (operand types are 'std::ostream'
{aka 'std::basic_ostream<char>'} and 'std::vector<int>')
/usr/include/c++/13/ostream:108:7: note: candidate: ...
/usr/include/c++/13/ostream:117:7: note: candidate: ...
[... 50+ lines of template instantiation backtrace ...]Concept 时代的错误：
error: cannot bind non-const lvalue reference of type 'int&'
to an rvalue of type 'int'
note: constraints not satisfied
note: the required expression 't.size()' is invalid编译器直接告诉你哪个约束失败，而不是展开整个模板实例化链。
7. 与 SFINAE 对比
// SFINAE：晦涩、难以组合
template<typename T,
typename = std::enable_if_t<std::is_integral_v<T>>>
T multiply(T a, T b) { return a * b; }
// Concept：清晰、可组合
template<std::integral T>
T multiply(T a, T b) { return a * b; }
// SFINAE 组合多个约束：噩梦
template<typename T,
typename = std::enable_if_t<
std::is_integral_v<T> &&
std::is_copy_constructible_v<T>>>
void func(T);
// Concept 组合：自然
template<std::integral T>
requires std::copy_constructible<T>
void func(T);8. 实际应用
约束迭代器类型
template<typename T>
concept ForwardIterator = requires(T it) {
{ *it } -> std::same_as<typename T::reference>;
{ ++it } -> std::same_as<T&>;
{ it++ } -> std::same_as<T>;
requires std::equality_comparable<T>;
};
template<ForwardIterator It>
void advance(It& it, size_t n) {
while (n--) ++it;
}约束可序列化类型
template<typename T>
concept Serializable = requires(std::ostream& os, const T& obj) {
{ os << obj } -> std::same_as<std::ostream&>;
};
template<Serializable T>
void save(const T& obj, const std::filesystem::path& file) {
std::ofstream ofs(file);
ofs << obj;
}约束数值计算
template<typename T>
concept Arithmetic = std::integral<T> || std::floating_point<T>;
template<Arithmetic T>
constexpr T clamp(T value, T lo, T hi) {
return value < lo ? lo : (value > hi ? hi : value);
}9. 注意事项
1. Concept 是编译期约束
template<std::integral T>
void func(T x);
func(42); // OK
func(3.14); // 编译错误，不是运行时检查2. 约束不满足时的替代方案
// 使用 requires 选择不同实现
template<typename T>
requires std::integral<T>
T abs(T x) { return x < 0 ? -x : x; }
template<typename T>
requires std::floating_point<T>
T abs(T x) { return std::fabs(x); }3. 避免过度约束
// 不好：过度约束，限制了可用类型
template<typename T>
concept StrictContainer = requires(T c) {
{ c.size() } -> std::same_as<size_t>; // 太严格
};
// 好：宽松约束，更通用
template<typename T>
concept Container = requires(T c) {
{ c.size() } -> std::convertible_to<size_t>;
};4. Concept 与 auto 结合
// 简写语法
void process(std::integral auto x);
// 等价于
template<std::integral T>
void process(T x);10. 与 Ranges 库结合
Ranges 库大量使用 concept 约束算法：
#include <ranges>
#include <algorithm>
// std::ranges::sort 要求 random_access_range
std::vector<int> vec = {3, 1, 4, 1, 5};
std::ranges::sort(vec); // OK
std::list<int> lst = {3, 1, 4};
// std::ranges::sort(lst); // 编译错误：list 不满足 random_access_range
std::ranges::sort(std::views::take(vec, 3)); // OK常用 Ranges concept：
| Concept | 要求 |
|---|---|
range | 有 begin() 和 end() |
sized_range | size() 在常数时间返回 |
random_access_range | 支持常数时间随机访问 |
view | 可移动、常数时间构造/析构 |
11. 前置知识：typename 与嵌套类型
在模板中使用嵌套类型（如 T::iterator）时，必须使用 typename 关键字明确告诉编译器这是一个类型而非静态成员。
为什么需要 typename
当编译器遇到 T::iterator 这样的语法时，无法确定这是一个嵌套类型还是一个静态数据成员：
template<typename T>
void process(T container) {
T::iterator it; // 编译错误！iterator 是类型还是静态成员？
}编译器默认假设这是静态数据成员。使用 typename 消除歧义：
template<typename T>
void process(T container) {
typename T::iterator it; // 明确声明 iterator 是嵌套类型
}必须使用 typename 的场景
| 场景 | 示例 |
|---|---|
| 声明依赖类型的嵌套类型变量 | typename T::iterator it; |
| 类型别名声明 | using ValueType = typename T::value_type; |
| 函数返回类型 | typename T::value_type get(); |
| 模板参数传递 | std::same_as<typename T::iterator, It> |
| Concept 的复合要求 | { c.begin() } -> std::same_as<typename T::iterator>; |
什么是嵌套类型
嵌套类型（Nested Type） 是指在类（或结构体）内部定义的类型。
class Container {
public:
// 嵌套类型定义（四种方式）
using value_type = int; // 方式1：using 别名
typedef int* pointer; // 方式2：typedef 别名
struct iterator { /* ... */ }; // 方式3：内部类
enum class Status { Ok, Error }; // 方式4：内部枚举
};
// 使用嵌套类型
Container::value_type x; // 等同于 int x
Container::iterator it; // Container 内部的 iterator 类型
Container::Status s; // Container 内部的 Status 枚举与成员变量的区别：
class Container {
public:
using value_type = int; // 嵌套类型（类型别名）
static int count; // 静态成员变量（是变量，不是类型）
int size; // 普通成员变量
};
Container::value_type x; // OK：value_type 是类型
Container::count = 10; // OK：count 是静态变量Concept 中的两种 typename 用法
在 requires 表达式中，typename T::name 有两种含义：
1. 类型要求（检查嵌套类型存在）
template<typename T>
concept HasIterator = requires {
typename T::iterator; // 检查 T 内部是否定义了 iterator 这个类型
};2. 类型声明（使用嵌套类型）
template<typename T>
concept Container = requires(T c) {
// 使用 T::iterator 作为类型参与比较
{ c.begin() } -> std::same_as<typename T::iterator>;
};不需要 typename 的情况
- 非依赖类型（类型已知，不依赖模板参数）：
struct MyClass { using Inner = int; };
MyClass::Inner x; // 不需要 typename- 使用
auto推导（C++11 起）：
template<typename Container>
void process(const Container& c) {
auto it = c.begin(); // 编译器自动推导，无需显式声明
}典型编译错误
如果不使用 typename：
template<typename T>
void bad(T& c) {
T::iterator it = c.begin(); // 错误！
}错误信息：
error: need 'typename' before 'T::iterator' because 'T' is a dependent scope12. 总结
| 特性 | SFINAE | Concept |
|---|---|---|
| 语法 | 晦涩 | 清晰 |
| 错误信息 | 冗长 | 明确 |
| 组合性 | 困难 | 自然 |
| 重载决议 | 手动 | 自动（subsumption） |
Concept 不是语法糖，而是模板元编程范式的转变：从"类型替换失败不是错误"到"类型约束显式表达"。当你写模板时，先问自己：这个类型需要满足什么条件？然后用 concept 表达它。
Related Articles
2025-08-11
C++ Ranges 完全指南
1. 为什么需要 Ranges？ 在 C++20 之前，处理数据序列是这样的： // 传统 STL：冗长、易错 std::vector<int> nums = {1, 2, 3, 4, 5, 6}; std::vector<int> result; for (int n : nums) { if (n % 2 == 0) { result.push_back(n * n); } } // 或者用算法（更复杂） std::vector<int> result; std::copy_if(nums.begin(), nums.end(), std::back_inserter(result), [](int n) { return n % 2 == 0; }); std::transform(result.begin(), result.end(), result.begin(), [](int n) { return n * n...
2022-12-03
C++ namespace
C++命名空间是语言的核心特性之一，用于解决名字冲突问题，尤其在大项目或使用多个库时。基于最新C++23标准，命名空间用法稳定，但结合模块（modules）使用更高效。下面直击要害，逐一拆解，包括[inline namespace]、匿名命名空间和命名空间别名。 参考：[cppreference.com] 1. 基本用法：声明与定义 命名空间通过namespace关键字声明，内容可以分散在多个文件中定义（如同函数定义）。 namespace MyLib { int add(int a, int b) { return a + b; } class Widget { public: void use(); }; } 使用方式： 限定名：MyLib::add(1, 2); 最安全，避免污染全局。 using声明：using MyLib::add; 只引入add，作用域内可用add(1,2)。 using指令：using namespace MyLib; 引入整个空...
2025-08-02
C++ move_only_function
在C++中，std::move_only_function 是C++23引入的标准库功能，用于表示仅支持移动语义的函数对象（callable object）。它是std::function的变种，但与std::function不同的是，std::move_only_function不要求存储的函数对象是可拷贝的，仅要求可移动，从而支持更广泛的用例，例如存储只支持移动语义的对象（如std::unique_ptr或lambda表达式中的非可拷贝对象）。以下是对std::move_only_function的详细说明，包括其设计、用法、实现规则和注意事项。 1. 什么是 std::move_only_function？ std::move_only_function 是一个类模板，定义在 <functional> 头文件中，用于包装可调用对象（如函数指针、lambda表达式、仿函数等），并提供类型擦除（type erasure），使其可以存储不同类型的可调用对象，同时只要求这些对象支持移动构造和移动赋值，而不需要支持拷贝。它是C++23标准的一部分，旨在解决std::fun...
2025-08-17
C++ xxx_cast
在 C++ 中，提供了四种主要的类型转换操作符（cast），它们统称为 _cast 函数，用于在不同类型之间进行显式类型转换。这些操作符分别是 static_cast、dynamic_cast、const_cast 和 reinterpret_cast。它们取代了 C 风格的强制类型转换（如 (type)expression），提供了更安全、更清晰的类型转换方式。以下是对这四个 _cast 函数的详细讲解，包括它们的用途、语法、特点以及使用场景。 1. static_cast 定义 static_cast 是一种在编译时进行类型转换的操作符，用于执行相对安全的类型转换。它不会进行运行时类型检查，因此效率较高，但需要程序员确保转换的正确性。 语法 static_cast<目标类型>(表达式) 用途 基本数据类型转换：在内置类型之间进行转换，例如 int 到 float、指针类型之间的转换（在安全的情况下）。 类层次结构中的向上转换：将派生类指针或引用转换为基类指针或引用（这是安全的，因为派生类对象总是包含基类部分）。 调用显式构造函数或转换函数：用于调用用户定义的类型转换（...
2025-11-04
C++ std::print
1. 概述 C++23 引入了 std::print 和 std::println，这是现代 C++ 对格式化输出的重大改进。相比传统的 printf，这些新函数提供了类型安全、性能优异且易于使用的格式化输出方案。 2. 基本用法 简单输出 #include <print> int main() { // 基本输出 std::print("Hello, World!\n"); // 带换行的输出 std::println("Hello, World!"); return 0; } 格式化输出 #include <print> #include <string> int main() { int age = 25; std::string name = "Alice"; // 格式化输出 std::print("Name: {}, Age: {}\n", name, age); ...
2025-09-23
Cpp Asio
Asio 是一个跨平台的 C++ 库，用于网络和低级 I/O 编程，提供了一套异步操作的框架。Boost.Asio 是其最知名的版本，但独立（standalone）版本的 Asio 允许在不依赖 Boost 的情况下使用。 1. Asio 库概述 Standalone Asio 是一个轻量级的网络编程库，设计目标是提供高效、异步的 I/O 操作。它支持以下功能： 网络编程：TCP、UDP、ICMP 等协议的客户端和服务器开发。 异步 I/O：通过回调、协程（C++20 起支持）或 Future/Promise 模型处理异步操作。 跨平台：支持 Windows、Linux、macOS 等操作系统。 低级 I/O：文件操作、串口通信、定时器等。 与 Boost.Asio 相比，standalone Asio 不依赖 Boost 的其他组件（如 Boost.System），因此更轻量，适合需要减少依赖的场景。 2. 安装与配置 下载 Standalone Asio 可从 GitHub 或其官方网站（think-async.com）获取最新版本。下载后，解压到项目目录。 配置 头文...
