# std::ranges::views::drop_while, std::ranges::drop_while_view

> C++ Atlas: `cppatlas.com/w/cpp/ranges/drop_while_view` | Source: https://en.cppreference.com/w/cpp/ranges/drop_while_view | Domain: Ranges | Standards: C++20, C++23

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

## Official Specification Summary (cppreference)

```cpp
// 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 drop_while_view
    : public ranges::view_interface<drop_while_view<V, Pred>> // (1) (since C++20)

namespace views {
    inline constexpr /* unspecified */ drop_while = /* unspecified */;
} // (2) (since C++20)

// Call signature

template< ranges::viewable_range R, class Pred >
    requires /* see below */
constexpr ranges::view auto drop_while( R&& r, Pred&& pred ); // (since C++20)

template< class Pred >
constexpr /*range adaptor closure*/ drop_while( Pred&& pred ); // (since C++20)
```

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

2) *RangeAdaptorObject*. The expression `views::drop_while(e, f)` is expression-equivalent to `drop_while_view(e, f)` for any suitable subexpressions `e` and `f`.

`drop_while_view` models the concepts `contiguous_range`, `random_access_range`, `bidirectional_range`, `forward_range`, `input_range`, and `common_range` when the underlying view `V` models respective concepts. It also models `sized_range` if `ranges::forward_range<V>` and `std::sized_sentinel_for<ranges::sentinel_t<V>, ranges::iterator_t<V>>` are modeled.

### Data members

**Member name — Definition**

- `base_` (private): the underlying `view` of type `V` (exposition-only member object*)
- `pred_` (private): the underlying function object of type `copyable-box<Pred>` (until C++23) `movable-box<Pred>` (since C++23) (exposition-only member object*)
- `cache_` (private) (conditionally present): TODO: mension L4$, see notes. (exposition-only member object*)

### Member functions

- (constructor): constructs a `drop_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 an iterator or a sentinel to the end (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`. (public member function of `std::ranges::view_interface<D>`)
- `cbegin` (C++23): returns a constant iterator to the beginning of the range. (public member function of `std::ranges::view_interface<D>`)
- `cend` (C++23): returns a sentinel for the constant iterator of the range. (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. (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`. (public member function of `std::ranges::view_interface<D>`)
- `size`: returns the number of elements in the derived view. Provided if it satisfies `forward_range` and its sentinel and iterator type satisfy `sized_sentinel_for`. (public member function of `std::ranges::view_interface<D>`)
- `front`: returns the first element in the derived view. Provided if it satisfies `forward_range`. (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`. (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`. (public member function of `std::ranges::view_interface<D>`)

### Deduction guides

### Helper templates

```cpp
template< class T, class Pred >
constexpr bool enable_borrowed_range<std::ranges::drop_while_view<T, Pred>> =
    ranges::enable_borrowed_range<T>; // (since C++20)
```

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

### Notes

In order to provide the amortized constant time complexity required by the `range` concept, the result of `begin` is cached within the `drop_while_view` object. If the underlying range is modified after the first call to `begin()`, subsequent uses of the `drop_while_view` object might have unintuitive behavior.

### Example

```cpp
#include <iostream>
#include <ranges>
#include <string>
#include <string_view>

using std::operator""sv;

[[nodiscard]]
constexpr bool is_space(char p) noexcept
{
    auto ne = [p](auto q) { return p != q; };
    return !!(" \t\n\v\r\f" | std::views::drop_while(ne));
};

[[nodiscard("trims the output")]]
constexpr std::string_view trim_left(std::string_view const in) noexcept
{
    auto view = in | std::views::drop_while(is_space);
    return {view.begin(), view.end()};
}

[[nodiscard("trims the output")]]
constexpr std::string trim(std::string_view const in)
{
    auto view = in
              | std::views::drop_while(is_space)
              | std::views::reverse
              | std::views::drop_while(is_space)
              | std::views::reverse
              ;
    return {view.begin(), view.end()};
}

int main()
{
    static_assert(trim_left(" \n C++23") == "C++23"sv);

    constexpr auto src{" \f\n\t\r\vHello, C++20!\f\n\t\r\v "sv};
    static_assert(trim(src) == "Hello, C++20!");

    static constexpr auto v = {0, 1, 2, 3, 4, 5};
    for (int n : v | std::views::drop_while([](int i) { return i < 3; }))
        std::cout << n << ' ';
    std::cout << '\n';
}
```

Output:

```text
3 4 5
```

### 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_while_view` was never a `borrowed_range` | it is a `borrowed_range` if its underlying view is |

### See also

- [`ranges::drop_view`](https://en.cppreference.com/w/cpp/ranges/drop_view) (C++20), [`views::drop`](https://en.cppreference.com/w/cpp/ranges/drop_view): a `view` consisting of elements of another `view`, skipping the first N elements (class template) (range adaptor object)

---
Attribution: content from https://en.cppreference.com/w/cpp/ranges/drop_while_view (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.