Standard library header <concepts> (C++20)
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Standard library headers
<compare> (C++20)
<contracts> (C++26)
<coroutine> (C++20)
<cstdint> (C++11)
<source_location> (C++20)
<stdfloat> (C++23)
<version> (C++20)
<concepts> (C++20)
<debugging> (C++26)
<stacktrace> (C++23)
<system_error> (C++11)
<memory_resource> (C++17)
<scoped_allocator> (C++11)
<type_traits> (C++11)
<ratio> (C++11)
<any> (C++17)
<bit> (C++20)
<charconv> (C++17)
<expected> (C++23)
<format> (C++20)
<optional> (C++17)
<stdbit.h> (C++26)
<tuple> (C++11)
<typeindex> (C++11)
<variant> (C++17)
<array> (C++11)
<flat_map> (C++23)
<flat_set> (C++23)
<forward_list> (C++11)
<hive> (C++26)
<mdspan> (C++23)
<span> (C++20)
<unordered_map> (C++11)
<unordered_set> (C++11)
<generator> (C++23)
<ranges> (C++20)
<cuchar> (C++11)
<string_view> (C++17)
<codecvt> (C++11/17/26*)
<regex> (C++11)
<cfenv> (C++11)
<linalg> (C++26)
<numbers> (C++20)
<random> (C++11)
<simd> (C++26)
<stdckdint.h> (C++26)
<chrono> (C++11)
<ccomplex> (C++11/17/20*)
<ciso646> (until C++20)
<cstdalign> (C++11/17/20*)
<cstdbool> (C++11/17/20*)
<ctgmath> (C++11/17/20*)
<cinttypes> (C++11)
<filesystem> (C++17)
<print> (C++23)
<spanstream> (C++23)
<strstream> (C++98/26*)
<syncstream> (C++20)
<atomic> (C++11)
<barrier> (C++20)
<condition_variable> (C++11)
<future> (C++11)
<hazard_pointer> (C++26)
<latch> (C++20)
<mutex> (C++11)
<rcu> (C++26)
<semaphore> (C++20)
<shared_mutex> (C++14)
<stdatomic.h> (C++23)
<stop_token> (C++20)
<thread> (C++11)
<execution> (C++17)
This header is part of the concepts library.
Contents
- 1 Concepts
- 2 Customization point objects
- 3 Synopsis
- 3.1 Helper concept boolean-testable
- 3.2 Concept same_as
- 3.3 Concept derived_from
- 3.4 Concept convertible_to
- 3.5 Concept common_reference_with
- 3.6 Concept common_with
- 3.7 Concept integral
- 3.8 Concept signed_integral
- 3.9 Concept unsigned_integral
- 3.10 Concept floating_point
- 3.11 Concept assignable_from
- 3.12 Concept swappable
- 3.13 Concept swappable_with
- 3.14 Concept destructible
- 3.15 Concept constructible_from
- 3.16 Concept default_initializable
- 3.17 Concept move_constructible
- 3.18 Concept copy_constructible
- 3.19 Concept equality_comparable
- 3.20 Concept equality_comparable_with
- 3.21 Helper concept partially-ordered-with
- 3.22 Concept totally_ordered
- 3.23 Concept totally_ordered_with
- 3.24 Concept movable
- 3.25 Concept copyable
- 3.26 Concept semiregular
- 3.27 Concept regular
- 3.28 Concept invocable
- 3.29 Concept regular_invocable
- 3.30 Concept predicate
- 3.31 Concept relation
- 3.32 Concept equivalence_relation
- 3.33 Concept strict_weak_order
Concepts
Core language concepts
(C++20)
(concept) [edit]
(C++20)
(concept) [edit]
(C++20)
(concept) [edit]
Comparison concepts
Object concepts
(C++20)
(concept) [edit]
(C++20)
semiregular
and equality_comparable
(concept) [edit]
Callable concepts
(C++20)
(concept) [edit]
Customization point objects
[edit] Synopsis
// all freestanding namespace std { // language-related concepts // concept same_as template<class T, class U> concept same_as = /* see description */; // concept derived_from template<class Derived, class Base> concept derived_from = /* see description */; // concept convertible_to template<class From, class To> concept convertible_to = /* see description */; // concept common_reference_with template<class T, class U> concept common_reference_with = /* see description */; // concept common_with template<class T, class U> concept common_with = /* see description */; // arithmetic concepts template<class T> concept integral = /* see description */; template<class T> concept signed_integral = /* see description */; template<class T> concept unsigned_integral = /* see description */; template<class T> concept floating_point = /* see description */; // concept assignable_from template<class LHS, class RHS> concept assignable_from = /* see description */; // concept swappable namespace ranges { inline namespace /* unspecified */ { inline constexpr /* unspecified */ swap = /* unspecified */; } } template<class T> concept swappable = /* see description */; template<class T, class U> concept swappable_with = /* see description */; // concept destructible template<class T> concept destructible = /* see description */; // concept constructible_from template<class T, class... Args> concept constructible_from = /* see description */; // concept default_initializable template<class T> concept default_initializable = /* see description */; // concept move_constructible template<class T> concept move_constructible = /* see description */; // concept copy_constructible template<class T> concept copy_constructible = /* see description */; // comparison concepts // concept equality_comparable template<class T> concept equality_comparable = /* see description */; template<class T, class U> concept equality_comparable_with = /* see description */; // concept totally_ordered template<class T> concept totally_ordered = /* see description */; template<class T, class U> concept totally_ordered_with = /* see description */; // object concepts template<class T> concept movable = /* see description */; template<class T> concept copyable = /* see description */; template<class T> concept semiregular = /* see description */; template<class T> concept regular = /* see description */; // callable concepts // concept invocable template<class F, class... Args> concept invocable = /* see description */; // concept regular_invocable template<class F, class... Args> concept regular_invocable = /* see description */; // concept predicate template<class F, class... Args> concept predicate = /* see description */; // concept relation template<class R, class T, class U> concept relation = /* see description */; // concept equivalence_relation template<class R, class T, class U> concept equivalence_relation = /* see description */; // concept strict_weak_order template<class R, class T, class U> concept strict_weak_order = /* see description */; }
[edit] Helper concept boolean-testable
template<class T> concept /*boolean-testable-impl*/ = convertible_to<T, bool>; // exposition only; template<class T> concept boolean-testable = // exposition only /*boolean-testable-impl*/<T> && requires(T&& t) { { !std::forward <T>(t) } -> /*boolean-testable-impl*/; };
[edit] Concept same_as
template<class T, class U> concept /*same-as-impl*/ = is_same_v<T, U>; // exposition only template<class T, class U> concept same_as = /*same-as-impl*/<T, U> && /*same-as-impl*/<U, T>;
[edit] Concept 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*>;
[edit] Concept convertible_to
template<class From, class To> concept convertible_to = is_convertible_v<From, To> && requires { static_cast<To>(declval<From>()); };
[edit] Concept 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>>;
[edit] Concept 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>>>;
[edit] Concept integral
template<class T> concept integral = is_integral_v<T>;
[edit] Concept signed_integral
template<class T> concept signed_integral = integral<T> && is_signed_v<T>;
[edit] Concept unsigned_integral
template<class T> concept unsigned_integral = integral<T> && !signed_integral<T>;
[edit] Concept floating_point
template<class T> concept floating_point = is_floating_point_v<T>;
[edit] Concept 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>; };
[edit] Concept swappable
template<class T> concept swappable = requires(T& a, T& b) { ranges::swap (a, b); };
[edit] Concept swappable_with
template<class T, class U> concept swappable_with = common_reference_with<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)); };
[edit] Concept destructible
template<class T> concept destructible = is_nothrow_destructible_v<T>;
[edit] Concept constructible_from
template<class T, class... Args> concept constructible_from = destructible<T> && is_constructible_v<T, Args...>;
[edit] Concept default_initializable
template<class T> constexpr bool /*is-default-initializable*/ = /* see description */; // exposition only template<class T> concept default_initializable = constructible_from<T> && requires { T{}; } && /*is-default-initializable*/<T>;
[edit] Concept move_constructible
template<class T> concept move_constructible = constructible_from<T, T> && convertible_to<T, T>;
[edit] Concept 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>;
[edit] Concept equality_comparable
template<class T, class U> concept /*weakly-equality-comparable-with*/ = // exposition only requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { { t == u } -> boolean-testable ; { t != u } -> boolean-testable ; { u == t } -> boolean-testable ; { u != t } -> boolean-testable ; }; template<class T> concept equality_comparable = /*weakly-equality-comparable-with*/<T, T>;
[edit] Concept equality_comparable_with
template<class T, class U, class C = common_reference_t<const T&, const U&>> concept /*comparison-common-type-with-impl*/ = // exposition only same_as<common_reference_t<const T&, const U&>, common_reference_t<const U&, const T&>> && requires { requires convertible_to<const T&, const C&> || convertible_to<T, const C&>; requires convertible_to<const U&, const C&> || convertible_to<U, const C&>; }; template<class T, class U> concept /*comparison-common-type-with*/ = // exposition only /*comparison-common-type-with-impl*/<remove_cvref_t<T>, remove_cvref_t<U>>; template<class T, class U> concept equality_comparable_with = equality_comparable<T> && equality_comparable<U> && /*comparison-common-type-with*/<T, U> && equality_comparable< common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>> && /*weakly-equality-comparable-with*/<T, U>;
[edit] Helper concept partially-ordered-with
Defined in header <compare>
template<class T, class U> concept /*partially-ordered-with*/ = // exposition only requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { { t < u } -> boolean-testable ; { t > u } -> boolean-testable ; { t <= u } -> boolean-testable ; { t >= u } -> boolean-testable ; { u < t } -> boolean-testable ; { u > t } -> boolean-testable ; { u <= t } -> boolean-testable ; { u >= t } -> boolean-testable ; };
[edit] Concept totally_ordered
template<class T> concept totally_ordered = equality_comparable<T> && /*partially-ordered-with*/<T, T>;
[edit] Concept totally_ordered_with
template<class T, class U> concept totally_ordered_with = totally_ordered<T> && totally_ordered<U> && equality_comparable_with<T, U> && totally_ordered< common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>> && /*partially-ordered-with*/<T, U>;
[edit] Concept movable
template<class T> concept movable = is_object_v<T> && move_constructible<T> && assignable_from<T&, T> && swappable<T>;
[edit] Concept copyable
template<class T> concept copyable = copy_constructible<T> && movable<T> && assignable_from<T&, T&> && assignable_from<T&, const T&> && assignable_from<T&, const T>;
[edit] Concept semiregular
template<class T> concept semiregular = copyable<T> && default_initializable<T>;
[edit] Concept regular
template<class T> concept regular = semiregular<T> && equality_comparable<T>;
[edit] Concept invocable
template<class F, class... Args> concept invocable = requires(F&& f, Args&&... args) { invoke(std::forward <F>(f), std::forward <Args>(args)...); // not required to be equality-preserving };
[edit] Concept regular_invocable
template<class F, class... Args> concept regular_invocable = invocable<F, Args...>;
[edit] Concept predicate
template<class F, class... Args> concept predicate = regular_invocable<F, Args...> && boolean-testable <invoke_result_t<F, Args...>>;
[edit] Concept 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>;
[edit] Concept equivalence_relation
template<class R, class T, class U> concept equivalence_relation = relation<R, T, U>;
[edit] Concept strict_weak_order
template<class R, class T, class U> concept strict_weak_order = relation<R, T, U>;