Standard library header <concepts>
From cppreference.com
This header is part of the concepts library.
Concepts | |
Core language concepts | |
(C++20) | specifies that a type is the same as another type (concept) |
(C++20) | specifies that a type is derived from another type (concept) |
(C++20) | specifies that a type is implicitly convertible to another type (concept) |
(C++20) | specifies that two types share a common reference type (concept) |
(C++20) | specifies that two types share a common type (concept) |
(C++20) | specifies that a type is an integral type (concept) |
(C++20) | specifies that a type is an integral type that is signed (concept) |
(C++20) | specifies that a type is an integral type that is unsigned (concept) |
(C++20) | specifies that a type is a floating-point type (concept) |
(C++20) | specifies that a type is assignable from another type (concept) |
(C++20) | specifies that a type can be swapped or that two types can be swapped with each other (concept) |
(C++20) | specifies that an object of the type can be destroyed (concept) |
(C++20) | specifies that a variable of the type can be constructed from or bound to a set of argument types (concept) |
(C++20) | specifies that an object of a type can be default constructed (concept) |
(C++20) | specifies that an object of a type can be move constructed (concept) |
(C++20) | specifies that an object of a type can be copy constructed and move constructed (concept) |
Comparison concepts | |
| specifies that operator == is an equivalence relation (concept) | |
| specifies that the comparison operators on the type yield a total order (concept) | |
Object concepts | |
(C++20) | specifies that an object of a type can be moved and swapped (concept) |
(C++20) | specifies that an object of a type can be copied, moved, and swapped (concept) |
(C++20) | specifies that an object of a type can be copied, moved, swapped, and default constructed (concept) |
(C++20) | specifies that a type is regular, that is, it is both semiregular and equality_comparable (concept) |
Callable concepts | |
(C++20) | specifies that a callable type can be invoked with a given set of argument types (concept) |
(C++20) | specifies that a callable type is a Boolean predicate (concept) |
(C++20) | specifies that a callable type is a binary relation (concept) |
(C++20) | specifies that a relation imposes an equivalence relation (concept) |
(C++20) | specifies that a relation imposes a strict weak ordering (concept) |
Customization point objects | |
(C++20) | swaps the values of two objects (customization point object) |
[edit]Synopsis
namespace std {// language-related concepts// concept same_astemplate<class T, class U> concept same_as =/* see description */; // concept derived_fromtemplate<class Derived, class Base> concept derived_from =/* see description */; // concept convertible_totemplate<class From, class To> concept convertible_to =/* see description */; // concept common_reference_withtemplate<class T, class U> concept common_reference_with =/* see description */; // concept common_withtemplate<class T, class U> concept common_with =/* see description */; // arithmetic conceptstemplate<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_fromtemplate<class LHS, class RHS> concept assignable_from =/* see description */; // concept swappablenamespace ranges {inlinenamespace/* unspecified */{inlineconstexpr/* unspecified */ swap =/* unspecified */;}}template<class T> concept swappable =/* see description */;template<class T, class U> concept swappable_with =/* see description */; // concept destructibletemplate<class T> concept destructible =/* see description */; // concept constructible_fromtemplate<class T, class... Args> concept constructible_from =/* see description */; // concept default_initializabletemplate<class T> concept default_initializable =/* see description */; // concept move_constructibletemplate<class T> concept move_constructible =/* see description */; // concept copy_constructibletemplate<class T> concept copy_constructible =/* see description */; // comparison concepts// concept equality_comparabletemplate<class T> concept equality_comparable =/* see description */;template<class T, class U> concept equality_comparable_with =/* see description */; // concept totally_orderedtemplate<class T> concept totally_ordered =/* see description */;template<class T, class U> concept totally_ordered_with =/* see description */; // object conceptstemplate<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 invocabletemplate<class F, class... Args> concept invocable =/* see description */; // concept regular_invocabletemplate<class F, class... Args> concept regular_invocable =/* see description */; // concept predicatetemplate<class F, class... Args> concept predicate =/* see description */; // concept relationtemplate<class R, class T, class U> concept relation =/* see description */; // concept equivalence_relationtemplate<class R, class T, class U> concept equivalence_relation =/* see description */; // concept strict_weak_ordertemplate<class R, class T, class U> concept strict_weak_order =/* see description */;}
[edit]Concept same_as
template<class T, class U> concept __SameImpl = is_same_v<T, U>;// exposition only template<class T, class U> concept same_as = __SameImpl<T, U>&& __SameImpl<U, T>;
[edit]Concept derived_from
template<class Derived, class Base> concept derived_from = is_base_of_v<Base, Derived>&& is_convertible_v<constvolatile Derived*, constvolatile Base*>;
[edit]Concept convertible_to
template<class From, class To> concept convertible_to = is_convertible_v<From, To>&& requires(From (&f)()){static_cast<To>(f());};
[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<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));};
[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>inlineconstexprbool __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 __WeaklyEqualityComparableWith =// 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 = __WeaklyEqualityComparableWith<T, T>;
[edit]Concept 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>;
[edit]Concept 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-testable;{ a > b }->boolean-testable;{ a <= b }->boolean-testable;{ a >= b }->boolean-testable;};
[edit]Concept 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-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 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>;
