std::ranges::starts_with

Определён в заголовочном файле `<algorithm>`
Сигнатура вызова
template< std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> constexpr bool starts_with( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(1)	(начиная с C++23)
template< ranges::input_range R1, ranges::input_range R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> constexpr bool starts_with( R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(2)	(начиная с C++23)
template< /execution-policy/ Ep, std::random_access_iterator I1, std::sized_sentinel_for<I1> S1, std::random_access_iterator I2, std::sized_sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> bool starts_with( Ep&& policy, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});	(3)	(начиная с C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R1, /sized-random-access-range/ R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> bool starts_with( Ep&& policy, R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});	(4)	(начиная с C++26)

Определение /*execution-policy*/ см. на этой странице; определение /*sized-random-access-range*/ см. на этой странице.

Проверяет, совпадает ли целевой диапазон с префиксом исходного диапазона. Элементы (спроецированные с помощью proj1 и proj2 соответственно) сравниваются с использованием бинарного предиката pred.

1) Исходный диапазон — [first1, last1), а целевой диапазон — [first2, last2).

2) Исходный диапазон — r1, а целевой диапазон — r2.

3,4) То же, что и (1,2), но выполняется в соответствии с policy.

Описанные на этой странице функциональные объекты — это функциональные объекты алгоритмов (неофициально называемые niebloids), то есть:

При вызове любого из них нельзя указать явный список аргументов шаблона.
Ни один из них не виден для поиска, зависящего от аргументов.
Если любой из них найден посредством обычного неквалифицированного поиска как имя слева от оператора вызова функции, поиск, зависящий от аргументов, подавляется.

Параметры

first1, last1	-	пара итератор–сентинел, задающая исходный диапазон
first2, last2	-	пара итератор–сентинел, задающая целевой диапазон
r1	-	исходный диапазон
r2	-	целевой диапазон
pred	-	предикат, применяемый к (спроецированным) элементам
proj1	-	проекция, применяемая к элементам исходного диапазона
proj2	-	проекция, применяемая к элементам целевого диапазона
policy	-	политика выполнения, которая будет использоваться

Возвращаемое значение

true, если целевой диапазон совпадает с префиксом исходного диапазона, и false в противном случае.

Сложность

Пусть

\(\scriptsize N_1\)N₁ — ranges::distance(first1, last1) или ranges::distance(r1), а
\(\scriptsize N_2\)N₂ — ranges::distance(first2, last2) или ranges::distance(r2):

1,2) Не более \(\scriptsize \min(N_1,N_2)\)min(N₁,N₂) применений pred, proj1 и proj2.

3,4) \(\scriptsize \mathcal{O}(\min(N_1,N_2))\)𝓞(min(N₁,N₂)) применений pred, proj1 и proj2.

Исключения

3,4) Во время выполнения:

Если требуемые для параллельного выполнения временные ресурсы памяти недоступны, выбрасывается std::bad_alloc.
Если при доступе к объектам через аргумент алгоритма возникает необработанное исключение, поведение определяется политикой выполнения (для стандартных политик вызывается std::terminate).

Примечания

Макрос для проверки поддержки возможностей	Значение	Стандарт	Возможность
`__cpp_lib_ranges_starts_ends_with`	`202106L`	(C++23)	`std::ranges::starts_with`, `std::ranges::ends_with`

Возможная реализация

struct starts_with_fn
{
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::input_iterator I2, std::sentinel_for<I2> S2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
        requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
    constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2,
                              Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return ranges::mismatch(std::move(first1), last1, std::move(first2), last2,
                                std::move(pred), std::move(proj1), std::move(proj2)
                               ).in2 == last2;
    }
    
    template<ranges::input_range R>
    constexpr auto get_end(R&& r)
    {
        return ranges::end(r);
    }
    
    template<ranges::forward_range R>
    constexpr auto get_end(R&& r)
    {
        return ranges::next(ranges::begin(r), ranges::end(r));
    }
    
    template<ranges::input_range R1, ranges::input_range R2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
        requires std::indirectly_comparable<ranges::iterator_t<R1>,
                                            ranges::iterator_t<R2>,
                                            Pred, Proj1, Proj2>
    constexpr bool operator()(R1&& r1, R2&& r2,
                              Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), get_end(r1),
                       ranges::begin(r2), get_end(r2),
                       std::move(pred), std::move(proj1), std::move(proj2));
    }
};

inline constexpr starts_with_fn starts_with{};

Пример

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

int main()
{
    using namespace std::literals;
    
    constexpr auto ascii_upper = [](char8_t c)
    {
        return u8'a' <= c && c <= u8'z' ? static_cast<char8_t>(c + u8'A' - u8'a') : c;
    };
    
    constexpr auto cmp_ignore_case = [=](char8_t x, char8_t y)
    {
        return ascii_upper(x) == ascii_upper(y);
    };
    
    static_assert(std::ranges::starts_with("const_cast", "const"sv));
    static_assert(std::ranges::starts_with("constexpr", "const"sv));
    static_assert(!std::ranges::starts_with("volatile", "const"sv));
    
    std::cout << std::boolalpha
              << std::ranges::starts_with(u8"Constantinopolis", u8"constant"sv,
                                          {}, ascii_upper, ascii_upper) << ' '
              << std::ranges::starts_with(u8"Istanbul", u8"constant"sv,
                                          {}, ascii_upper, ascii_upper) << ' '
              << std::ranges::starts_with(u8"Metropolis", u8"metro"sv,
                                          cmp_ignore_case) << ' '
              << std::ranges::starts_with(u8"Acropolis", u8"metro"sv,
                                          cmp_ignore_case) << '\n';
    
    constexpr static auto v = { 1, 3, 5, 7, 9 };
    constexpr auto odd = [](int x) { return x % 2; };
    static_assert(std::ranges::starts_with(v, std::views::iota(1)
                                            | std::views::filter(odd)
                                            | std::views::take(3)));
}

Вывод:

true false true false

См. также

ranges::ends_with (C++23)	проверяет, заканчивается ли диапазон другим диапазоном (функциональный объект алгоритма)
ranges::mismatch (C++20)	находит первую позицию, в которой два диапазона различаются (функциональный объект алгоритма)
starts_with (C++20)	проверяет, начинается ли строка с заданного префикса (открытая функция-член `std::basic_string<CharT,Traits,Allocator>`)
starts_with (C++20)	проверяет, начинается ли string view с заданного префикса (открытая функция-член `std::basic_string_view<CharT,Traits>`)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/algorithm/ranges/starts_with