Section 3: library functions
std::_Bind< _Ind, _Tp > – Synopsis Detailed Description template<std::size_t _Ind, typename… _Tp>struct std::_Bind< _Ind, _Tp > Type of the function object returned from bind(). Definition at line 1277 of file functional. Author Generated automatically by Doxygen for libstdc++ from the source code.
std::_Base_bitset< _Nw > – Synopsis Public Types typedef unsigned long _WordT Public Member Functions constexpr _Base_bitset (unsigned long long __val) noexcept template<size_t _Nb> bool _M_are_all () const noexcept void _M_do_and (const _Base_bitset< _Nw > &__x) noexcept size_t _M_do_count () const noexcept size_t _M_do_find_first (size_t) const noexcept size_t _M_do_find_next (size_t, size_t) const noexcept void _M_do_flip ()…
std::UnsignedIntegral – std::UnsignedIntegral Synopsis Defined in header <concepts> template < class T > (since C++20) concept UnsignedIntegral = std::Integral<T> && !std::SignedIntegral<T>; The concept UnsignedIntegral<T> is satisfied if and only if T is an integral type and std::is_signed_v<T> is false. Notes UnsignedIntegral<T> may be satisfied by a type that is not a unsigned_integer_type, for example, bool….
std::UniformRandomBitGenerator – std::UniformRandomBitGenerator Synopsis Defined in header <random> template <class G> concept UniformRandomBitGenerator = std::Invocable<G&> && std::UnsignedIntegral<std::invoke_result_t<G&>> && (since C++20) requires { G::min(); requires std::Same<decltype(G::min()), std::invoke_result_t<G&>>; G::max(); requires std::Same<decltype(G::max()), std::invoke_result_t<G&>>; }; The concept UniformRandomBitGenerator <G> specifies that G is the type of a uniform random bit generator, that is, objects of type G is a…
std::Swappable,std::SwappableWith – std::Swappable,std::SwappableWith Synopsis Defined in header<concepts> template <class T> concept Swappable = requires(T & a, T &b) { (1)(since C++ 20) ranges::swap(a, b); }; template <class T, class U> concept SwappableWith = CommonReference < const std::remove_reference_t<T> &, const std::remove_reference_t<U> & > && requires(T &&t, U &&u) { (2)(since C++ 20) ranges::swap(std::forward<T>(t), std::forward<T>(t)); ranges::swap(std::forward<U>(u), std::forward<U>(u));…
std::StrictWeakOrder – std::StrictWeakOrder Synopsis Defined in header <concepts> template < class R, class T, class U > (1) (since C++20) concept StrictWeakOrder = std::Relation<R, T, U>; The concept StrictWeakOrder<R, T, U> specifies that the Relation R imposes a strict weak ordering on its arguments. A relation r is a strict weak ordering if * it…
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…