C++模板约束概念类型要求表达式语法-C++-PHP中文网

C++20 Concepts通过引入concept关键字和requires表达式，为模板参数提供清晰的编译期约束，取代了晦涩的SFINAE机制，使代码意图更明确、错误信息更友好，显著提升了模板代码的可读性与可维护性。

c++模板约束概念类型要求表达式语法

C++模板约束概念，也就是我们常说的C++20 Concepts，本质上是给模板参数加了一层“契约”或“类型要求”。它允许你在编译期明确地指定模板参数需要满足的条件，比如它必须支持某个操作、拥有某个成员类型，或者满足某个特定的概念。这套机制的核心在于

requires

登录后复制

表达式语法，它提供了一种强大且富有表现力的方式来描述这些要求。在我个人看来，Concepts的引入，是C++模板编程领域一次革命性的进步，它让模板代码的意图变得前所未有的清晰，也极大地改善了长期以来饱受诟病的模板错误信息问题。

解决方案

在C++20之前，我们为了约束模板参数，通常会依赖SFINAE（Substitution Failure Is Not An Error）机制，比如

std::enable_if

登录后复制

或

std::void_t

登录后复制

，但这套东西写起来冗长晦涩，错误信息也常常令人摸不着头脑。而Concepts的出现，就是为了解决这些痛点。

要理解C++模板约束，我们首先要掌握

concept

登录后复制

关键字和

requires

登录后复制

表达式。一个

concept

登录后复制

就是一个具名的、可重用的模板参数约束集。你可以这样定义一个：

立即学习“C++免费学习笔记（深入）”；

template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>; // 要求a+b是一个合法的表达式，并且结果类型与T相同
};

template <typename T>
concept Printable = requires(T t, std::ostream& os) {
    { os << t } -> std::same_as<std::ostream&>; // 要求T可被输出到流
};

登录后复制

这里，

requires(...) { ... }

登录后复制

就是

requires

登录后复制

表达式。它内部可以包含多种形式的要求：

简单要求 (Simple requirements): 只是检查一个表达式是否合法。

requires(T t) {
    t.foo(); // 要求T有一个名为foo的成员函数
    *t;      // 要求T可被解引用
};

登录后复制

类型要求 (Type requirements): 检查某个类型是否存在。

requires(T t) {
    typename T::value_type; // 要求T有一个名为value_type的嵌套类型
};

登录后复制

复合要求 (Compound requirements): 检查表达式的合法性、结果类型和noexcept属性。

requires(T t) {
    { t.get() } -> int;           // 要求t.get()合法，且结果类型可转换为int
    { t.data() } -> std::same_as<int&>; // 要求t.data()合法，且结果类型必须精确匹配int&
    { t.reset() } noexcept;       // 要求t.reset()合法，且必须是noexcept的
};

登录后复制

嵌套要求 (Nested requirements): 在一个

requires

登录后复制

表达式中引用另一个

concept

登录后复制

。

template <typename T>
concept MyComplexConcept = requires(T t) {
    requires Addable<T>; // 要求T满足Addable概念
    requires Printable<T>; // 要求T满足Printable概念
};

登录后复制

定义好

concept

登录后复制

之后，你就可以在模板参数列表或函数签名中使用它们来约束类型：

template <Addable T> // 在模板参数列表直接使用concept
T add(T a, T b) {
    return a + b;
}

void print_something(Printable auto p) { // C++20的简写模板语法，用concept约束auto
    std::cout << p << std::endl;
}

template <typename T>
    requires Addable<T> && Printable<T> // 在requires子句中使用concept组合
void process(T val) {
    std::cout << add(val, val) << std::endl;
}

登录后复制

这种显式的约束，让代码的意图一目了然。当传入不符合要求的类型时，编译器会给出清晰的错误信息，直接告诉你哪个概念的哪个要求没有被满足，而不是一堆SFINAE失败的内部实现细节。

C++20 Concepts如何提升模板代码的可读性和错误诊断能力？

说实话，这是Concepts最让我感到兴奋的地方。过去，写模板代码就像是在走钢丝，你不知道什么时候会因为某个类型不支持某个操作而导致编译失败，而且那错误信息，简直就是天书。比如，你试图对一个没有

operator+

登录后复制

的类型使用加法，SFINAE可能会给你一长串的模板实例化失败的日志，让你在茫茫多的类型推导细节里找问题。这不仅耗费精力，还极大地打击了开发者的积极性。

Concepts的引入，彻底改变了这种局面。它通过强制模板参数在编译时满足预定义的语义契约，将潜在的错误从运行时提前到了编译时，并且以一种极其友好的方式呈现出来。

考虑一个简单的例子：

// 传统方式，如果T不支持+，这里会SFINAE失败，错误信息可能很长
template <typename T>
auto sum_old(T a, T b) {
    return a + b;
}

// 使用Concepts
template <typename T>
concept HasPlusOperator = requires(T a, T b) {
    { a + b };
};

