std::ranges::views::take_while, std::ranges::take_while_view

template< ranges::view V, class Pred > requires ranges::input_range<V> && std::is_object_v<Pred> && std::indirect_unary_predicate<const Pred, ranges::iterator_t<V>> class take_while_view : public ranges::view_interface<take_while_view<V, Pred>>	(1)	(since C++20)
namespace views { inline constexpr /unspecified/ take_while = /unspecified/; }	(2)	(since C++20)

1) A range adaptor that represents view of the first N elements from an underlying sequence, ending before the first element for which the predicate returns false.

2) The expression views::take_while(E, F) is expression-equivalent to take_while_view{E, F} for any suitable subexpressions E and F.

take_while_view models the concepts contiguous_range, random_access_range, bidirectional_range, forward_range, and input_range when the underlying view V models respective concepts.

Expression-equivalent

Expression e is expression-equivalent to expression f, if e and f have the same effects, either are both potentially-throwing or are both not potentially-throwing (i.e. noexcept(e) == noexcept(f)), and either are both constant subexpressions or are both not constant subexpressions.

Member functions

(constructor)	constructs a `take_while_view` (public member function)
base	returns a copy of the underlying (adapted) view (public member function)
pred	returns a reference to the stored predicate (public member function)
begin	returns an iterator to the beginning (public member function)
end	returns a sentinel representing the end (public member function)

Deduction guides

Nested classes

sentinel

the sentinel type
(public member class)

Example

Run this code

#include <ranges>
#include <iostream>
 
int main()
{
    for (int year : std::views::iota(2017)
                  | std::views::take_while([](int y) { return y <= 2020; })) {
        std::cout << year << ' ';
    }
    std::cout << '\n';
 
    const char idea[] {"Today is yesterday's tomorrow!.."};
    for (char x : std::ranges::take_while_view(idea, [](char c) { return c != '.'; })) {
        std::cout << x;
    }
    std::cout << '\n';
}

Output:

2017 2018 2019 2020 
Today is yesterday's tomorrow!

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Technical Specifications