Difference between revisions of "cpp/ranges/drop view"
From cppreference.com
m (fmt: T as expr. vs T as id.) |
m (limit to C++23 revision box) |
||
Line 34: | Line 34: | ||
:* {{c|std::span<typename T::element_type>}}, if {{tt|T}} is a specialization of {{lc|std::span}}; | :* {{c|std::span<typename T::element_type>}}, if {{tt|T}} is a specialization of {{lc|std::span}}; | ||
:* {{c|T}} otherwise; | :* {{c|T}} otherwise; | ||
+ | {{rrev|since=c++23| | ||
* otherwise, if {{tt|T}} is a specialization of {{lc|ranges::repeat_view}}: | * otherwise, if {{tt|T}} is a specialization of {{lc|ranges::repeat_view}}: | ||
:* {{c|views::repeat(*e.value_, ranges::distance(e) - /*inc*/)}}, if {{tt|T}} models {{lconcept|sized_range}}; in such case {{c|e}} is evaluated only once; | :* {{c|views::repeat(*e.value_, ranges::distance(e) - /*inc*/)}}, if {{tt|T}} models {{lconcept|sized_range}}; in such case {{c|e}} is evaluated only once; | ||
:* {{c|((void)e, auto(f))}} otherwise, except that the evaluations of {{c|e}} and {{c|f}} are indeterminately sequenced; | :* {{c|((void)e, auto(f))}} otherwise, except that the evaluations of {{c|e}} and {{c|f}} are indeterminately sequenced; | ||
+ | }} | ||
* otherwise, {{c|drop_view(e, f)}}. | * otherwise, {{c|drop_view(e, f)}}. | ||
<!----> | <!----> |
Revision as of 23:29, 15 August 2022
Defined in header <ranges>
|
||
template< ranges::view V > class drop_view : public ranges::view_interface<drop_view<V>> |
(1) | (since C++20) |
namespace views { inline constexpr /*unspecified*/ drop = /*unspecified*/; |
(2) | (since C++20) |
Call signature |
||
template< ranges::viewable_range R, class DifferenceType > requires /* see below */ |
(since C++20) | |
template< class DifferenceType > constexpr /*range adaptor closure*/ drop( DifferenceType&& count ); |
(since C++20) | |
1) A range adaptor consisting of elements of the underlying sequence, skipping the first N elements.
2) Range adaptor object. 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, static_cast<T>(e)), if
T
is 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*/)), if
T
is a specialization of ranges::subrange that models bothrandom_access_range
andsized_range
, andT
needs 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
T
is a specialization of std::span, std::basic_string_view, ranges::iota_view, or ranges::subrange that models bothrandom_access_range
andsized_range
, whereU
is
- std::span<typename T::element_type>, if
T
is a specialization of std::span; - T otherwise;
- std::span<typename T::element_type>, if
|
(since C++23) |
- 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 |
Expression-equivalent
Expression e is expression-equivalent to expression f, if
- e and f have the same effects, and
- either both are constant subexpressions or else neither is a constant subexpression, and
- either both are potentially-throwing or else neither is potentially-throwing (i.e. noexcept(e) == noexcept(f)).
Member functions
constructs a drop_view (public member function) | |
returns a copy of the underlying (adapted) view (public member function) | |
returns an iterator to the beginning (public member function) | |
returns an iterator or a sentinel to the end (public member function) | |
returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range . (public member function) | |
Inherited from std::ranges::view_interface | |
returns whether the derived view is empty. Provided if it satisfies sized_range or forward_range . (public member function of std::ranges::view_interface<D> )
| |
(C++23) |
returns a constant iterator to the beginning of the range. (public member function of std::ranges::view_interface<D> )
|
(C++23) |
returns a sentinel for the constant iterator of the range. (public member function of std::ranges::view_interface<D> )
|
returns whether the derived view is not empty. Provided if ranges::empty is applicable to it. (public member function of std::ranges::view_interface<D> )
| |
gets the address of derived view's data. Provided if its iterator type satisfies contiguous_iterator . (public member function of std::ranges::view_interface<D> )
| |
returns the first element in the derived view. Provided if it satisfies forward_range . (public member function of std::ranges::view_interface<D> )
| |
returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range . (public member function of std::ranges::view_interface<D> )
| |
returns the n th element in the derived view. Provided if it satisfies random_access_range . (public member function of std::ranges::view_interface<D> )
|
Deduction guides
Helper templates
template<class T> inline constexpr bool enable_borrowed_range<std::ranges::drop_view<T>> = |
(since C++20) | |
This specialization of std::ranges::enable_borrowed_range makes drop_view
satisfy borrowed_range
when the underlying view satisfies it.
Example
Run this code
#include <ranges> #include <iostream> int main() { const auto nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; for (int i : nums | std::views::drop(2)) std::cout << i << ' '; std::cout << '\n'; for (int i : std::views::iota(1, 10) | std::views::drop(2)) std::cout << i << ' '; std::cout << '\n'; for (int i : std::ranges::drop_view{nums, 2}) std::cout << i << ' '; std::cout << '\n'; }
Output:
3 4 5 6 7 8 9 3 4 5 6 7 8 9 3 4 5 6 7 8 9
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 3494 | C++20 | drop_view was never a borrowed_range
|
it is a borrowed_range if its underlying view is
|
LWG 3407 | C++20 | views::drop sometimes fails to constructa sized random access range |
the construction is adjusted so that it is always valid |
See also
a view consisting of the elements of another view , skipping the initial subsequence of elements until the first element where the predicate returns false(class template) (range adaptor object) |