requires 表达式语法
什么是 requires 表达式
requires 表达式是 C++20 引入的一种编译期布尔表达式,用来检测一组操作、类型或约束是否对给定的模板参数合法。它是定义概念的核心工具,也可以直接用在 requires 子句中作为即席约束。
requires 表达式的求值结果是 bool:如果所有需求都满足,结果为 true;否则为 false。表达式内部的代码不会被实际执行,编译器只检查这些表达式是否"能编译通过"。
语法
requires (参数列表) {
需求序列;
}参数列表是可选的,用来声明假想的变量。这些参数不会被实际创建,只是为需求提供名字和类型。
需求序列由四种需求组成:简单需求、类型需求、复合需求、嵌套需求。
四种需求
| 需求类型 | 语法 | 检查内容 |
|---|---|---|
| 简单需求 | 表达式; | 表达式是否能编译通过 |
| 类型需求 | typename 类型名; | 类型是否存在 |
| 复合需求 | { 表达式 } noexcept -> 类型约束; | 表达式合法性 + noexcept + 返回类型 |
| 嵌套需求 | requires 布尔约束; | 额外的编译期布尔条件 |
基本示例
#include <iostream>
#include <concepts>
#include <string>
#include <vector>
#include <type_traits>
// ============================
// 示例1:简单需求——检查表达式合法性
// ============================
// 简单需求只检查表达式是否能编译,不求值,不检查返回类型
template<typename T>
concept Addable = requires(T a, T b) {
a + b; // 要求 a + b 是合法表达式
};
template<typename T>
concept Incrementable = requires(T a) {
++a; // 要求前置自增合法
a++; // 要求后置自增合法
};
template<Addable T>
T add(T a, T b) {
return a + b;
}
void simple_requirement_demo() {
std::cout << add(3, 4) << std::endl; // 7
std::cout << add(1.5, 2.5) << std::endl; // 4.0
std::cout << add(std::string("hi "), std::string("there")) << std::endl;
// vector<int> 不支持 + 运算,编译错误:
// add(std::vector<int>{}, std::vector<int>{});
}
// ============================
// 示例2:类型需求——检查嵌套类型是否存在
// ============================
template<typename T>
concept Container = requires {
typename T::value_type; // 必须有嵌套类型 value_type
typename T::iterator; // 必须有嵌套类型 iterator
typename T::size_type; // 必须有嵌套类型 size_type
};
template<Container T>
void print_container_info() {
std::cout << "value_type 大小: " << sizeof(typename T::value_type) << " 字节" << std::endl;
}
void type_requirement_demo() {
print_container_info<std::vector<int>>(); // 通过
print_container_info<std::string>(); // 通过
// print_container_info<int>(); // 编译错误:int 没有这些嵌套类型
}
// ============================
// 示例3:复合需求——检查返回类型
// ============================
// 复合需求语法:{ 表达式 } noexcept(可选) -> 类型约束(可选);
template<typename T>
concept EqualityComparable = requires(T a, T b) {
{ a == b } -> std::convertible_to<bool>; // == 返回值可转为 bool
{ a != b } -> std::convertible_to<bool>; // != 返回值可转为 bool
};
template<typename T>
concept Sizable = requires(T a) {
{ a.size() } -> std::convertible_to<std::size_t>; // 有 size() 方法且返回值兼容 size_t
};
template<typename T>
concept NoexceptMovable = requires(T a) {
{ std::move(a) } noexcept; // 移动操作不能抛异常
};
template<EqualityComparable T>
bool are_equal(const T& a, const T& b) {
return a == b;
}
void compound_requirement_demo() {
std::cout << std::boolalpha;
std::cout << "3 == 3: " << are_equal(3, 3) << std::endl; // true
std::cout << "hello == world: "
<< are_equal(std::string("hello"), std::string("world")) << std::endl; // false
}
// ============================
// 示例4:嵌套需求——附加编译期条件
// ============================
// 嵌套需求用 requires 关键字引入一个编译期布尔表达式
template<typename T>
concept SmallIntegral = requires {
requires std::is_integral_v<T>; // 必须是整数类型
requires sizeof(T) <= 4; // 大小不超过 4 字节
};
template<typename T>
concept SignedAndAddable = requires(T a, T b) {
a + b; // 简单需求:可以相加
requires std::is_signed_v<T>; // 嵌套需求:必须是有符号类型
};
template<SmallIntegral T>
void small_int_func(T value) {
std::cout << "小整数: " << value << std::endl;
}
void nested_requirement_demo() {
small_int_func(42); // int:4 字节,通过
small_int_func(short(10)); // short:2 字节,通过
// small_int_func(42LL); // long long:8 字节,不满足 sizeof <= 4
// small_int_func(3.14); // double:不是整数类型
}
// ============================
// 示例5:综合示例——所有四种需求
// ============================
template<typename T>
concept IterableContainer = requires(T c, typename T::iterator it) {
// 类型需求
typename T::value_type;
typename T::iterator;
// 简单需求
c.begin();
c.end();
c.size();
// 复合需求
{ c.begin() } -> std::same_as<typename T::iterator>;
{ c.size() } -> std::convertible_to<std::size_t>;
{ *it } -> std::convertible_to<typename T::value_type>;
// 嵌套需求
requires std::default_initializable<T>;
};
template<IterableContainer T>
void print_elements(const T& container) {
std::cout << "[ ";
for (const auto& elem : container) {
std::cout << elem << " ";
}
std::cout << "]" << std::endl;
}
void comprehensive_demo() {
std::vector<int> vec{1, 2, 3, 4, 5};
print_elements(vec);
std::string str = "hello";
print_elements(str);
}
int main() {
std::cout << "=== 简单需求 ===" << std::endl;
simple_requirement_demo();
std::cout << "\n=== 类型需求 ===" << std::endl;
type_requirement_demo();
std::cout << "\n=== 复合需求 ===" << std::endl;
compound_requirement_demo();
std::cout << "\n=== 嵌套需求 ===" << std::endl;
nested_requirement_demo();
std::cout << "\n=== 综合示例 ===" << std::endl;
comprehensive_demo();
return 0;
}requires 表达式 vs requires 子句
这两个都用 requires 关键字,但含义不同:
| 概念 | 位置 | 作用 |
|---|---|---|
| requires 表达式 | 概念定义中或作为布尔表达式 | 检测一组需求是否满足,返回 bool |
| requires 子句 | 模板声明或函数声明中 | 对模板参数施加约束 |
// requires 表达式:produces a bool
template<typename T>
concept C = requires(T a) { a + a; }; // requires(...) { ... } 是表达式
// requires 子句:constrains a template
template<typename T>
requires C<T> // requires C<T> 是子句
void f(T a) {}
// 两者结合(requires requires):
template<typename T>
requires requires(T a) { a + a; } // 第一个 requires 是子句,第二个是表达式
void g(T a) {}requires requires 这种"双重 requires"语法虽然合法,但可读性差。建议先定义命名概念,再用 requires 子句引用它。
适用场景
- 定义概念时描述类型必须满足的接口要求
- 检查类型是否有特定的成员函数、嵌套类型或运算符
- 约束返回类型——确保某个操作返回的类型符合预期
- 检查 noexcept 属性
- 组合多种不同层次的约束条件
常见问题
简单需求和复合需求什么时候该用哪个?
如果只需要检查表达式是否合法("能编译就行"),用简单需求。如果还需要检查返回类型或 noexcept 属性,用复合需求。
requires 表达式中的参数是真的变量吗?
不是。它们是"假想的"参数,只为了在需求中提供名字和类型,不会被实际构造或析构。
requires 表达式可以单独用在普通代码中吗?
可以。requires 表达式的结果是 bool,可以用在 if constexpr、static_assert 或任何需要编译期 bool 的地方:
if constexpr (requires(T a) { a.size(); }) {
// T 有 size() 方法
}复合需求的 -> 后面写什么?
写一个类型约束(concept),不能写具体类型。比如 -> std::same_as<int> 或 -> std::convertible_to<double>,而不是 -> int。
注意事项
- requires 表达式内部的代码不会被求值,只检查合法性
- 简单需求不能以
requires关键字开头(会被当成嵌套需求) - 复合需求的
->后面必须是概念(类型约束),不能是具体类型 - 参数列表不能有默认参数,不能以省略号结尾
requires requires语法虽合法但应尽量避免,优先定义命名概念- requires 表达式可以引用外层模板参数
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 10.0 |
| Clang | 10.0 |
| MSVC | 19.26 (VS 2019 16.6) |
总结
requires 表达式是 C++20 概念系统的基础构件,提供了四种需求来检测类型的各种属性:简单需求检查表达式合法性,类型需求检查嵌套类型是否存在,复合需求可以同时检查表达式合法性、noexcept 属性和返回类型约束,嵌套需求允许嵌入额外的编译期布尔条件。它们可以自由组合,用来描述从简单到复杂的各种类型要求。requires 表达式通常用在概念定义中,也可以直接用在 requires 子句或 if constexpr 中。掌握这四种需求的用法,就能灵活地为模板参数定义精确的约束条件。