概念库 （自 C++20 起）

 

C++

编译器支持

独立和宿主式

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 （自 C++20 起）

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

概念库

核心语言概念 same_as (C++20) derived_from (C++20) convertible_to (C++20) common_reference_with (C++20) common_with (C++20) integral (C++20) signed_integral (C++20) unsigned_integral (C++20) floating_point (C++20) swappableswappable_with (C++20)(C++20) destructible (C++20) constructible_from (C++20) default_initializable (C++20)   move_constructible (C++20) copy_constructible (C++20) assignable_from (C++20)

比较概念 equality_comparableequality_comparable_with (C++20)(C++20) totally_orderedtotally_ordered_with (C++20)(C++20) 对象概念 movable (C++20) copyable (C++20) semiregular (C++20) regular (C++20) 可调用概念 invocableregular_invocable (C++20)(C++20) predicate (C++20) relation (C++20) equivalence_relation (C++20) strict_weak_order (C++20)

仅供展示的概念 boolean-testable  (C++20)

 

概念库提供了基本库概念的定义，这些概念可用于执行模板参数的编译时验证，并根据类型属性执行函数分派。这些概念为程序中的等式推理提供了基础。

标准库中的大多数概念都施加了语法和语义要求。据说，如果满足其语法要求，则标准概念是满足的；如果满足其语法要求并且还满足其语义要求（如果有），则标准概念是建模的。

通常，只有语法要求可以由编译器检查。如果程序的有效性或含义取决于模板参数序列是否对概念进行建模，并且概念已满足但未建模，或者如果在使用点未满足语义要求，则程序是非良构的，无需诊断。

等式保持

如果表达式在给定相等输入时产生相等的输出，则该表达式是等式保持的，其中

• 输入由其操作数组成（不一定使表达式在语义上有效），并且
• 输出由其结果以及表达式对操作数的所有修改（如果有）组成

其中，为方便措辞，其“操作数”是指其最大的子表达式，该子表达式由 id-表达式 或 std::move、std::forward 和 std::declval 的调用组成。

每个操作数的 cv 限定和值类别通过假设其类型中的每个模板类型参数都表示 cv 无限定的完整非数组对象类型来确定。

每个需要等式保持的表达式还必须是稳定的，也就是说，在没有对这些输入对象进行任何显式中间修改的情况下，使用相同的输入对象对其进行两次求值必须具有相等的输出。

除非另有说明，否则在 requires 表达式 中使用的每个表达式的 标准库概念 都需要是等式保持的，并且表达式的求值可能仅修改其非常量操作数。常量操作数不得修改。

在标准库中，以下概念允许具有非等式保持的 requires 表达式

• output_iterator
• indirectly_writable
• invocable
• weakly_incrementable
• range

隐式表达式变体

requires 表达式，对于某些常量左值操作数使用非修改表达式，也隐式地要求接受给定操作数的非常量左值或（可能常量）右值的表达式的附加变体，除非明确要求具有不同语义的此类表达式变体。

这些隐式表达式变体必须满足声明的表达式的相同语义要求。实现验证变体的语法的程度是未指定的。

template<class T>
concept C = requires(T a, T b, const T c, const T d)
{
    c == d;           // expression #1: does not modify the operands
    a = std::move(b); // expression #2: modifies both operands
    a = c;            // expression #3: modifies the left operand `a`
};
 
// Expression #1 implicitly requires additional expression variations that
// meet the requirements for c == d (including non-modification),
// as if the following expressions had been declared as well:
 
// ------ const == const ------- ------ const == non-const ---
//                                         c  ==           b;
//            c == std::move(d);           c  == std::move(b);
// std::move(c) ==           d;  std::move(c) ==           b;
// std::move(c) == std::move(d); std::move(c) == std::move(b);
 
// -- non-const == const ------- -- non-const == non-const ---
//           a  ==           d;            a  ==           b;
//           a  == std::move(d);           a  == std::move(b);
// std::move(a) ==           d;  std::move(a) ==           b;
// std::move(a) == std::move(d); std::move(a) == std::move(b);
 
// Expression #3 implicitly requires additional expression variations that
// meet the requirements for a = c
// (including non-modification of the second operand),
// as if the expressions a = b (non-constant lvalue variation)
// and a = std::move(c) (const rvalue variation) had been declared.
 
// Note: Since expression #2 already requires the non-constant rvalue variation
// (a == std::move(b)) explicitly, expression #3 does not implicitly require it anymore.
 
// The type T meets the explicitly stated syntactic requirements of
// concept C above, but does not meet the additional implicit requirements
// (i.e., T satisfies but does not model C):
// a program requires C<T> is ill-formed (no diagnostic required).
struct T
{
    bool operator==(const T&) const { return true; }
    bool operator==(T&) = delete;
};

标准库概念

定义于命名空间 std
核心语言概念
定义于头文件 <concepts>
same_as (C++20)	指定一个类型与另一个类型相同 （概念）
derived_from (C++20)	指定一个类型派生自另一个类型 （概念）
convertible_to (C++20)	指定一个类型可以隐式转换为另一个类型 （概念）
common_reference_with (C++20)	指定两个类型共享一个公共引用类型 （概念）
common_with (C++20)	指定两个类型共享一个公共类型 （概念）
integral (C++20)	指定一个类型是整型 （概念）
signed_integral (C++20)	指定一个类型是带符号的整型 （概念）
unsigned_integral (C++20)	指定一个类型是无符号的整型 （概念）
floating_point (C++20)	指定一个类型是浮点类型 （概念）
assignable_from (C++20)	指定一个类型可以从另一个类型赋值 （概念）
swappableswappable_with (C++20)	指定一个类型可以被交换，或者两个类型可以相互交换 （概念）
destructible (C++20)	指定可以销毁该类型的对象 （概念）
constructible_from (C++20)	指定可以从一组参数类型构造或绑定该类型的变量 （概念）
default_initializable (C++20)	指定可以默认构造类型的对象 （概念）
move_constructible (C++20)	指定可以移动构造类型的对象 （概念）
copy_constructible (C++20)	指定可以复制构造和移动构造类型的对象 （概念）
比较概念
定义于头文件 <concepts>
boolean-testable  (C++20)	指定类型可以在布尔上下文中使用 （仅供展示的概念*）
equality_comparableequality_comparable_with (C++20)	指定运算符 == 是等价关系 （概念）
totally_orderedtotally_ordered_with (C++20)	指定类型上的比较运算符产生全序 （概念）
定义于头文件 <compare>
three_way_comparablethree_way_comparable_with (C++20)	指定运算符 <=> 在给定类型上产生一致的结果 （概念）
对象概念
定义于头文件 <concepts>
movable (C++20)	指定可以移动和交换类型的对象 （概念）
copyable (C++20)	指定可以复制、移动和交换类型的对象 （概念）
semiregular (C++20)	指定可以复制、移动、交换和默认构造类型的对象 （概念）
regular (C++20)	指定一个类型是 Regular 的，也就是说，它既是 semiregular 又是 equality_comparable （概念）
可调用概念
定义于头文件 <concepts>
invocableregular_invocable (C++20)	指定可以使用给定的一组参数类型调用可调用类型 （概念）
predicate (C++20)	指定可调用类型是布尔谓词 （概念）
relation (C++20)	指定可调用类型是二元关系 （概念）
equivalence_relation (C++20)	指定 relation 施加等价关系 （概念）
strict_weak_order (C++20)	指定 relation 施加严格弱序 （概念）

其他概念可以在迭代器库、算法库和范围库中找到。

参见

• 具名要求