Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      Ranges library(since C++20)

      From cppreference.com
      <cpp
       
       
      Ranges library
      Range adaptors
       

      The ranges library is an extension and generalization of the algorithms and iterator libraries that makes them more powerful by making them composable and less error-prone.

      The library creates and manipulates rangeviews, lightweight objects that indirectly represent iterable sequences (ranges). Ranges are an abstraction on top of

      • [begin, end) – iterator pairs, e.g. ranges made by implicit conversion from containers. All algorithms that take iterator pairs now have overloads that accept ranges (e.g.ranges::sort)
      • begin + [​0​, size) – counted sequences, e.g. range returned byviews::counted
      • [begin, predicate) – conditionally-terminated sequences, e.g. range returned byviews::take_while
      • [begin, ..) – unbounded sequences, e.g. range returned byviews::iota

      The ranges library includesrange algorithms, which are applied to ranges eagerly, andrange adaptors, which are applied to views lazily. Adaptors can be composed into pipelines, so that their actions take place as the view is iterated.

      Defined in header<ranges>
      namespace std{

         namespace views= ranges::views;

      }
      		(since C++20)

      The namespace aliasstd::views is provided as a shorthand forstd::ranges::views.

      Defined in namespacestd::ranges

      Contents

      Range access
      Defined in header<ranges>
      Defined in header<iterator>
      returns an iterator to the beginning of a range
      (customization point object)[edit]
      returns a sentinel indicating the end of a range
      (customization point object)[edit]
      returns an iterator to the beginning of a read-only range
      (customization point object)[edit]
      returns a sentinel indicating the end of a read-only range
      (customization point object)[edit]
      returns a reverse iterator to a range
      (customization point object)[edit]
      returns a reverse end iterator to a range
      (customization point object)[edit]
      returns a reverse iterator to a read-only range
      (customization point object)[edit]
      returns a reverse end iterator to a read-only range
      (customization point object)[edit]
      returns an integer equal to the reserve hint given by a range
      (customization point object)[edit]
      returns an integer equal to the size of a range
      (customization point object)[edit]
      returns a signed integer equal to the size of a range
      (customization point object)[edit]
      checks whether a range is empty
      (customization point object)[edit]
      obtains a pointer to the beginning of a contiguous range
      (customization point object)[edit]
      obtains a pointer to the beginning of a read-only contiguous range
      (customization point object)[edit]
      Range primitives
      Defined in header<ranges>
      obtains iterator and sentinel types of a range
      (alias template)[edit]
      obtains size, difference, and value types of a range
      (alias template)[edit]
      obtains reference types of a range
      (alias template)[edit]
      Dangling iterator handling
      Defined in header<ranges>
      a placeholder type indicating that an iterator or asubrange should not be returned since it would be dangling
      (class)[edit]
      obtains iterator type orsubrange type of aborrowed_range
      (alias template)[edit]
      Other utilities
      Defined in header<ranges>
      tags a range to be treated as a sequence rather than a single value
      (class template)[edit]
      Range concepts
      Defined in header<ranges>
      specifies that a type is a range, that is, it provides abegin iterator and anend sentinel
      (concept)[edit]
      specifies that a type is arange and iterators obtained from an expression of it can be safely returned without danger of dangling
      (concept)[edit]
      specifies that a range can estimate its size in constant time
      (concept)[edit]
      specifies that a range knows its size in constant time
      (concept)[edit]
      specifies that a range is a view, that is, it has constant time copy/move/assignment
      (concept)[edit]
      specifies a range whose iterator type satisfiesinput_iterator
      (concept)[edit]
      specifies a range whose iterator type satisfiesoutput_iterator
      (concept)[edit]
      specifies a range whose iterator type satisfiesforward_iterator
      (concept)[edit]
      specifies a range whose iterator type satisfiesbidirectional_iterator
      (concept)[edit]
      specifies a range whose iterator type satisfiesrandom_access_iterator
      (concept)[edit]
      specifies a range whose iterator type satisfiescontiguous_iterator
      (concept)[edit]
      specifies that a range has identical iterator and sentinel types
      (concept)[edit]
      specifies the requirements for arange to be safely convertible to aview
      (concept)[edit]
      specifies that a range has read-only elements
      (concept)[edit]
      Range conversions
      Defined in header<ranges>
      (C++23)
      		 constructs a new non-view object from an input range
      (function template)[edit]
      Views
      Defined in header<ranges>
      helper class template for defining aview, using thecuriously recurring template pattern
      (class template)[edit]
      combines an iterator-sentinel pair into aview
      (class template)[edit]

      [edit]Range factories

      Defined in header<ranges>
      Defined in namespacestd::ranges
      an emptyview with no elements
      (class template)(variable template)[edit]
      aview that contains a single element of a specified value
      (class template)(customization point object)[edit]
      aview consisting of a sequence generated by repeatedly incrementing an initial value
      (class template)(customization point object)[edit]
      aview consisting of a generated sequence by repeatedly producing the same value
      (class template)(customization point object)[edit]
      aview consisting of the elements obtained by successive application ofoperator>> on the associated input stream
      (class template)(customization point object)[edit]

      [edit]Range adaptors

      Defined in header<ranges>
      Defined in namespacestd::ranges
      helper base class template for defining a range adaptor closure object
      (class template)[edit]
      aview that includes all elements of arange
      (alias template)(range adaptor object)[edit]
      aview of the elements of some otherrange
      (class template)[edit]
      aview with unique ownership of somerange
      (class template)[edit]
      aview of a sequence that casts each element to an rvalue
      (class template)(range adaptor object)[edit]
      aview that consists of the elements of arange that satisfies a predicate
      (class template)(range adaptor object)[edit]
      aview of a sequence that applies a transformation function to each element
      (class template)(range adaptor object)[edit]
      aview consisting of the first N elements of anotherview
      (class template)(range adaptor object)[edit]
      aview consisting of the initial elements of anotherview, until the first element on which a predicate returnsfalse
      (class template)(range adaptor object)[edit]
      aview consisting of elements of anotherview, skipping the first N elements
      (class template)(range adaptor object)[edit]
      aview consisting of the elements of anotherview, skipping the initial subsequence of elements until the first element where the predicate returnsfalse
      (class template)(range adaptor object)[edit]
      aview consisting of the sequence obtained from flattening aview ofranges
      (class template)(range adaptor object)[edit]
      aview consisting of the sequence obtained from flattening a view of ranges, with the delimiter in between elements
      (class template)(range adaptor object)[edit]
      aview over the subranges obtained from splitting anotherview using a delimiter
      (class template)(range adaptor object)[edit]
      aview over the subranges obtained from splitting anotherview using a delimiter
      (class template)(range adaptor object)[edit]
      aview consisting of concatenation of the adapted views
      (class template)(customization point object)[edit]
      creates a subrange from an iterator and a count
      (customization point object)[edit]
      converts aview into acommon_range
      (class template)(range adaptor object)[edit]
      aview that iterates over the elements of another bidirectional view in reverse order
      (class template)(range adaptor object)[edit]
      converts aview into aconstant_range
      (class template)(range adaptor object)[edit]
      takes aview consisting oftuple-like values and a number N and produces aview of Nth element of each tuple
      (class template)(range adaptor object)[edit]
      takes aview consisting of pair-like values and produces aview of the first elements of each pair
      (class template)(range adaptor object)[edit]
      takes aview consisting of pair-like values and produces aview of the second elements of each pair
      (class template)(range adaptor object)[edit]
      aview that maps each element of adapted sequence to a tuple of both the element's position and its value
      (class template)(range adaptor object)[edit]
      aview consisting of tuples of references to corresponding elements of the adapted views
      (class template)(customization point object)[edit]
      aview consisting of results of application of a transformation function to corresponding elements of the adapted views
      (class template)(customization point object)[edit]
      aview consisting of tuples of references to adjacent elements of the adapted view
      (class template)(range adaptor object)[edit]
      aview consisting of results of application of a transformation function to adjacent elements of the adapted view
      (class template)(range adaptor object)[edit]
      a range ofviews that areN-sized non-overlapping successive chunks of the elements of anotherview
      (class template)(range adaptor object)[edit]
      aview whose Mth element is aview over the Mth through (M + N - 1)th elements of anotherview
      (class template)(range adaptor object)[edit]
      splits theview into subranges between each pair of adjacent elements for which the given predicate returnsfalse
      (class template)(range adaptor object)[edit]
      aview consisting of elements of anotherview, advancing over N elements at a time
      (class template)(range adaptor object)[edit]
      aview consisting of tuples of results calculated by the n-ary cartesian product of the adapted views
      (class template)(customization point object)[edit]
      aview that caches the last-accessed element of its underlying sequence
      (class template)(range adaptor object)[edit]
      converts aview into a range that isinput_range-only and non-common_range
      (class template)(range adaptor object)[edit]

      [edit]Range generators(since C++23)

      Defined in header<generator>
      Defined in namespacestd
      (C++23)
      		 Aview that represents synchronouscoroutine generator
      (class template)[edit]

      [edit]Helper items

      [edit]Range adaptor objects

      SeeRangeAdaptorObject (RAO).

      [edit]Range adaptor closure objects

      SeeRangeAdaptorClosureObject (RACO).

      [edit]Customization point objects

      SeeCustomization point object (CPO).

      [edit]Assignable wrapper

      Some range adaptors wrap their elements or function objects with thecopyable-box(until C++23)movable-box(since C++23). The wrapper augments the wrapped object with assignability when needed.

      [edit]Non-propagating cache

      Some range adaptors are specified in terms of an exposition-only class templatenon-propagating-cache, which behaves almost likestd::optional<T> (see description for differences).

      [edit]Conditionally-const type

      template<bool Const,class T>
      using/*maybe-const*/=std::conditional_t<Const,const T, T>;
      		(exposition only*)

      The alias template/*maybe-const*/ is a shorthand used to conditionally apply aconst qualifier to the typeT.

      [edit]Integer-like type helper templates

      template</*is-integer-like*/ T>
      using/*make-signed-like-t*/<T>=/* see description */;
      		 (1)(exposition only*)
      template</*is-integer-like*/ T>
      using/*make-unsigned-like-t*/<T>=/* see description */;
      		 (2)(exposition only*)
      template</*is-integer-like*/ T>

      /*make-unsigned-like-t*/<T>/*to-unsigned-like*/( T t)
      {
         returnstatic_cast</*make-unsigned-like-t*/<T>>(t);

      }
      		 (3)(exposition only*)
      1) For aninteger-like typeT:
      • IfT is an integer type,/*make-signed-like-t*/<T> isstd::make_signed_t<T>.
      • Otherwise,/*make-signed-like-t*/<T> is a corresponding unspecified signed-integer-like type of the same width asT.
      2) For an integer-like typeT:
      • IfT is an integer type,/*make-unsigned-like-t*/<T> isstd::make_unsigned_t<T>.
      • Otherwise,/*make-signed-like-t*/<T> is a corresponding unspecified unsigned-integer-like type of the same width asT.
      3) Explicitly convertst to/*make-unsigned-like-t*/<T>.

      [edit]Customization point object helpers

      template<ranges::input_range R>

      constexprauto&/*possibly-const-range*/(R& r)noexcept
      {
         ifconstexpr(ranges::input_range<const R>)
             returnconst_cast<const R&>(r);
         else
             return r;

      }
      		 (1)(exposition only*)
      template<class T>

      constexprauto/*as-const-pointer*/(const T* p)noexcept
      {
         return p;

      }
      		 (2)(exposition only*)

      Some range access customization point objects are specified in terms of these exposition-only function templates.

      1)/*possibly-const-range*/ returns the const-qualified version ofr ifconst R modelsinput_range; otherwise, returnsr without any casting.
      2)/*as-const-pointer*/ returns a pointer to object of constant type.

      [edit]Range adaptor helpers

      template<class F,class Tuple>

      constexprauto/*tuple-transform*/( F&& f, Tuple&& tuple)
      {
         returnstd::apply([&]<class...Ts>(Ts&&...args)
         {
             returnstd::tuple<std::invoke_result_t<F&, Ts>...>
                 (std::invoke(f,std::forward<Ts>(args))...);
         },std::forward<Tuple>(tuple));

      }
      		 (1)(exposition only*)
      template<class F,class Tuple>

      constexprvoid/*tuple-for-each*/( F&& f, Tuple&& tuple)
      {
         std::apply([&]<class...Ts>(Ts&&...args)
         {
             (static_cast<void>(std::invoke(f,std::forward<Ts>(args))), ...);
         },std::forward<Tuple>(tuple));

      }
      		 (2)(exposition only*)
      template<class T>

      constexpr T&/*as-lvalue*/( T&& t)
      {
         returnstatic_cast<T&>(t);

      }
      		 (3)(exposition only*)

      Some range adaptors are specified in terms of these exposition-only function templates.

      1)/*tuple-transform*/ returns a new tuple constructed by applyingf to each element oftuple.
      2)/*tuple-for-each*/ appliesf to each element oftuple and returns nothing.
      3)/*as-lvalue*/ forwards rvaluet as lvalue.

      [edit]Helper concepts

      Following exposition-only concepts are used for several types, but they are not parts of the interface of standard library.

      template<class R>

      concept/*simple-view*/=
         ranges::view<R>&&ranges::range<const R>&&
         std::same_as<ranges::iterator_t<R>,ranges::iterator_t<const R>>&&

         std::same_as<ranges::sentinel_t<R>,ranges::sentinel_t<const R>>;
      		 (1)(exposition only*)
      template<class I>

      concept/*has-arrow*/=
          ranges::input_iterator<I>&&

         (std::is_pointer_v<I>|| requires(const I i){ i.operator->();});
      		 (2)(exposition only*)
      template<class T,class U>

      concept/*different-from*/=

         !std::same_as<std::remove_cvref_t<T>,std::remove_cvref_t<U>>;
      		 (3)(exposition only*)
      template<class R>

      concept/*range-with-movable-references*/=
         ranges::input_range<R>&&
         std::move_constructible<ranges::range_reference_t<R>>&&

         std::move_constructible<ranges::range_rvalue_reference_t<R>>;
      		 (4)(exposition only*)
      template<bool C,class...Views>

      concept/*all-random-access*/=
         (ranges::random_access_range

               <std::conditional_t<C,const Views, Views>>&& ...);
      		 (5)(exposition only*)
      template<bool C,class...Views>

      concept/*all-bidirectional*/=
         (ranges::bidirectional_range

               <std::conditional_t<C,const Views, Views>>&& ...);
      		 (6)(exposition only*)
      template<bool C,class...Views>

      concept/*all-forward*/=
         (ranges::forward_range

               <std::conditional_t<C,const Views, Views>>&& ...);
      		 (7)(exposition only*)

      [edit]Notes

      Feature-test macroValueStdFeature
      __cpp_lib_generator202207L(C++23)std::generator – synchronous coroutine generator for ranges
      __cpp_lib_ranges201911L(C++20)Ranges library andconstrained algorithms
      202106L(C++23)
      (DR20)      		Non-default-initializableviews
      202110L(C++23)
      (DR20)      		Views withownership
      202202L(C++23)ranges::range_adaptor_closure
      202207L(C++23)Relaxingrange adaptors to allow for move-only types
      202211L(C++23)Removing "poison pills"(P2602) overloads inranges::begin etc
      202302L(C++23)Relaxing ranges to allow certain projections
      202406L(C++26)
      (DR20)      		Removing the common reference requirement from the indirectly invocable concepts
      __cpp_lib_ranges_as_const202207L(C++23)std::const_iterator,ranges::as_const_view
      __cpp_lib_ranges_as_rvalue202207L(C++23)ranges::as_rvalue_view
      __cpp_lib_ranges_cache_latest202411L(C++26)ranges::cache_latest_view
      __cpp_lib_ranges_cartesian_product202207L(C++23)ranges::cartesian_product_view
      __cpp_lib_ranges_chunk202202L(C++23)ranges::chunk_view
      __cpp_lib_ranges_chunk_by202202L(C++23)ranges::chunk_by_view
      __cpp_lib_ranges_concat202403L(C++26)ranges::concat_view
      __cpp_lib_ranges_enumerate202302L(C++23)ranges::enumerate_view
      __cpp_lib_ranges_join_with202202L(C++23)ranges::join_with_view
      __cpp_lib_ranges_repeat202207L(C++23)ranges::repeat_view
      __cpp_lib_ranges_reserve_hint202502L(C++26)ranges::reserve_hint andranges::approximately_sized_range
      __cpp_lib_ranges_slide202202L(C++23)ranges::slide_view
      __cpp_lib_ranges_stride202207L(C++23)ranges::stride_view
      __cpp_lib_ranges_to_container202202L(C++23)ranges::to
      __cpp_lib_ranges_to_input202502L(C++26)ranges::to_input_view
      __cpp_lib_ranges_zip202110L(C++23)ranges::zip_view,
      ranges::zip_transform_view,
      ranges::adjacent_view,
      ranges::adjacent_transform_view

      [edit]Example

      Run this code
      #include <iostream>#include <ranges> int main(){autoconst ints={0,1,2,3,4,5};auto even=[](int i){return0== i%2;};auto square=[](int i){return i* i;}; // the "pipe" syntax of composing the views:for(int i: ints| std::views::filter(even)| std::views::transform(square))std::cout<< i<<' '; std::cout<<'\n'; // a traditional "functional" composing syntax:for(int i: std::views::transform(std::views::filter(ints, even), square))std::cout<< i<<' ';}

      Output:

      0 4 160 4 16

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 3509
      (P2281R1)      		C++20it was unclear how range adaptor objects bound trailing argumentsthey are bound
      by value
      LWG 3948C++23possibly-const-range andas-const-pointer
      were not declarednoexcept      		declarednoexcept
      LWG 4027C++23possibly-const-range would not add const-qualification
      for ranges that has already modeledconstant_range      		adds const-qualification
      for such ranges
      LWG 4112C++20has-arrow did not requirei to be const-qualifiedrequires

      [edit]See also

      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/ranges&oldid=180956"
      [8]ページ先頭
      ©2009-2025 Movatter.jp