Author: Linux Manual

std::StrictTotallyOrdered,std::StrictTotallyOrderedWith – std::StrictTotallyOrdered,std::StrictTotallyOrderedWith Synopsis Defined in header<concepts> template <class T> concept StrictTotallyOrdered = std::EqualityComparable<T> && requires(const std::remove_reference_t<T> &a, const std::remove_reference_t<T> &b) { (1)(since C++ 20) a < b; requires std::Boolean<decltype(a < b)>; a > b; requires std::Boolean<decltype(a > b)>; a <= b; requires std::Boolean<decltype(a <= b)>; a >= b; requires std::Boolean<decltype(a >= b)>; }; template…

std::SignedIntegral – std::SignedIntegral Synopsis Defined in header <concepts> template < class T > (since C++20) concept SignedIntegral = std::Integral<T> && std::is_signed_v<T>; The concept SignedIntegral<T> is satisfied if and only if T is an integral type and std::is_signed_v<T> is true. Notes SignedIntegral<T> may be satisfied by a type that is not a signed_integer_type, for example, char…

std::Semiregular – std::Semiregular Synopsis Defined in header <concepts> template <class T> (since C++20) concept Semiregular = std::Copyable<T> && std::DefaultConstructible<T>; The Semiregular concept specifies that a type is both copyable and default constructible. It is satisfied by types that behave similarly to built-in types like int, except that they need not support comparison with ==.

