std::ranges::views::drop, std::ranges::drop_view
From cppreference.com
 
 
 
 
 
 C++ 
 Feature test macros (C++20)
 Concepts library (C++20)
 Metaprogramming library (C++11)
 Ranges library (C++20)
 Filesystem library (C++17)
 Concurrency support library (C++11)
 Execution control library (C++26)
Ranges library 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
(exposition-only member object*)
 
 returns the approximate size of the resulting 
(public member function) [edit]
 
 
 returns a constant iterator to the beginning of the range 
(public member function of
 
 returns a sentinel for the constant iterator of the range 
(public member function of
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	
		
(C++23)(C++23)
  (C++23)(C++23)
(C++23)(C++23)
  (C++26)(C++26)
drop_viewviews::drop
(C++23)(C++23)
  (C++26)(C++26)
(C++26)(C++26)
  (C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
  (C++23)(C++23)
(C++23)
(C++23)(C++23)
(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)(C++23)
(C++23)
    std::ranges::drop_view
Defined in header 
 
 
<ranges> 
 template< ranges::view V >
 (1) 
 (since C++20) 
class drop_view
namespace views {
 (2) 
 (since C++20) 
    inline constexpr /* unspecified */ drop = /* unspecified */;
Call signature
 
 
template< ranges::viewable_range R >
 
 (since C++20) 
    requires /* see below */
constexpr ranges::view auto
template< class DifferenceType >
constexpr /* range adaptor closure */ drop( DifferenceType&& count );
 
 (since C++20) 
constexpr /* range adaptor closure */ drop( DifferenceType&& count );
1) A range adaptor consisting of elements of the underlying sequence, skipping the first N elements.
2) RangeAdaptorObject. Given  
T is std::remove_cvref_t <decltype((e))> and D is ranges::range_difference_t <decltype((e))>), the expression views::drop(e, f) is expression-equivalent to:
-  ((void)f,Tis a ranges::empty_view, except that the evaluations of e and f are indeterminately sequenced;
-  otherwise, T(ranges::begin (e) + inc, ranges::end (e),
 /*to-unsigned-like*/(ranges::distance (e) - inc)), ifTis a specialization of ranges::subrange that models bothrandom_access_rangeandsized_range, andTneeds to store the size (see ranges::subrange::subrange() for details), where inc is std::min <D>(ranges::distance (e), f);
-  otherwise, U(ranges::begin (e) + inc, ranges::end (e)), if Tis a specialization of std::span , std::basic_string_view , ranges::iota_view , or ranges::subrange that models bothrandom_access_rangeandsized_range, whereUis
-  otherwise, if Tis a specialization of ranges::repeat_view:
-  views::repeat (*e.value_, ranges::distance (e) - inc), if Tmodelssized_range; in such case e is evaluated only once;
- ((void)e, auto(f)) otherwise, except that the evaluations of e and f are indeterminately sequenced;
 
-  views::repeat (*e.value_, ranges::distance (e) - inc), if 
- otherwise, drop_view(e, f).
drop_view models the concepts contiguous_range, random_access_range, bidirectional_range, forward_range, input_range, common_range, and sized_range when the underlying view V models respective concepts.
Contents
[edit] Data members
 Member
 Description
V base_ (private)
 the underlying view(exposition-only member object*)
 ranges::range_difference_t <V> 
(exposition-only member object*)
count_ (private)
 the number of elements to skip(exposition-only member object*)
 non-propagating-cache <ranges::iterator_t <V>> 
(present only if
(exposition-only member object*)
cache_ (private) (present only if
V satisfies forward_range but not random_access_range and sized_range)
 an object that caches the result of calls to begin() (exposition-only member object*)
[edit] Member functions
 
 returns the number of elements, provided only if the underlying (adapted) range satisfies 
(public member function) [edit]
sized_range (public member function) [edit]
(C++26)
approximately_sized_range (public member function) [edit]
Inherited from std::ranges::view_interface
 
 returns whether the derived view is empty, provided only if it satisfies 
(public member function of
sized_range or forward_range (public member function of
std::ranges::view_interface<D>) [edit] 
(C++23)
(public member function of
std::ranges::view_interface<D>) [edit] 
(C++23)
(public member function of
std::ranges::view_interface<D>) [edit] 
 
 returns whether the derived view is not empty, provided only if ranges::empty  is applicable to it 
(public member function of
(public member function of
std::ranges::view_interface<D>) [edit] 
 
 gets the address of derived view's data, provided only if its iterator type satisfies 
(public member function of
contiguous_iterator (public member function of
std::ranges::view_interface<D>) [edit] 
 
 returns the first element in the derived view, provided if it satisfies 
(public member function of
forward_range (public member function of
std::ranges::view_interface<D>) [edit] 
 
 returns the last element in the derived view, provided only if it satisfies 
(public member function of
bidirectional_range and common_range (public member function of
std::ranges::view_interface<D>) [edit] 
 
 returns the 
(public member function of
nth element in the derived view, provided only if it satisfies random_access_range (public member function of
std::ranges::view_interface<D>) [edit] 
[edit] Deduction guides
[edit] Helper templates
template< class T >
 
 (since C++20) 
constexpr bool enable_borrowed_range<std::ranges::drop_view<T>> =
This specialization of ranges::enable_borrowed_range  makes drop_view satisfy borrowed_range when the underlying view satisfies it.
[edit] Example
Run this code
#include <initializer_list> #include <iostream> #include <ranges> int main() { const auto nums = {1, 2, 3, 4, 5, 6, 7}; std::cout << "drop " << 2 << ": "; for (int i : std::ranges::drop_view{nums, 2}) std::cout << i << ' '; std::cout << '\n'; std::cout << "drop " << 3 << ": "; for (int i : nums | std::views::drop(3)) std::cout << i << ' '; std::cout << '\n'; std::cout << "drop " << 4 << ": "; for (int i : std::views::iota (1, 8) | std::views::drop(4)) std::cout << i << ' '; std::cout << '\n'; // Note that dropping more than the number of elements is OK: for (int dp : {5, 6, 7, 890, 100500}) { std::cout << "drop " << dp << ": "; for (int i : std::views::iota (1, 8) | std::views::drop(dp)) std::cout << i << ' '; std::cout << '\n'; } }
Output:
drop 2: 3 4 5 6 7 drop 3: 4 5 6 7 drop 4: 5 6 7 drop 5: 6 7 drop 6: 7 drop 7: drop 890: drop 100500:
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior | 
|---|---|---|---|
| LWG 3407 | C++20 | views::dropsometimes fails toconstruct a sized random access range | the construction is adjusted so that it is always valid | 
| LWG 3494 | C++20 | drop_viewwas never aborrowed_range | it is a borrowed_rangeif its underlying view is |