C++ 参考手册
- C++11
- C++14
- C++17
- C++20
- C++ 编译器支持情况表
- 独立与宿主实现
- C++ 语言
- C++ 关键词
- 预处理器
- C++ 标准库头文件
- 标准库头文件 <ctime>
- 标准库头文件 <cstring>
- 标准库头文件 <set>
- 标准库头文件 <cctype>
- 标准库头文件 <cwctype>
- 标准库头文件 <utility>
- 标准库头文件 <queue>
- 标准库头文件 <complex>
- 标准库头文件 <iterator>
- 标准库头文件 <algorithm>
- 标准库头文件 <valarray>
- 标准库头文件 <numeric>
- 标准库头文件 <cmath>
- 标准库头文件 <iosfwd>
- 标准库头文件 <ios>
- 标准库头文件 <iomanip>
- 标准库头文件 <streambuf>
- 标准库头文件 <istream>
- 标准库头文件 <ostream>
- 标准库头文件 <iostream>
- 标准库头文件 <sstream>
- 标准库头文件 <clocale>
- 标准库头文件 <vector>
- 标准库头文件 <deque>
- 标准库头文件 <list>
- 标准库头文件 <map>
- 标准库头文件 <cwchar>
- 标准库头文件 <locale>
- 标准库头文件 <codecvt>
- 标准库头文件 <bitset>
- 标准库头文件 <functional>
- 标准库头文件 <stdexcept>
- 标准库头文件 <csignal>
- 标准库头文件 <csetjmp>
- 标准库头文件 <stack>
- 标准库头文件 <cassert>
- 标准库头文件 <cerrno>
- 标准库头文件 <memory>
- 标准库头文件 <typeindex>
- 标准库头文件 <type_traits>
- 标准库头文件 <chrono>
- 标准库头文件 <initializer_list>
- 标准库头文件 <tuple>
- 标准库头文件 <scoped_allocator>
- 标准库头文件 <cstdint>
- 标准库头文件 <cinttypes>
- 标准库头文件 <system_error>
- 标准库头文件 <cuchar>
- 标准库头文件 <array>
- 标准库头文件 <forward_list>
- 标准库头文件 <unordered_set>
- 标准库头文件 <unordered_map>
- 标准库头文件 <random>
- 标准库头文件 <ratio>
- 标准库头文件 <cfenv>
- 标准库头文件 <regex>
- 标准库头文件 <atomic>
- 标准库头文件 <thread>
- 标准库头文件 <mutex>
- 标准库头文件 <future>
- 标准库头文件 <condition_variable>
- 标准库头文件 <any>
- 标准库头文件 <optional>
- 标准库头文件 <variant>
- 标准库头文件 <memory_resource>
- 标准库头文件 <string_view>
- 标准库头文件 <charconv>
- 标准库头文件 <execution>
- 标准库头文件 <filesystem>
- 标准库头文件 <concepts>
- 标准库头文件 <coroutine>
- 标准库头文件 <compare>
- 标准库头文件 <version>
- 标准库头文件 <source_location>
- 标准库头文件 <format>
- 标准库头文件 <span>
- 标准库头文件 <ranges>
- 标准库头文件 <bit>
- 标准库头文件 <numbers>
- 标准库头文件 <syncstream>
- 标准库头文件 <stop_token>
- 标准库头文件 <semaphore>
- 标准库头文件 <latch>
- 标准库头文件 <barrier>
- 标准库头文件 <string>
- 标准库头文件 <cstddef>
- 标准库头文件 <limits>
- 标准库头文件 <cfloat>
- 标准库头文件 <climits>
- 标准库头文件 <cstdlib>
- 标准库头文件 <new>
- 标准库头文件 <typeinfo>
- 标准库头文件 <exception>
- 标准库头文件 <cstdarg>
- 标准库头文件 <ciso646>
- 标准库头文件 <cstdalign>
- 标准库头文件 <cstdbool>
- 标准库头文件 <fstream>
- 标准库头文件 <cstdio>
- 标准库头文件 <strstream>
- 标准库头文件 <shared_mutex>
- 标准库头文件 <ccomplex>
- 标准库头文件 <ctgmath>
- 注释
- 具名要求
- 功能特性测试 (C++20)
- 工具库
- 类型支持(基本类型、RTTI、类型特性)
- 概念库 (C++20)
- 错误处理
- 动态内存管理
- 日期和时间工具
- 字符串库
- 容器库
- 迭代器库
- 范围库 (C++20)
- 算法库
- 数值库
- 输入/输出库
- 文件系统库
- 本地化库
- 正则表达式库
- 原子操作库
- 线程支持库
- 实验性 C++ 特性
- 有用的资源
- 索引
- std 符号索引
- 协程支持 (C++20)
- C++ 关键词
位置:首页 > C++ 参考手册 >C++ 标准库头文件 > 标准库头文件 <concepts>
标准库头文件 <concepts>
此头文件是概念库的一部分。
概念 | |
核心语言概念 | |
(C++20) |
指定一个类型与另一类型相同 (概念) |
(C++20) |
指定一个类型派生自另一类型 (概念) |
(C++20) |
指定一个类型能隐式转换成另一类型 (概念) |
(C++20) |
指定两个类型共有一个公共引用类型 (概念) |
(C++20) |
指定两个类型共有一个公共类型 (概念) |
(C++20) |
指定类型为整型类型 (概念) |
(C++20) |
指定类型为有符号的整型类型 (概念) |
(C++20) |
指定类型为无符号的整型类型 (概念) |
(C++20) |
指定类型为浮点类型 (概念) |
(C++20) |
指定一个类型能从另一类型赋值 (概念) |
(C++20) |
指定一个类型能进行交换,或两个类型能彼此交换 (概念) |
(C++20) |
指定能销毁该类型的对象 (概念) |
(C++20) |
指定该类型的变量能从一组实参类型进行构造,或绑定到一组实参类型 (概念) |
(C++20) |
指定能默认构造一个类型的对象 (概念) |
(C++20) |
指定能移动构造一个类型的对象 (概念) |
(C++20) |
指定能复制构造和移动构造一个类型的对象 (概念) |
比较概念 | |
(C++20) |
指定类型能用于布尔语境 (概念) |
指定运算符 == 为等价关系 (概念) | |
指定比较运算符在该类型上产生全序 (概念) | |
对象概念 | |
(C++20) |
指定能移动及交换一个类型的对象 (概念) |
(C++20) |
指定能复制、移动及交换一个类型的对象 (概念) |
(C++20) |
指定能赋值、移动、交换及默认构造一个类型的对象 (概念) |
(C++20) |
指定类型为正则,即它既为 semiregular 亦为 equality_comparable (概念) |
可调用概念 | |
(C++20) |
指定能以给定的一组实参类型调用的可调用类型 (概念) |
(C++20) |
指定可调用类型为布尔谓词 (概念) |
(C++20) |
指定可调用类型为二元关系 (概念) |
(C++20) |
指定 relation 施加等价关系 (概念) |
(C++20) |
指定一个 relation 所强加的是严格弱序 (概念) |
定制点对象 | |
(C++20) |
交换两个对象的值 (定制点对象) |
概要
namespace std { // 语言相关概念 // 概念 same_as template<class T, class U> concept same_as = /* 见描述 */; // 概念 derived_from template<class Derived, class Base> concept derived_from = /* 见描述 */; // 概念 convertible_to template<class From, class To> concept convertible_to = /* 见描述 */; // 概念 common_reference_with template<class T, class U> concept common_reference_with = /* 见描述 */; // 概念 common_with template<class T, class U> concept common_with = /* 见描述 */; // 算术概念 template<class T> concept integral = /* 见描述 */; template<class T> concept signed_integral = /* 见描述 */; template<class T> concept unsigned_integral = /* 见描述 */; template<class T> concept floating_point = /* 见描述 */; // 概念 assignable_from template<class LHS, class RHS> concept assignable_from = /* 见描述 */; // 概念 swappable namespace ranges { inline namespace /* 未指明 */ { inline constexpr /* 未指明 */ swap = /* 未指明 */; } } template<class T> concept swappable = /* 见描述 */; template<class T, class U> concept swappable_with = /* 见描述 */; // 概念 destructible template<class T> concept destructible = /* 见描述 */; // 概念 constructible_from template<class T, class... Args> concept constructible_from = /* 见描述 */; // 概念 default_initializable template<class T> concept default_initializable = /* 见描述 */; // 概念 move_constructible template<class T> concept move_constructible = /* 见描述 */; // 概念 copy_constructible template<class T> concept copy_constructible = /* 见描述 */; // 比较概念 // 概念 boolean template<class B> concept boolean = /* 见描述 */; // 概念 equality_comparable template<class T> concept equality_comparable = /* 见描述 */; template<class T, class U> concept equality_comparable_with = /* 见描述 */; // 概念 totally_ordered template<class T> concept totally_ordered = /* 见描述 */; template<class T, class U> concept totally_ordered_with = /* 见描述 */; // 对象概念 template<class T> concept movable = /* 见描述 */; template<class T> concept copyable = /* 见描述 */; template<class T> concept semiregular = /* 见描述 */; template<class T> concept regular = /* 见描述 */; // 可调用概念 // 概念 invocable template<class F, class... Args> concept invocable = /* 见描述 */; // 概念 regular_invocable template<class F, class... Args> concept regular_invocable = /* 见描述 */; // 概念 predicate template<class F, class... Args> concept predicate = /* 见描述 */; // 概念 relation template<class R, class T, class U> concept relation = /* 见描述 */; // 概念 equivalence_relation template<class R, class T, class U> concept equivalence_relation = /* 见描述 */; // 概念 strict_weak_order template<class R, class T, class U> concept strict_weak_order = /* 见描述 */; }
概念 same_as
template<class T, class U> concept __SameImpl = is_same_v<T, U>; // 仅为阐释 template<class T, class U> concept same_as = __SameImpl<T, U> && __SameImpl<U, T>;
概念 derived_from
template<class Derived, class Base> concept derived_from = is_base_of_v<Base, Derived> && is_convertible_v<const volatile Derived*, const volatile Base*>;
概念 convertible_to
template<class From, class To> concept convertible_to = is_convertible_v<From, To> && requires(From (&f)()) { static_cast<To>(f()); };
概念 common_reference_with
template<class T, class U> concept common_reference_with = same_as<common_reference_t<T, U>, common_reference_t<U, T>> && convertible_to<T, common_reference_t<T, U>> && convertible_to<U, common_reference_t<T, U>>;
概念 common_with
template<class T, class U> concept common_with = same_as<common_type_t<T, U>, common_type_t<U, T>> && requires { static_cast<common_type_t<T, U>>(declval<T>()); static_cast<common_type_t<T, U>>(declval<U>()); } && common_reference_with< add_lvalue_reference_t<const T>, add_lvalue_reference_t<const U>> && common_reference_with< add_lvalue_reference_t<common_type_t<T, U>>, common_reference_t< add_lvalue_reference_t<const T>, add_lvalue_reference_t<const U>>>;
概念 integral
template<class T> concept integral = is_integral_v<T>;
概念 signed_integral
template<class T> concept signed_integral = integral<T> && is_signed_v<T>;
概念 unsigned_integral
template<class T> concept unsigned_integral = integral<T> && !signed_integral<T>;
概念 floating_point
template<class T> concept floating_point = is_floating_point_v<T>;
概念 assignable_from
template<class LHS, class RHS> concept assignable_from = is_lvalue_reference_v<LHS> && common_reference_with< const remove_reference_t<LHS>&, const remove_reference_t<RHS>&> && requires(LHS lhs, RHS&& rhs) { { lhs = std::forward<RHS>(rhs) } -> same_as<LHS>;
概念 swappable
template<class T> concept swappable = requires(T& a, T& b) { ranges::swap(a, b); };
概念 swappable_with
template<class T, class U> concept swappable_with = common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> && requires(T&& t, U&& u) { ranges::swap(std::forward<T>(t), std::forward<T>(t)); ranges::swap(std::forward<U>(u), std::forward<U>(u)); ranges::swap(std::forward<T>(t), std::forward<U>(u)); ranges::swap(std::forward<U>(u), std::forward<T>(t)); };
概念 destructible
template<class T> concept destructible = is_nothrow_destructible_v<T>;
概念 constructible_from
template<class T, class... Args> concept constructible_from = destructible<T> && is_constructible_v<T, Args...>;
概念 default_initializable
template<class T> inline constexpr bool __is_default_initializable = /* 见定义 */; // 仅用于阐释 template<class T> concept default_initializable = constructible_from<T> && requires{ T{}; } && __is_default_initializable<T>;
概念 move_constructible
template<class T> concept move_constructible = constructible_from<T, T> && convertible_to<T, T>;
概念 copy_constructible
template<class T> concept copy_constructible = move_constructible<T> && constructible_from<T, T&> && convertible_to<T&, T> && constructible_from<T, const T&> && convertible_to<const T&, T> && constructible_from<T, const T> && convertible_to<const T, T>;
概念 boolean
template<class B> concept boolean = movable<remove_cvref_t<B>> && requires(const remove_reference_t<B>& b1, const remove_reference_t<B>& b2, const bool a) { { b1 } -> convertible_to<bool>; { !b1 } -> convertible_to<bool>; { b1 && b2 } -> same_as<bool>; { b1 && a } -> same_as<bool>; { a && b2 } -> same_as<bool>; { b1 || b2 } -> same_as<bool>; { b1 || a } -> same_as<bool>; { a || b2 } -> same_as<bool>; { b1 == b2 } -> convertible_to<bool>; { b1 == a } -> convertible_to<bool>; { a == b2 } -> convertible_to<bool>; { b1 != b2 } -> convertible_to<bool>; { b1 != a } -> convertible_to<bool>; { a != b2 } -> convertible_to<bool>; };
概念 equality_comparable
template<class T, class U> concept __WeaklyEqualityComparableWith = // 仅为阐释 requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { { t == u } -> boolean; { t != u } -> boolean; { u == t } -> boolean; { u != t } -> boolean; }; template<class T> concept equality_comparable = __WeaklyEqualityComparableWith<T, T>;
概念 equality_comparable_with
template<class T, class U> concept equality_comparable_with = equality_comparable<T> && equality_comparable<U> && common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> && equality_comparable< common_reference_t< const remove_reference_t<T>&, const remove_reference_t<U>&>> && __WeaklyEqualityComparableWith<T, U>;
概念 totally_ordered
template<class T> concept totally_ordered = equality_comparable<T> && requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) { { a < b } -> boolean; { a > b } -> boolean; { a <= b } -> boolean; { a >= b } -> boolean; };
概念 totally_ordered_with
template<class T, class U> concept totally_ordered_with = totally_ordered<T> && totally_ordered<U> && common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> && totally_ordered< common_reference_t< const remove_reference_t<T>&, const remove_reference_t<U>&>> && equality_comparable_with<T, U> && requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { { t < u } -> boolean; { t > u } -> boolean; { t <= u } -> boolean; { t >= u } -> boolean; { u < t } -> boolean; { u > t } -> boolean; { u <= t } -> boolean; { u >= t } -> boolean; };
概念 movable
template<class T> concept movable = is_object_v<T> && move_constructible<T> && assignable_from<T&, T> && swappable<T>;
概念 copyable
template<class T> concept copyable = copy_constructible<T> && movable<T> && assignable_from<T&, const T&>;
概念 semiregular
template<class T> concept semiregular = copyable<T> && default_initializable<T>;
概念 regular
template<class T> concept regular = semiregular<T> && equality_comparable<T>;
概念 invocable
template<class F, class... Args> concept invocable = requires(F&& f, Args&&... args) { invoke(std::forward<F>(f), std::forward<Args>(args)...); // 不要求保持相等性 };
概念 regular_invocable
template<class F, class... Args> concept regular_invocable = invocable<F, Args...>;
概念 predicate
template<class F, class... Args> concept predicate = regular_invocable<F, Args...> && boolean<invoke_result_t<F, Args...>>;
概念 relation
template<class R, class T, class U> concept relation = predicate<R, T, T> && predicate<R, U, U> && predicate<R, T, U> && predicate<R, U, T>;
概念 equivalence_relation
template<class R, class T, class U> concept equivalence_relation = relation<R, T, U>;
概念 strict_weak_order
template<class R, class T, class U> concept strict_weak_order = relation<R, T, U>;