std::ranges...s::take_view(3)

💅 std::ranges...s::take_view(3) 💅

okay bestie, welcome to the C++ Standard Libary manual page for std::ranges::views::take and std::ranges::take_view — manual name folded in right here near the top, no boring duplicated header line, periodt 💖.

🎀 NAME 🎀

std::ranges::views::take,std::ranges::take_view — std::ranges::views::take,std::ranges::take_view

✨ Synopsis ✨

Defined in header <ranges>.

template< ranges::view V >
class take_view
(1) (since C++20)
    : public ranges::view_interface<take_view<V>>
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)

1. A range adaptor that represents view of the elements from an underlying sequence, starting at the beginning and ending at a given bound.
2. 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, decay-copy(e)), if T is a ranges::empty_view, except that the evaluations of e and f are indeterminately sequenced;
• U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), if T is a specialization of std::span, std::basic_string_view, or ranges::subrange that models both random_access_range and sized_range, where U is
  • std::span<typename T::element_type>, if T is a specialization of std::span;
  • T, if T is a specialization of std::basic_string_view;
  • ranges::subrange<ranges::iterator_t<T>>, if T is a specialization of ranges::subrange;
  • ranges::iota_view(*ranges::begin(e), *(ranges::begin(e) + std::min<D>(ranges::distance(e), f))), if T is a specialization of ranges::iota_view that models both random_access_range and sized_range;
• otherwise, if T is a specialization of ranges::repeat_view:
  • views::repeat(*e.value_, std::min<D>(ranges::distance(e), f)), if (since C++23) T models sized_range; in that case e is evaluated only once;
  • views::repeat(*e.value_, static_cast<D>(e)) otherwise;
• otherwise, take_view(e, f).

In all cases, decltype((f)) must model 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.

🫶 Member functions 🫶

• constructor — constructs a take_view (C++20) (public member function)
• base — returns a copy of the underlying (adapted) view (C++20) (public member function)
• begin — returns an iterator to the beginning (C++20) (public member function)
• end — returns an iterator or a sentinel to the end (C++20) (public member function)
• size — returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range. (C++20) (public member function)

🌈 Inherited from std::ranges::view_interface 🌈

• empty — returns whether the derived view is empty. Provided if it satisfies sized_range or forward_range. (C++20) (public member function of std::ranges::view_interface<D>)
• cbegin — returns a constant iterator to the beginning of the range. (C++23) (public member function of std::ranges::view_interface<D>)
• cend — returns a sentinel for the constant iterator of the range. (C++23) (public member function of std::ranges::view_interface<D>)
• operator bool — returns whether the derived view is not empty. Provided if ranges::empty is applicable to it. (C++20) (public member function of std::ranges::view_interface<D>)
• data — gets the address of derived view's data. Provided if its iterator type satisfies contiguous_iterator. (C++20) (public member function of std::ranges::view_interface<D>)
• front — returns the first element in the derived view. Provided if it satisfies forward_range. (C++20) (public member function of std::ranges::view_interface<D>)
• back — returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range. (C++20) (public member function of std::ranges::view_interface<D>)
• operator[] — returns the n^th element in the derived view. Provided if it satisfies random_access_range. (C++20) (public member function of std::ranges::view_interface<D>)

🎀 Deduction guides 🎀

The page literally just has the heading Deduction guides here, bestie — no extra details to spill 🫶.

🦋 Nested classes 🦋

• sentinel — the sentinel type. (C++20) (exposition-only member class template*)

💜 Helper templates 💜

template< class T >
inline constexpr bool
(since C++20)
enable_borrowed_range<std::ranges::take_view<T>> =
    std::ranges::enable_borrowed_range<T>;

This specialization of std::ranges::enable_borrowed_range makes take_view satisfy borrowed_range when the underlying view satisfies it.

🌈 Example 🌈

// Run this code

#include <algorithm>
#include <iostream>
#include <ranges>

auto print = [](char x){ std::cout << x; };

int main()
{
    constexpr char pi[]{'3', '.', '1', '4', '1', '5', '9', '2'};

    std::ranges::for_each(pi | std::ranges::views::take(6), print);
    std::cout << '\n';

    // safely takes 8 chars only, i.e. min(pi.size(), 42)
    std::ranges::for_each(std::ranges::take_view{pi, 42}, print);

    std::cout << '\n';
}

👀 Output: 👀

3.1415
3.141592

💀 Defect reports 💀

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

• LWG 3407 — Applied to: C++20. Behavior as published: views::take sometimes failed to construct a sized random access range. Correct behavior: the result type is adjusted so that construction is always valid.
• LWG 3494 — Applied to: C++20. Behavior as published: take_view was never a borrowed_range. Correct behavior: it is a borrowed_range if its underlying view is.

👑 See also 👑

• views::counted — creates a subrange from an iterator and a count. (C++20) (customization point object)
• ranges::take_while_view, views::take_while — a view consisting of the initial elements of another view, until the first element on which a predicate returns false. (C++20) (class template) (range adaptor object)
• ranges::copy_n — copies a number of elements to a new location. (C++20) (niebloid)

---

source: http://cppreference.com · version/date: 2024.06.10 · page: std::ranges...s::take_view(3) — bye bestie, go slay your ranges 💖