| Defined in header <ranges>
|
||
| template< ranges::view V > class take_view : public ranges::view_interface<take_view<V>> |
(1) | (since C++20) |
| namespace views { inline constexpr /* unspecified */ take = /* unspecified */; } |
(2) | (since C++20) |
| Call signature |
||
| template< ranges::viewable_range R > requires /* see below */ constexpr ranges::view auto take( R&& r, ranges::range_difference_t<R> count ); |
(since C++20) | |
| template< class DifferenceType > constexpr /* range adaptor closure */ take( DifferenceType&& count ); |
(since C++20) | |
view of the elements from an underlying sequence, starting at the beginning and ending at a given bound.views::take is a RangeAdaptorObject. The expression views::take(e, f) results in a view that represents the first f elements from e. The result is not necessarily a take_view.
views::take(e, f) is expression-equivalent to (where T is std::remove_cvref_t<decltype((e))> and D is ranges::range_difference_t<decltype((e))>):
-
((void)f,, ifdecay-copy(e))Tis a ranges::empty_view, except that the evaluations ofeandfare indeterminately sequenced; -
U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), ifTis a specialization of std::span, std::basic_string_view, or ranges::subrange that models bothrandom_access_rangeandsized_range, whereUis
- std::span<typename T::element_type>, if
Tis a specialization of std::span; -
T, ifTis a specialization of std::basic_string_view; - ranges::subrange<ranges::iterator_t<T>>, if
Tis a specialization of ranges::subrange;
- std::span<typename T::element_type>, if
-
ranges::iota_view(*ranges::begin(e),, if
*(ranges::begin(e) + std::min<D>(ranges::distance(e), f)))Tis a specialization of ranges::iota_view that models bothrandom_access_rangeandsized_range;
|
(since C++23) |
- otherwise,
take_view(e, f).
std::convertible_to<D>.take_view models the concepts contiguous_range, random_access_range, bidirectional_range, forward_range, input_range, and sized_range when the underlying view V models respective concepts. It models common_range when the underlying view V models both random_access_range and sized_range.
Data members
| Member name | Definition |
base_ (private)
|
the underlying view of type V(exposition-only member object*) |
count_ (private)
|
the number of elements to take, of type ranges::range_difference_t<V> (exposition-only member object*) |
Member functions
constructs a take_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 nth element in the derived view. Provided if it satisfies random_access_range. (public member function of std::ranges::view_interface<D>) | |
Deduction guides
Nested classes
| (C++20) |
the sentinel type (exposition-only member class template*) |
Helper templates
| template< class T > constexpr bool enable_borrowed_range<std::ranges::take_view<T>> = ranges::enable_borrowed_range<T>; |
(since C++20) | |
This specialization of std::ranges::enable_borrowed_range makes take_view satisfy borrowed_range when the underlying view satisfies it.
Example
#include <algorithm>
#include <iostream>
#include <ranges>
int main()
{
namespace views = std::views;
auto print = [](char x){ std::cout << x; };
for (const char nums[]{'1', '2', '3'};
int n : views::iota(0, 5))
{
std::cout << "take(" << n << "): ";
// safely takes only upto min(n, nums.size()) elements:
std::ranges::for_each(nums | views::take(n), print);
std::cout << '\n';
}
}take(0):
take(1): 1
take(2): 12
take(3): 123
take(4): 123Defect 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::take sometimes failed toconstruct a sized random access range |
the result type is adjusted so that construction is always valid |
| LWG 3494 | C++20 | take_view was never a borrowed_range
|
it is a borrowed_range if its underlying view is
|
See also
| (C++20) |
creates a subrange from an iterator and a count (customization point object) |
a view consisting of the initial elements of another view, until the first element on which a predicate returns false(class template) (range adaptor object) | |
| (C++20) |
copies a number of elements to a new location (algorithm function object) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.