template <HasPlusOperator T>
T sum_new(T a, T b) {
    return a + b;
}

struct NoPlus {};

int main() {
    // sum_old(NoPlus{}, NoPlus{}); // 编译错误，错误信息可能很复杂
    sum_new(NoPlus{}, NoPlus{}); // 编译错误，错误信息清晰：'NoPlus' does not satisfy 'HasPlusOperator'
                               // the expression 'a + b' is not satisfied
}

登录后复制

你看，使用

sum_new

登录后复制

时，编译器会直接告诉你

NoPlus

登录后复制

类型没有满足

HasPlusOperator

登录后复制

这个概念，并且具体指出是

a + b

登录后复制

这个表达式没有被满足。这种直观的反馈，让问题的定位变得异常简单。它不再是关于编译器内部如何尝试实例化模板的细节，而是直接指向了你代码的语义意图。

这不仅仅是让错误信息好看那么简单，它还提升了代码的可读性。当我在阅读一个模板函数签名时，如果看到

template <Printable T>

登录后复制

，我立刻就知道这个

登录后复制

类型是需要支持流输出的。这比我去看函数体内部，或者去翻阅

std::enable_if

登录后复制

的复杂条件要高效得多。Concepts将模板参数的“期望行为”提升到了接口层面，让模板代码的“契约”变得透明化，从而极大地降低了理解和维护模板代码的认知负担。

理解C++

requires

登录后复制

表达式：从基础到高级语法详解

requires

登录后复制

表达式是Concepts的“心脏”，它定义了模板参数必须满足的实际条件。它的语法结构非常灵活，允许我们表达各种复杂的类型要求。

基础结构： 一个

requires

登录后复制

表达式通常由

requires

登录后复制

关键字、一个可选的参数列表（用于引入要测试的变量），以及一对花括号包围的要求列表组成。

requires (parameters) {
    // requirement-list
}

登录后复制

parameters

登录后复制

列表中的变量，其类型是

requires

登录后复制

表达式外部模板参数的类型。这些变量仅在

requires

登录后复制

表达式内部有效，用于测试表达式。

四种主要要求类型：

简单要求 (Simple Requirements): 这可能是最常见和最直观的要求。它只是简单地检查一个表达式是否是合法的。如果表达式合法，则该要求满足。
```
requires(T t) {
    t.size(); // 要求T有一个名为size()的成员函数
    ++t;      // 要求T支持前缀递增操作
};
```
登录后复制
这类要求不关心表达式的结果类型或其noexcept属性，只关心它是否能编译通过。
类型要求 (Type Requirements): 当我们需要检查一个类型是否具有特定的嵌套类型或别名时，就会用到它。
```
requires(T t) {
    typename T::value_type; // 要求T内部定义了名为value_type的类型
    typename T::iterator;   // 要求T内部定义了名为iterator的类型
};
```
登录后复制
这里
```
typename
```
登录后复制
是必须的，因为它告诉编译器
```
T::value_type
```
登录后复制
是一个类型名，而不是一个静态成员。
复合要求 (Compound Requirements): 这是最强大的要求形式，它不仅检查表达式的合法性，还可以进一步约束其结果类型和noexcept属性。语法是
```
{ expression } -> ReturnTypeConstraint;
```
登录后复制
或
```
{ expression } noexcept;
```
登录后复制
或
```
{ expression } -> ReturnTypeConstraint noexcept;
```
登录后复制
。
- 结果类型约束：
```
-> ReturnTypeConstraint
```
  登录后复制
```
ReturnTypeConstraint
```
  登录后复制
  可以是：
  - 一个类型名：表示表达式结果必须可以隐式转换为该类型。
```
{ a + b } -> int;
```
    登录后复制
    (结果可以转换为int)
  - ```
  std::same_as<U>
```
  登录后复制
  ：表示表达式结果类型必须与
```
  U
```
  登录后复制
  精确匹配。
```
  { a + b } -> std::same_as<T>;
```
  登录后复制
  (结果类型必须是T)
- ```
std::convertible_to<U>
```
    登录后复制
    ：表示表达式结果必须可以隐式转换为
```
U
```
    登录后复制
    。
```
{ a + b } -> std::convertible_to<T>;
```
    登录后复制
    (与直接写
```
-> T;
```
    登录后复制
    效果类似)
- Noexcept约束：
```
noexcept
```
  登录后复制
```
{ expr } noexcept;
```
  登录后复制
  要求
```
expr
```
  登录后复制
  必须是一个
```
noexcept
```
  登录后复制
  表达式。
```
{ expr } -> ReturnTypeConstraint noexcept;
```
  登录后复制
  结合了类型和noexcept约束。
