Linux Manuals

std::experimental::ranges::EqualityComparable,std::experimental::ranges::EqualityComparableWith – std::experimental::ranges::EqualityComparable,std::experimental::ranges::EqualityComparableWith Synopsis Defined in header<experimental / ranges / concepts> template <class T> (1)(ranges TS) concept bool EqualityComparable = WeaklyEqualityComparableWith<T, T>; template <class T, class U> concept bool EqualityComparableWith = EqualityComparable<T> && EqualityComparable<U> && CommonReference< const std::remove_reference_t<T> &, (2)(ranges TS) const std::remove_reference_t<U> &> && EqualityComparable< ranges::common_reference_t< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &>> && WeaklyEqualityComparableWith<T,…

std::experimental::ranges::Destructible – std::experimental::ranges::Destructible Synopsis Defined in header <experimental/ranges/concepts> template < class T > (ranges TS) concept bool Destructible = std::is_nothrow_destructible<T>::value; The concept Destructible specifies the concept of all types whose instances can safely be destroyed at the end of their lifetime (including reference types). There need not be any subsumption relationship between Destructible<T> and std::is_nothrow_destructible<T>::value….

std::experimental::ranges::DerivedFrom – std::experimental::ranges::DerivedFrom Synopsis Defined in header <experimental/ranges/concepts> template < class T, class U > concept bool DerivedFrom = (ranges TS) std::is_base_of<U, T>::value && std::is_convertible<std::remove_cv_t<T>*, std::remove_cv_t<U>*>::value; The concept DerivedFrom<T, U> is satisfied if and only if U is a class type that is either T or a public and unambiguous base of T. Despite the…

std::experimental::ranges::DefaultConstructible – std::experimental::ranges::DefaultConstructible Synopsis Defined in header <experimental/ranges/concepts> template < class T > (ranges TS) concept bool DefaultConstructible = 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                                    specifies that a variable of the type can be constructed…

std::experimental::ranges::Copyable – std::experimental::ranges::Copyable Synopsis Defined in header<experimental / ranges / concepts> template <class T> concept bool Copyable = CopyConstructible<T> && (ranges TS) Movable<T> && 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…

std::experimental::ranges::CopyConstructible – std::experimental::ranges::CopyConstructible Synopsis Defined in header<experimental / ranges / concepts> template <class T> concept bool CopyConstructible = MoveConstructible<T> && (ranges TS) Constructible<T, T &> && ConvertibleTo<T &, T> && Constructible<T, const T &> && ConvertibleTo<const T &, T> && Constructible<T, const T> && ConvertibleTo<const T, T>; The concept CopyConstructible is satisfied if T is…

std::experimental::ranges::ConvertibleTo – std::experimental::ranges::ConvertibleTo Synopsis Defined in header <experimental/ranges/concepts> template <class From, class To> concept bool ConvertibleTo = std::is_convertible<From, To>::value && (ranges TS) 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…

std::experimental::ranges::Constructible – std::experimental::ranges::Constructible Synopsis Defined in header <experimental/ranges/concepts> template < class T, class… Args > concept bool Constructible = (ranges TS) Destructible<T> && std::is_constructible<T, Args…>::value; The Constructible concept specifies that a variable of type T can be initialized with the given set of argument types Args…. There need not be any subsumption relationship between Constructible<T,…

std::experimental::ranges::CommonReference – std::experimental::ranges::CommonReference Synopsis Defined in header <experimental/ranges/concepts> template < class T, class U > concept bool CommonReference = Same<ranges::common_reference_t<T, U>, ranges::common_reference_t<U, T>> && (ranges TS) ConvertibleTo<T, ranges::common_reference_t<T, U>> && ConvertibleTo<U, ranges::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 ranges::common_reference_t) to which…

std::experimental::ranges::Common – std::experimental::ranges::Common Synopsis Defined in header<experimental / ranges / concepts> template <class T, class U> concept bool Common = Same<ranges::common_type_t<T, U>, ranges::common_type_t<U, T>> && ConvertibleTo<T, ranges::common_type_t<T, U>> && ConvertibleTo<U, ranges::common_type_t<T, U>> && CommonReference< std::add_lvalue_reference_t<const T>, (ranges TS) std::add_lvalue_reference_t<const U>> && CommonReference< std::add_lvalue_reference_t<ranges::common_type_t<T, U>>, ranges::common_reference_t< std::add_lvalue_reference_t<const T>, std::add_lvalue_reference_t<const U>>>; The concept Common<T, U> specifies that…

