Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::take_while_view
Defined in header <ranges>
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)
Call signature
template < ranges:: viewable_range R, class Pred >

requires /* see below */

constexpr ranges:: view auto take_while ( R && r, Pred && pred ) ;
(since C++20)
template < class Pred >
constexpr /*range adaptor closure*/ take_while ( Pred && pred ) ;
(since C++20)
1) A range adaptor that represents view of the elements from an underlying sequence, starting at the beginning and ending at the first element for which the predicate returns false .
2) RangeAdaptorObject . 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.

Contents

Data members

Member Description
V base_ (private) the underlying view
( exposition-only member object* )
copyable-box <Pred> (until C++23) movable-box <Pred> (since C++23) pred_ (private) the underlying function object
( exposition-only member object* )

Member functions

constructs a take_while_view
(public member function)
returns a copy of the underlying (adapted) view
(public member function)
returns a reference to the stored predicate
(public member function)
returns an iterator to the beginning
(public member function)
returns a sentinel representing the end
(public member function)
Inherited from std::ranges::view_interface
returns whether the derived view is empty, provided only 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 only 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 only 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 n th element in the derived view, provided only if it satisfies random_access_range
(public member function of std::ranges::view_interface<D> )

Deduction guides

Nested classes

the sentinel type
( exposition-only member class template* )

Notes

For forward_iterator s , views :: take_while ( v, pred ) is similar to ranges:: subrange { ranges:: begin ( v ) , ranges:: find_if_not ( v, pred ) } , but the latter invokes pred only during construction (while the former invokes pred each time a valid take_while iterator is compared to a sentinel).

Example

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

Output: 

2020 2021 2022 2023 2024 2025
Today is yesterday's tomorrow!

See also

(C++20)
a view consisting of the first N elements of another view
(class template) (range adaptor object)
(C++20)
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)