概念(Concepts)约束检查机制
面试考点
C++20 Concepts 是模板编程的重大革新。面试官通过这道题考察你是否理解概念的定义、requires 表达式的用法、约束的归入(subsumption)规则、以及 Concepts 相比 SFINAE 的优势。
核心概念
Concepts 是编译期求值的谓词,用于约束模板参数。当约束不满足时,编译器给出清晰的错误信息,而不是像 SFINAE 那样产生难以理解的模板错误。约束检查发生在模板实例化之前。
基本示例
#include <iostream>
#include <concepts>
#include <type_traits>
#include <string>
#include <vector>
// ============================
// 示例1:定义和使用概念
// ============================
// 用 concept 关键字定义概念
// 概念是一个编译期布尔谓词
template<typename T>
concept Numeric = std::is_arithmetic_v<T>;
// 四种使用概念约束模板参数的语法
// 语法1:requires 子句
template<typename T>
requires Numeric<T>
T add_v1(T a, T b) {
return a + b;
}
// 语法2:简写形式(类型约束)
template<Numeric T>
T add_v2(T a, T b) {
return a + b;
}
// 语法3:尾部 requires 子句
template<typename T>
T add_v3(T a, T b) requires Numeric<T> {
return a + b;
}
// 语法4:auto 参数约束
Numeric auto add_v4(Numeric auto a, Numeric auto b) {
return a + b;
}
void basic_demo() {
std::cout << add_v1(1, 2) << std::endl; // OK
std::cout << add_v2(1.5, 2.5) << std::endl; // OK
// add_v1(std::string("a"), std::string("b")); // 编译错误,清晰的约束失败信息
}
// ============================
// 示例2:requires 表达式
// ============================
// requires 表达式用于检测类型是否满足特定要求
template<typename T>
concept Printable = requires(T t) {
// 简单要求:表达式必须合法
std::cout << t;
};
template<typename T>
concept Container = requires(T c) {
// 简单要求:必须有 begin() 和 end()
c.begin();
c.end();
// 类型要求:必须有 value_type 成员类型
typename T::value_type;
// 复合要求:size() 返回值可转换为 std::size_t
{ c.size() } -> std::convertible_to<std::size_t>;
};
// 嵌套要求:在 requires 表达式中使用 requires 子句
template<typename T>
concept SizedContainer = requires(T c) {
requires Container<T>; // 必须满足 Container
requires (sizeof(T) > 0); // 编译期条件
{ c.empty() } -> std::same_as<bool>; // empty() 返回 bool
};
void requires_expr_demo() {
static_assert(Printable<int>);
static_assert(Printable<std::string>);
static_assert(Container<std::vector<int>>);
static_assert(!Container<int>); // int 不满足 Container
static_assert(SizedContainer<std::vector<int>>);
}
// ============================
// 示例3:约束的归入(Subsumption)
// ============================
// 概念可以组合,编译器用归入规则选择最具体的重载
template<typename T>
concept Movable = std::is_move_constructible_v<T>;
template<typename T>
concept Copyable = Movable<T> && std::is_copy_constructible_v<T>;
// Copyable 归入 Movable(Copyable 比 Movable 更严格)
// 当类型同时满足两个概念时,编译器选择更具体的
template<Movable T>
void process(T&& obj) {
std::cout << "Movable 版本" << std::endl;
}
template<Copyable T>
void process(T&& obj) {
std::cout << "Copyable 版本(更具体)" << std::endl;
}
void subsumption_demo() {
int x = 42;
process(x); // 选择 Copyable 版本(int 同时满足两个,但 Copyable 更具体)
// 如果有一个只能移动不能拷贝的类型
// process(std::make_unique<int>(42)); // 选择 Movable 版本
}
// ============================
// 示例4:标准库中的概念
// ============================
// std::integral:整数类型
// std::floating_point:浮点类型
// std::same_as<T, U>:T 和 U 是同一类型
// std::convertible_to<From, To>:From 可以转换为 To
// std::derived_from<Derived, Base>:Derived 继承自 Base
// std::invocable<F, Args...>:F 可以用 Args 调用
// std::regular:可拷贝、可默认构造、可比较
template<std::integral T>
T gcd(T a, T b) {
while (b != 0) {
T temp = b;
b = a % b;
a = temp;
}
return a;
}
void stdlib_concepts_demo() {
std::cout << gcd(12, 8) << std::endl; // 4
// gcd(1.5, 2.5); // 编译错误:double 不满足 std::integral
}
// ============================
// 示例5:Concepts vs SFINAE 对比
// ============================
// SFINAE 写法(晦涩)
template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void old_way(T value) {
std::cout << "SFINAE: " << value << std::endl;
}
// Concepts 写法(清晰)
template<std::integral T>
void new_way(T value) {
std::cout << "Concepts: " << value << std::endl;
}
// ============================
// 示例6:约束检查的时机
// ============================
/*
约束检查发生在以下时刻:
1. 模板实例化之前(不会产生模板体内的错误)
2. 重载决议时(选择最匹配的重载)
3. 偏特化选择时
检查顺序:
模板参数替换 -> 约束检查 -> 模板体实例化
如果约束不满足:
- 该候选从重载集中移除(类似 SFINAE)
- 但错误信息直接说"不满足约束 X",而不是一堆模板错误
*/
int main() {
std::cout << "=== 基本用法 ===" << std::endl;
basic_demo();
std::cout << "\n=== requires 表达式 ===" << std::endl;
requires_expr_demo();
std::cout << "所有 static_assert 通过" << std::endl;
std::cout << "\n=== 归入规则 ===" << std::endl;
subsumption_demo();
std::cout << "\n=== 标准库概念 ===" << std::endl;
stdlib_concepts_demo();
return 0;
}requires 表达式中的四种要求
| 要求类型 | 语法 | 检查内容 |
|---|---|---|
| 简单要求 | expr; | 表达式合法 |
| 类型要求 | typename T::type; | 类型存在 |
| 复合要求 | { expr } -> concept; | 表达式合法且返回类型满足概念 |
| 嵌套要求 | requires constraint; | 编译期约束为 true |
Concepts vs SFINAE
| 特性 | Concepts | SFINAE |
|---|---|---|
| 语法 | 清晰直观 | 晦涩复杂 |
| 错误信息 | 直接说"不满足约束 X" | 大量模板错误堆栈 |
| 归入(重载选择) | 自动选择最具体的 | 需要手动管理互斥条件 |
| 可组合性 | 用 && 和 || 组合 | 嵌套 enable_if 很痛苦 |
| 标准版本 | C++20 | C++11 |
常见问题
约束归入(subsumption)是怎么工作的?
编译器用布尔代数分析约束之间的关系。如果概念 A 的约束包含概念 B 的所有约束(A = B && 其他),则 A 归入 B,即 A 更具体。当类型同时满足 A 和 B 时,编译器选择 A。归入只在命名概念之间生效,直接写 std::is_xxx_v<T> 不参与归入。
requires 关键字有几种用法?
两种完全不同的用法:requires 子句(约束模板参数)和 requires 表达式(定义要求列表)。它们可以嵌套使用:requires requires(T t) { t.foo(); }。
Concepts 能完全替代 SFINAE 吗?
在大多数场景下可以。Concepts 更简洁、错误信息更好、支持归入。但在某些复杂的元编程场景中,SFINAE 和 enable_if 仍然有用。新代码推荐优先使用 Concepts。
适用场景
- 约束模板参数,替代 SFINAE
- 定义类型要求(接口约束)
- 重载决议中自动选择最匹配版本
- 库设计中的类型安全约束
注意事项
- 归入规则只对命名概念生效,直接写 type_traits 不参与归入
- requires 表达式中的表达式不会被求值,只检查合法性
- 概念定义必须在命名空间作用域
- 概念不能递归定义
- 概念不能被特化
总结
C++20 Concepts 通过编译期谓词约束模板参数,替代了 SFINAE 的大部分功能。requires 表达式可以检查表达式合法性、类型存在性、返回类型约束。归入规则让编译器自动选择最具体的重载。面试中要能写出概念定义和 requires 表达式、解释四种约束语法、说明归入规则的工作原理、以及和 SFINAE 的区别。