std::experimental::ranges::BoundedRange – std::experimental::ranges::BoundedRange Synopsis Defined in header <experimental/ranges/range> template <class T> concept bool BoundedRange = (ranges TS) Range<T> && Same<ranges::iterator_t<T>, ranges::sentinel_t<T>>;  This section is incomplete  Reason: add description and extra caveats

std::experimental::ranges::Boolean – std::experimental::ranges::Boolean Synopsis Defined in header<experimental / ranges / concepts> template <class B> concept bool Boolean = Movable<std::decay_t<B>> && requires(const std::remove_reference_t<B> &b1, const std::remove_reference_t<B> &b2, const bool a) { { b1 } -> ConvertibleTo<bool> &&; { !b1 } -> ConvertibleTo<bool> &&; { b1 &&a } -> Same<bool> &&; { b1 || a } ->…

std::experimental::ranges::BidirectionalRange – std::experimental::ranges::BidirectionalRange Synopsis Defined in header <experimental/ranges/range> template <class T> concept bool BidirectionalRange = (ranges TS) ForwardRange<T> && BidirectionalIterator<ranges::iterator_t<T>>;  This section is incomplete  Reason: add description and extra caveats

std::experimental::ranges::BidirectionalIterator – std::experimental::ranges::BidirectionalIterator Synopsis Defined in header <experimental/ranges/iterator> template < class I > concept bool BidirectionalIterator = ForwardIterator<I> && DerivedFrom<ranges::iterator_category_t<I>, ranges::bidirectional_iterator_tag> && (ranges TS) requires(I i) { { –i } -> Same<I>&; { i– } -> Same<I>&&; }; The concept BidirectionalIterator<I> refines ForwardIterator by adding the ability to move an iterator backward. A bidirectional iterator…

std::experimental::ranges::Assignable – std::experimental::ranges::Assignable Synopsis Defined in header<experimental / ranges / concepts> template <class T, class U> concept bool Assignable = std::is_lvalue_reference<T>::value && CommonReference< const std::remove_reference_t<T> &, (ranges TS) const std::remove_reference_t<U> &> && requires(T t, U &&u) { { t = std::forward<U>(u) } -> Same<T> &&; }; The concept Assignable<T, U> specifies that an expression of…

std::experimental::randint – std::experimental::randint Synopsis Defined in header <experimental/random> template <class IntType> (library fundamentals TS v2) IntType randint(IntType a, IntType b); Generates a random integer in the closed interval [a, b]. Parameters a, b – integer values specifying the range Return value A random integer i in the closed interval [a, b], produced using a thread-local…

std::experimental::propagate_const<T>::swap – std::experimental::propagate_const<T>::swap Synopsis constexpr void swap(propagate_const & pt) noexcept(/* see below */); (library fundamentals TS v2) Swaps the wrapped pointer with that of pt. Let t_ designate the private data member that is the wrapped pointer-like object, then this function is equivalent to swap(t_, pt.t_). Parameters pt – another propagate_const object to swap with…

std::experimental::propagate_const<T>::propagate_const – std::experimental::propagate_const<T>::propagate_const Synopsis constexpr propagate_const() = default; (1)(library fundamentals TS v2) constexpr propagate_const(propagate_const &&p) = default; (2)(library fundamentals TS v2) template <class U> (3)(library fundamentals TS v2) /* see below */ constexpr propagate_const(propagate_const<U> &&pu); template <class U> (4)(library fundamentals TS v2) /* see below */ constexpr propagate_const(U &&u); propagate_const(const propagate_const &) = delete; (5)(library…

std::experimental::propagate_const<T>::operatorelement_type*,std::experimental::propagate_const<T>::operatorconstelement_type* – std::experimental::propagate_const<T>::operatorelement_type*,std::experimental::propagate_const<T>::operatorconstelement_type* Synopsis constexpr operator element_type*(); (1) (library fundamentals TS v2) constexpr operator const element_type*() const; (2) (library fundamentals TS v2) Provides implicit conversions to element_type* and const element_type*. 1) This function does not participate in overload resolution unless T is an object pointer type or is implicitly convertible to element_type*. 2) This function…

std::experimental::propagate_const<T>::operatorbool – std::experimental::propagate_const<T>::operatorbool Synopsis constexpr explicit operator bool() const; (library fundamentals TS v2) Checks whether the wrapped pointer-like object, t_, is null. Parameters (none) Return value true if the wrapped object is not null, otherwise false. Equivalent to (bool)t_. Example  This section is incomplete  Reason: no example See also     returns a pointer to the object…