Linux Manuals session 3

std::ranges::all_of,std::ranges::any_of,std::ranges::none_of – std::ranges::all_of,std::ranges::any_of,std::ranges::none_of Synopsis Defined in header <algorithm> Call signature template< InputIterator I, Sentinel<I> S, class Proj = std::identity, IndirectUnaryPredicate<projected<I, Proj>> Pred > (1) (since C++20) bool all_of( I first, S last, Pred pred, Proj proj = {} ); template< InputRange R, class Proj = std::identity, IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred > (2) (since C++20) bool all_of(…

std::ranges::ViewableRange – std::ranges::ViewableRange Synopsis Defined in header <ranges> template<class T> concept ViewableRange = Range<T> && (__ForwardingRange<T> || View<std::decay_t<T>>); The ViewableRange concept is a refinement of Range that describes a range that can be safely converted into a View. (note __ForwardingRange is the exposition-only concept defined in Range)

std::ranges::View,std::ranges::enable_view,std::ranges::view_base – std::ranges::View,std::ranges::enable_view,std::ranges::view_base Synopsis Defined in header<ranges> template <class T> (1) concept View = Range<T> && Semiregular<T> && enable_view<T>; template <class T> (2) inline constexpr bool enable_view = /*see description*/; struct view_base { }; (3) 1) The View concept specifies the requirements of a Range type that has constant time copy, move, and assignment operations…

std::ranges::SizedRange,std::ranges::disable_sized_range – std::ranges::SizedRange,std::ranges::disable_sized_range Synopsis Defined in header <ranges> template< class T > concept SizedRange = Range<T> && ! disable_sized_range<std::remove_cvref_t<T>> && (1) requires(T& t) { ranges::size(t); }; template<class> (2) inline constexpr bool disable_sized_range = false; 1) The SizedRange concept specifies the requirements of a Range type that knows its size in constant time with the size…

std::ranges::Range – std::ranges::Range Synopsis Defined in header<ranges> template <class T> (1) concept Range = __RangeImpl<T &>; // exposition-only definition // exposition-only helper concept template <class T> concept __RangeImpl = requires(T &&t) { (2) ranges::begin(std::forward<T>(t)); // equality-preserving for forward iterators ranges::end(std::forward<T>(t)); }; // exposition-only helper concept template <class T> (3) concept __ForwardingRange = Range<T> && __RangeImpl<T>;…

std::ranges::RandomAccessRange – std::ranges::RandomAccessRange Synopsis Defined in header <ranges> template<class T> concept RandomAccessRange = BidirectionalRange<T> && RandomAccessIterator<iterator_t<T>>; The RandomAccessRange concept is a refinement of Range for which ranges::begin returns a model of RandomAccessIterator.

std::ranges::OutputRange – std::ranges::OutputRange Synopsis Defined in header <ranges> template<class R, class T> concept OutputRange = Range<R> && OutputIterator<iterator_t<R>, T>; The OutputRange concept is a refinement of Range for which ranges::begin returns a model of OutputIterator.

std::ranges::InputRange – std::ranges::InputRange Synopsis Defined in header <ranges> template<class T> concept InputRange = Range<T> && InputIterator<iterator_t<T>>; The InputRange concept is a refinement of Range for which ranges::begin returns a model of InputIterator.

std::ranges::ForwardRange – std::ranges::ForwardRange Synopsis Defined in header <ranges> template<class T> concept ForwardRange = InputRange<T> && ForwardIterator<iterator_t<T>>; The ForwardRange concept is a refinement of Range for which ranges::begin returns a model of ForwardIterator.

std::ranges::ContiguousRange – std::ranges::ContiguousRange Synopsis Defined in header <ranges> template<class T> concept ContiguousRange = RandomAccessRange<T> && ContiguousIterator<iterator_t<T>> && requires(T& t) { { ranges::data(t) } -> Same<std::add_pointer_t<iter_reference_t<iterator_t<T>>>>; }; The ContiguousRange concept is a refinement of Range for which ranges::begin returns a model of ContiguousIterator and the customization point ranges::data is usable.