std::Same – std::Same Synopsis Defined in header <concepts> template < class T, class U > (since C++20) concept Same = /* see below */; The concept Same<T, U> is satisfied if and only if T and U denote the same type. std::Same<T, U> subsumes std::Same<U, T> and vice versa. Possible implementation   namespace detail {       template<…

std::Relation – std::Relation Synopsis Defined in header <concepts> template <class R, class T, class U> concept Relation = (1) (since C++20) std::Predicate<R, T, T> && std::Predicate<R, U, U> && std::Predicate<R, T, U> && std::Predicate<R, U, T>; The concept Relation<R, T, U> specifies that R defines a binary relation over the set of expressions whose type…

std::Regular – std::Regular Synopsis Defined in header <concepts> template <class T> (since C++20) concept Regular = std::Semiregular<T> && std::EqualityComparable<T>; The Regular concept specifies that a type is regular, that is, it is copyable, default constructible, and equality comparable. It is satisfied by types that behave similarly to built-in types like int, and that are comparable…

std::Predicate – std::Predicate Synopsis Defined in header <concepts> template < class F, class… Args > concept Predicate = (since C++20) std::RegularInvocable<F, Args…> && std::Boolean<std::invoke_result_t<F, Args…>>; The concept Predicate<F, Args…> specifies that F is a predicate that accepts arguments whose types and value categories are encoded by Args…, i.e., it can be invoked with these arguments…

std::MoveConstructible – std::MoveConstructible Synopsis Defined in header <concepts> template< class T > (since C++20) concept MoveConstructible = std::Constructible<T, T> && std::ConvertibleTo<T, T>; The concept MoveConstructible is satisfied if T is a reference type, or if it is an object type where an object of that type can constructed from an rvalue of that type in…

std::Movable – std::Movable Synopsis Defined in header <concepts> template < class T > concept Movable = std::is_object_v<T> && (since C++20) std::MoveConstructible<T> && std::Assignable<T&, T> && std::Swappable<T>; The concept Movable<T> specifies that T is an object type that can moved (that is, it can be move constructed, move assigned, and lvalues of type T can be…

std::Invocable,std::RegularInvocable – std::Invocable,std::RegularInvocable Synopsis Defined in header <concepts> template< class F, class… Args > concept Invocable = requires(F&& f, Args&&… args) { (since C++20) std::invoke(std::forward<F>(f), std::forward<Args>(args)…); /* not required to be equality preserving */ }; template< class F, class… Args > (since C++20) concept RegularInvocable = std::Invocable<F, Args…>; The Invocable concept specifies that a callable…

std::Integral – std::Integral Synopsis Defined in header <concepts> template < class T > (since C++20) concept Integral = std::is_integral_v<T>; The concept Integral<T> is satisfied if and only if T is an integral type. See also is_integral checks if a type is an integral type             (class template) (C++11)

std::EqualityComparable,std::EqualityComparableWith – std::EqualityComparable,std::EqualityComparableWith Synopsis Defined in header<concepts> template <class T, class U> concept __WeaklyEqualityComparableWith = // exposition only requires(const std::remove_reference_t<T> &t, const std::remove_reference_t<U> &u) { t == u; requires std::Boolean<decltype(t == u)>; (1) t != u; requires std::Boolean<decltype(t != u)>; u == t; requires std::Boolean<decltype(u == t)>; u != t; requires std::Boolean<decltype(u != t)>; };…

std::Destructible – std::Destructible Synopsis Defined in header <concepts> template < class T > (since C++20) concept Destructible = std::is_nothrow_destructible_v<T>; The concept Destructible specifies the concept of all types whose instances can safely be destroyed at the end of their lifetime (including reference types). Notes Unlike the Destructible named requirement, std::Destructible requires the destructor to be…

std::DerivedFrom – std::DerivedFrom Synopsis Defined in header<concepts> template <class Derived, class Base> concept DerivedFrom = (since C++ 20) std::is_base_of_v<Base, Derived> && std::is_convertible_v<const volatile Derived *, const volatile Base *>; The concept DerivedFrom<Derived, Base> is satisfied if and only if Base is a class type that is either Derived or a public and unambiguous base of…

std::DefaultConstructible – std::DefaultConstructible Synopsis Defined in header <concepts> template < class T > (since C++20) concept DefaultConstructible = std::Constructible<T>; The DefaultConstructible concept provides a shorthand for the common case when the question is whether a type can be constructed with no arguments. See also Constructible specifies that a variable of the type can be constructed…

std::Copyable – std::Copyable Synopsis Defined in header<concepts> template <class T> concept Copyable = std::CopyConstructible<T> &&(since C++ 20) std::Movable<T> && std::Assignable<T &, const T &>; The concept Copyable<T> specifies that T is an Movable object type that can also copied (that is, it supports copy construction and copy assignment). Notes It is intended that Copyable<T> also…

std::CopyConstructible – std::CopyConstructible Synopsis Defined in header<concepts> template <class T> concept CopyConstructible = std::MoveConstructible<T> &&(since C++ 20) std::Constructible<T, T &> && std::ConvertibleTo<T &, T> && std::Constructible<T, const T &> && std::ConvertibleTo<const T &, T> && std::Constructible<T, const T> && std::ConvertibleTo<const T, T>; The concept CopyConstructible is satisfied if T is an lvalue reference type, or…

std::ConvertibleTo – std::ConvertibleTo Synopsis Defined in header <concepts> template <class From, class To> concept ConvertibleTo = std::is_convertible_v<From, To> && (since C++20) requires(From (&f)()) { static_cast<To>(f()); }; The concept ConvertibleTo<From, To> specifies that an expression of the type and value category specified by From can be implicitly and explicitly converted to the type To, and the…

std::Constructible – std::Constructible Synopsis Defined in header <concepts> template < class T, class… Args > concept Constructible = (since C++20) std::Destructible<T> && std::is_constructible_v<T, Args…>; The Constructible concept specifies that a variable of type T can be initialized with the given set of argument types Args…. See also is_constructible is_trivially_constructible is_nothrow_constructible checks if a type has…

std::CommonReference – std::CommonReference Synopsis Defined in header <concepts> template < class T, class U > concept CommonReference = std::Same<std::common_reference_t<T, U>, std::common_reference_t<U, T>> && (since C++20) std::ConvertibleTo<T, std::common_reference_t<T, U>> && std::ConvertibleTo<U, std::common_reference_t<T, U>>; The concept CommonReference<T, U> specifies that two types T and U share a common reference type (as computed by std::common_reference_t) to which both…