This header is part of theconcepts library.
Concepts | ||
Core language concepts | ||
(C++20) | specifies that a type is the same as another type (concept)[edit] | |
(C++20) | specifies that a type is derived from another type (concept)[edit] | |
(C++20) | specifies that a type is implicitly convertible to another type (concept)[edit] | |
(C++20) | specifies that two types share a common reference type (concept)[edit] | |
(C++20) | specifies that two types share a common type (concept)[edit] | |
(C++20) | specifies that a type is an integral type (concept)[edit] | |
(C++20) | specifies that a type is an integral type that is signed (concept)[edit] | |
(C++20) | specifies that a type is an integral type that is unsigned (concept)[edit] | |
(C++20) | specifies that a type is a floating-point type (concept)[edit] | |
(C++20) | specifies that a type is assignable from another type (concept)[edit] | |
(C++20) | specifies that a type can be swapped or that two types can be swapped with each other (concept)[edit] | |
(C++20) | specifies that an object of the type can be destroyed (concept)[edit] | |
(C++20) | specifies that a variable of the type can be constructed from or bound to a set of argument types (concept)[edit] | |
(C++20) | specifies that an object of a type can be default constructed (concept)[edit] | |
(C++20) | specifies that an object of a type can be move constructed (concept)[edit] | |
(C++20) | specifies that an object of a type can be copy constructed and move constructed (concept)[edit] | |
Comparison concepts | ||
| specifies that operator== is an equivalence relation (concept)[edit] | ||
| specifies that the comparison operators on the type yield a total order (concept)[edit] | ||
Object concepts | ||
(C++20) | specifies that an object of a type can be moved and swapped (concept)[edit] | |
(C++20) | specifies that an object of a type can be copied, moved, and swapped (concept)[edit] | |
(C++20) | specifies that an object of a type can be copied, moved, swapped, and default constructed (concept)[edit] | |
(C++20) | specifies that a type is regular, that is, it is bothsemiregular andequality_comparable(concept)[edit] | |
Callable concepts | ||
(C++20) | specifies that a callable type can be invoked with a given set of argument types (concept)[edit] | |
(C++20) | specifies that a callable type is a Boolean predicate (concept)[edit] | |
(C++20) | specifies that a callable type is a binary relation (concept)[edit] | |
(C++20) | specifies that arelation imposes an equivalence relation(concept)[edit] | |
(C++20) | specifies that arelation imposes a strict weak ordering(concept)[edit] | |
Customization point objects | ||
(C++20) | swaps the values of two objects (customization point object)[edit] | |
// all freestandingnamespace 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 */;}
boolean-testabletemplate<class T>concept/*boolean-testable-impl*/= convertible_to<T,bool>;// exposition only; template<class T>conceptboolean-testable=// exposition only/*boolean-testable-impl*/<T>&& requires(T&& t){{!std::forward<T>(t)}->/*boolean-testable-impl*/;};
same_astemplate<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>;
derived_fromtemplate<class Derived,class Base>concept derived_from= is_base_of_v<Base, Derived>&& is_convertible_v<constvolatile Derived*,constvolatile Base*>;
convertible_totemplate<class From,class To>concept convertible_to= is_convertible_v<From, To>&& requires{static_cast<To>(declval<From>());};
common_reference_withtemplate<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_withtemplate<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>>>;
integraltemplate<class T>concept integral= is_integral_v<T>;
signed_integraltemplate<class T>concept signed_integral= integral<T>&& is_signed_v<T>;
unsigned_integraltemplate<class T>concept unsigned_integral= integral<T>&&!signed_integral<T>;
floating_pointtemplate<class T>concept floating_point= is_floating_point_v<T>;
assignable_fromtemplate<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>;};
swappabletemplate<class T>concept swappable= requires(T& a, T& b){ranges::swap(a, b);};
swappable_withtemplate<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));};
destructibletemplate<class T>concept destructible= is_nothrow_destructible_v<T>;
constructible_fromtemplate<class T,class...Args>concept constructible_from= destructible<T>&& is_constructible_v<T, Args...>;
default_initializabletemplate<class T>constexprbool/*is-default-initializable*/=/* see description */;// exposition only template<class T>concept default_initializable= constructible_from<T>&& requires{ T{};}&&/*is-default-initializable*/<T>;
move_constructibletemplate<class T>concept move_constructible= constructible_from<T, T>&& convertible_to<T, T>;
copy_constructibletemplate<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>;
equality_comparabletemplate<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>;
equality_comparable_withtemplate<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>;
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;};
totally_orderedtemplate<class T>concept totally_ordered= equality_comparable<T>&&/*partially-ordered-with*/<T, T>;
totally_ordered_withtemplate<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>;
movabletemplate<class T>concept movable= is_object_v<T>&& move_constructible<T>&& assignable_from<T&, T>&& swappable<T>;
copyabletemplate<class T>concept copyable= copy_constructible<T>&& movable<T>&& assignable_from<T&, T&>&& assignable_from<T&,const T&>&& assignable_from<T&,const T>;
semiregulartemplate<class T>concept semiregular= copyable<T>&& default_initializable<T>;
regulartemplate<class T>concept regular= semiregular<T>&& equality_comparable<T>;
invocabletemplate<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};
regular_invocabletemplate<class F,class...Args> concept regular_invocable= invocable<F, Args...>;
predicatetemplate<class F,class...Args>concept predicate= regular_invocable<F, Args...>&&boolean-testable<invoke_result_t<F, Args...>>;
relationtemplate<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_relationtemplate<class R,class T,class U>concept equivalence_relation= relation<R, T, U>;
strict_weak_ordertemplate<class R,class T,class U>concept strict_weak_order= relation<R, T, U>;
