概念(Concepts)约束检查机制 ​

面试考点 ​

C++20 Concepts 是模板编程的重大革新。面试官通过这道题考察你是否理解概念的定义、requires 表达式的用法、约束的归入(subsumption)规则、以及 Concepts 相比 SFINAE 的优势。

核心概念 ​

Concepts 是编译期求值的谓词,用于约束模板参数。当约束不满足时,编译器给出清晰的错误信息,而不是像 SFINAE 那样产生难以理解的模板错误。约束检查发生在模板实例化之前。

基本示例 ​

cpp
#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 ​

特性ConceptsSFINAE
语法清晰直观晦涩复杂
错误信息直接说"不满足约束 X"大量模板错误堆栈
归入(重载选择)自动选择最具体的需要手动管理互斥条件
可组合性用 && 和 || 组合嵌套 enable_if 很痛苦
标准版本C++20C++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 的区别。