requires 表达式语法 ​

什么是 requires 表达式 ​

requires 表达式是 C++20 引入的一种编译期布尔表达式,用来检测一组操作、类型或约束是否对给定的模板参数合法。它是定义概念的核心工具,也可以直接用在 requires 子句中作为即席约束。

requires 表达式的求值结果是 bool:如果所有需求都满足,结果为 true;否则为 false。表达式内部的代码不会被实际执行,编译器只检查这些表达式是否"能编译通过"。

语法 ​

cpp
requires (参数列表) {
    需求序列;
}

参数列表是可选的,用来声明假想的变量。这些参数不会被实际创建,只是为需求提供名字和类型。

需求序列由四种需求组成:简单需求、类型需求、复合需求、嵌套需求。

四种需求 ​

需求类型语法检查内容
简单需求表达式;表达式是否能编译通过
类型需求typename 类型名;类型是否存在
复合需求{ 表达式 } noexcept -> 类型约束;表达式合法性 + noexcept + 返回类型
嵌套需求requires 布尔约束;额外的编译期布尔条件

基本示例 ​

cpp
#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 子句模板声明或函数声明中对模板参数施加约束
cpp
// 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 的地方:

cpp
if constexpr (requires(T a) { a.size(); }) {
    // T 有 size() 方法
}

复合需求的 -> 后面写什么?

写一个类型约束(concept),不能写具体类型。比如 -> std::same_as<int> 或 -> std::convertible_to<double>,而不是 -> int。

注意事项 ​

  • requires 表达式内部的代码不会被求值,只检查合法性
  • 简单需求不能以 requires 关键字开头(会被当成嵌套需求)
  • 复合需求的 -> 后面必须是概念(类型约束),不能是具体类型
  • 参数列表不能有默认参数,不能以省略号结尾
  • requires requires 语法虽合法但应尽量避免,优先定义命名概念
  • requires 表达式可以引用外层模板参数

编译器支持情况 ​

编译器最低支持版本
GCC10.0
Clang10.0
MSVC19.26 (VS 2019 16.6)

总结 ​

requires 表达式是 C++20 概念系统的基础构件,提供了四种需求来检测类型的各种属性:简单需求检查表达式合法性,类型需求检查嵌套类型是否存在,复合需求可以同时检查表达式合法性、noexcept 属性和返回类型约束,嵌套需求允许嵌入额外的编译期布尔条件。它们可以自由组合,用来描述从简单到复杂的各种类型要求。requires 表达式通常用在概念定义中,也可以直接用在 requires 子句或 if constexpr 中。掌握这四种需求的用法,就能灵活地为模板参数定义精确的约束条件。