std::ranges::CommonRange – std::ranges::CommonRange Synopsis Defined in header <ranges> template<class T> concept CommonRange = Range<T> && Same<iterator_t<T>, sentinel_t<T>>; The CommonRange concept is a refinement of Range for which ranges::begin and ranges::end return the same type (e.g. all standard library containers).

std::ranges::BidirectionalRange – std::ranges::BidirectionalRange Synopsis Defined in header <ranges> template<class T> concept BidirectionalRange = ForwardRange<T> && BidirectionalIterator<iterator_t<T>>; The BidirectionalRange concept is a refinement of Range for which ranges::begin returns a model of BidirectionalIterator.

std::range_error – std::range_error Synopsis Defined in header <stdexcept> class range_error; Defines a type of object to be thrown as exception. It can be used to report range errors (that is, situations where a result of a computation cannot be represented by the destination type) The only standard library components that throw this exception are std::wstring_convert::from_bytes…

std::random_shuffle,std::shuffle – std::random_shuffle,std::shuffle Synopsis Defined in header<algorithm> template <class RandomIt> (1)(deprecated in C++ 14) void random_shuffle(RandomIt first, RandomIt last); (removed in C++ 17) template <class RandomIt, class RandomFunc> (until C++ 11) void random_shuffle(RandomIt first, RandomIt last, RandomFunc &r); template <class RandomIt, class RandomFunc> (since C++ 11) void random_shuffle(RandomIt first, RandomIt last, RandomFunc &&r); (2)(deprecated in…

std::random_device::random_device – std::random_device::random_device Synopsis random_device() : random_device(/*implementation-defined*/){}(1)(since C++ 11) explicit random_device(const std::string &token); (2)(since C++ 11) random_device(const random_device &) = delete; (3)(since C++ 11) 1) Default constructs a new std::random_device object with an implementation-defined token. 2) Constructs a new std::random_device object, making use of the argument token in an implementation-defined manner. 3) The copy constructor…

std::random_device::operator() – std::random_device::operator() Synopsis result_type operator()(); (since C++11) Generates a non-deterministic uniformly-distributed random value. Parameters (none) Return value A random number uniformly distributed in [min(), max()]. Exceptions Throws an implementation-defined exception derived from std::exception if a random number could not be generated. See also min gets the smallest possible value in the output range          (public…

std::random_device::min – std::random_device::min Synopsis static constexpr result_type min(); (since C++11) Returns the minimum value potentially generated by the random-number engine. This value is equal to 0u. Parameters (none) Return value The minimum potentially generated value. Complexity Constant See also max gets the largest possible value in the output range          (public static member function) [static]

std::random_device::max – std::random_device::max Synopsis static constexpr result_type max(); (since C++11) Returns the maximum value potentially generated by the random-number engine. This value is equal to std::numeric_limits<unsigned int>::max(). Parameters (none) Return value The maximum potentially generated value. Complexity Constant See also min gets the smallest possible value in the output range          (public static member function) [static]

std::random_device::entropy – std::random_device::entropy Synopsis double entropy() const noexcept; (since C++ 11) Obtains an estimate of the random number device entropy, which is a floating-point value between 0 and log 2(max()+1) (which is equal to std::numeric_limits<unsigned int>::digits). If the device has n states whose individual probabilities are P 0,…,P n-1, the device entropy S is defined…

std::random_device – std::random_device Synopsis Defined in header <random> class random_device; (since C++11) std::random_device is a uniformly-distributed integer random number generator that produces non-deterministic random numbers. std::random_device may be implemented in terms of an implementation-defined pseudo-random number engine if a non-deterministic source (e.g. a hardware device) is not available to the implementation. In this case each…