```
requires(T t) {
    { t.get_value() } -> std::same_as<int>; // 要求t.get_value()返回int
    { t.write_data() } noexcept;           // 要求t.write_data()是noexcept的
    { t.calculate() } -> double noexcept;  // 要求t.calculate()返回double且是noexcept的
};
```
登录后复制
嵌套要求 (Nested Requirements): 允许你在一个
```
requires
```
登录后复制
表达式中包含另一个
```
requires
```
登录后复制
子句，或者直接引用一个已经定义好的
```
concept
```
登录后复制
。
```
requires(T t) {
    requires std::integral<T>; // 要求T满足标准库的integral概念
    requires requires(T other) { // 嵌套的requires表达式
        { t == other } -> bool;
    };
};
```
登录后复制
这种嵌套可以用来构建更复杂的约束逻辑，或者将多个概念组合起来。

AiPPT模板广场
AiPPT模板广场-PPT模板-word文档模板-excel表格模板

147

查看详情

组合与逻辑操作： 多个要求可以通过

&&

登录后复制

（逻辑与）和

||

登录后复制

（逻辑或）进行组合，形成更复杂的条件。

template <typename T>
concept Arithmetic = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
    { a - b } -> std::same_as<T>;
    { a * b } -> std::same_as<T>;
    { a / b } -> std::same_as<T>;
};

template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>; // 使用逻辑或组合标准库概念

登录后复制

通过这些语法元素，

requires

登录后复制

表达式提供了一个非常强大且富有表现力的工具集，来精确地描述模板参数的语义需求。理解并熟练运用它们，是掌握C++20 Concepts的关键。

C++模板约束与传统SFINAE：何时选择以及如何迁移？

在我看来，C++20 Concepts的出现，基本宣告了传统SFINAE（Substitution Failure Is Not An Error）在模板约束领域的“退休”。虽然SFINAE在C++的历史中扮演了至关重要的角色，解决了许多类型检查和重载决议的问题，但它的复杂性和晦涩性也让无数C++开发者头疼不已。

何时选择Concepts？

答案很简单：几乎总是选择Concepts。

新代码： 对于任何新的C++20或更高版本的项目，毫无疑问应该优先使用Concepts。它们提供了清晰的语法、语义化的错误消息和更好的可读性，这些都是SFINAE无法比拟的。
重构现有代码： 如果你有机会重构旧的模板代码，特别是那些依赖
```
std::enable_if
```
登录后复制
、
```
std::void_t
```
登录后复制
或者复杂的特化来实现约束的部分，我强烈建议将其迁移到Concepts。这将显著提高代码的可维护性和可理解性。
表达意图： Concepts让你能够直接表达模板参数的“意图”或“契约”，而不是通过一些编译器的副作用（如SFINAE）来间接实现。这种显式性是代码质量的关键。
更好的重载决议： Concepts在重载决议中也扮演了更直接的角色，它们被视为模板参数的属性，可以帮助编译器更好地选择最匹配的模板特化。

何时SFINAE可能仍然出现？

虽然我极力推荐Concepts，但在某些特定场景下，你可能仍然会遇到或需要使用SFINAE：

维护旧代码库： 在那些尚未升级到C++20或因为历史原因无法升级的旧项目里，SFINAE仍然是主流的模板约束手段。
非常规的元编程技巧： 极少数情况下，SFINAE的某些高级元编程技巧可能无法直接通过Concepts完美复刻，但这通常是针对非常底层和复杂的编译器行为进行操作，对普通应用开发者来说非常罕见。

如何从SFINAE迁移到Concepts？

迁移过程通常涉及将SFINAE的条件逻辑转化为

concept

登录后复制

定义中的

requires

登录后复制

表达式。下面是一些常见的SFINAE模式及其Concepts等效：

std::enable_if

登录后复制

基于某个类型特性：

SFINAE:

template <typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void func(T t) { /* ... */ }

登录后复制

Concepts:

template <std::integral T> // 直接使用标准库概念
void func(T t) { /* ... */ }

// 或者自定义概念
template <typename T>
concept MyIntegral = std::is_integral_v<T>;

template <MyIntegral T>
void func(T t) { /* ... */ }

登录后复制

std::enable_if

登录后复制

基于成员函数存在：

SFINAE (通常结合

std::void_t

登录后复制

或自定义特化)：

template <typename T, typename = std::void_t<decltype(std::declval<T>().foo())>>
void func(T t) { /* ... */ }

登录后复制

Concepts:

template <typename T>
concept HasFoo = requires(T t) {
    t.foo(); // 简单要求即可
};

template <HasFoo T>
void func(T t) { /* ... */ }

登录后复制

std::enable_if

登录后复制

基于表达式的返回值类型：

SFINAE:

template <typename T, typename = std::enable_if_t<std::is_same_v<decltype(std::declval<T>().get()), int>>>
void func(T t) { /* ... */ }

登录后复制

Concepts:

template <typename T>
concept HasIntGetter = requires(T t) {
    { t.get() } -> std::same_as<int>; // 复合要求，精确匹配返回值
};

template <HasIntGetter T>
void func(T t) { /* ... */ }

登录后复制

迁移的关键在于识别SFINAE条件中试图表达的“类型要求”，然后用