std::ranges::contains, std::ranges::contains_subrange

Определено в заголовке `<algorithm>`
Сигнатура вызова
template< std::input_iterator I, std::sentinel_for<I> S, class T, class Proj = std::identity > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr bool contains( I first, S last, const T& value, Proj proj = {} );	(1)	(начиная с C++23) (до C++26)
template< std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr bool contains( I first, S last, const T& value, Proj proj = {} );	(1)		(начиная с C++26)
template< ranges::input_range R, class T, class Proj = std::identity > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr bool contains( R&& r, const T& value, Proj proj = {} );	(2)	(начиная с C++23) (до C++26)
template< ranges::input_range R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr bool contains( R&& r, const T& value, Proj proj = {} );	(2)		(начиная с C++26)
template< std::forward_iterator I1, std::sentinel_for<I1> S1, std::forward_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 contains_subrange( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(3)	(начиная с C++23)
template< ranges::forward_range R1, ranges::forward_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 contains_subrange( R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(4)	(начиная с C++23)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> bool contains( Ep&& policy, I first, S last, const T& value, Proj proj = {} );	(5)	(начиная с C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> bool contains( Ep&& policy, R&& r, const T& value, Proj proj = {} );	(6)	(начиная с C++26)
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 contains_subrange( Ep&& policy, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(7)	(начиная с 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 contains_subrange( Ep&& policy, R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(8)	(начиная с C++26)

За определением /*execution-policy*/ обратитесь на эту страницу; за определением /*sized-random-access-range*/ обратитесь на эту страницу.

1,2) Проверяет, содержит ли исходный диапазон целевое значение value.

1) Исходный диапазон — это [first, last).

2) Исходный диапазон — это r.

3,4) Проверяет, является ли целевой диапазон поддиапазоном исходного диапазона.

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

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

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

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

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

Параметры

first/first1, last/last1	-	пара итератор-страж, определяющая исходный диапазон
first2, last2	-	пара итератор-страж, определяющая целевой диапазон
r/r1	-	исходный диапазон
value	-	целевое значение
r2	-	целевой диапазон
pred/pred1	-	предикат, применяемый к (спроецированным) элементам исходного диапазона
pred2	-	предикат, применяемый к (спроецированным) элементам целевого диапазона
proj/proj1	-	проекция, применяемая к элементам исходного диапазона
proj2	-	проекция, применяемая к элементам целевого диапазона
policy	-	политика выполнения для использования

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

1) ranges::find(std::move(first), last, value, proj) != last

2) ranges::find(r, value, proj) != ranges::end(r)

3) first2 == last2 || !ranges::search(first1, last1, first2, last2, pred, proj1, proj2).empty()

4) ranges::empty(r2) || !ranges::search(r1, r2, pred, proj1, proj2).empty()

5-8) То же, что и (1-4), но добавляет std::forward<Ep>(policy) в список аргументов ranges::find или ranges::search в качестве первого аргумента.

Сложность

Пусть

$\scriptsize N$ $N$ равно ranges::distance(first, last) или ranges::distance(r),
$\scriptsize N_1$ $N 1$ равно ranges::distance(first1, last1) или ranges::distance(r1), и
$\scriptsize N_2$ $N 2$ равно ranges::distance(first2, last2) или ranges::distance(r2):

1,2) Не более

N

сравнений и применений proj.

3,4) Не более

N 1 \cdotN 2

применений pred и proj.

5,6)

𝓞(N)

сравнений и применений proj.

7,8)

𝓞(N 1 \cdotN 2)

применений pred и proj.

Исключения

5-8) Во время выполнения:

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

Примечания

В C++20 можно реализовать contains с помощью ranges::find(haystack, needle) != ranges::end(haystack) или contains_subrange с помощью !ranges::search(haystack, needle).empty().

ranges::contains_subrange, как и ranges::search, и в отличие от std::search, не поддерживает поисковики (такие как std::boyer_moore_searcher).

Макрос тестирования возможности	Значение	Стандарт	Возможность
`__cpp_lib_ranges_contains`	`202207L`	(C++23)	`ranges::contains` и `ranges::contains_subrange`
`__cpp_lib_algorithm_default_value_type`	`202403L`	(C++26)	Списочная инициализация для алгоритмов (1,2)

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

contains (1,2)

struct contains_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity,
             class T = std::projected_value_t<I, Proj>>
    requires std::indirect_binary_predicate
                 <ranges::equal_to, std::projected<I, Proj>, const T*>
    constexpr bool operator()(I first, S last, const T& value, Proj proj = {}) const
    {
        return ranges::find(std::move(first), last, value, proj) != last;
    }
    
    template<ranges::input_range R,
             class Proj = std::identity,
             class T = std::projected_value_t<ranges::iterator_t<R>, Proj>>
    requires std::indirect_binary_predicate
                 <ranges::equal_to,
                  std::projected<ranges::iterator_t<R>, Proj>, const T*>
    constexpr bool operator()(R&& r, const T& value, Proj proj = {}) const
    {
        return ranges::find(r, value, proj) != ranges::end(r);
    }
};

inline constexpr contains_fn contains{};

contains_subrange (3,4)

struct contains_subrange_fn
{
    template<std::forward_iterator I1, std::sentinel_for<I1> S1,
             std::forward_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 (first2 == last2) ||
                   !ranges::search(first1, last1, first2, last2,
                                   pred, proj1, proj2).empty();
    }
    
    template<ranges::forward_range R1, ranges::forward_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 ranges::empty(r2) ||
                   !ranges::search(r1, r2, pred, proj1, proj2).empty();
    }
};

inline constexpr contains_subrange_fn contains_subrange{};

Пример

Запустить этот код

#include <algorithm>
#include <array>
#include <complex>

namespace ranges = std::ranges;

int main()
{
    constexpr auto haystack = std::array{3, 1, 4, 1, 5};
    constexpr auto needle = std::array{1, 4, 1};
    constexpr auto bodkin = std::array{2, 5, 2};
    
    static_assert
    (
        ranges::contains(haystack, 4) &&
       !ranges::contains(haystack, 6) &&
        ranges::contains_subrange(haystack, needle) &&
       !ranges::contains_subrange(haystack, bodkin)
    );
    
    constexpr std::array<std::complex<double>, 3> nums{{{1, 2}, {3, 4}, {5, 6}}};
    #ifdef __cpp_lib_algorithm_default_value_type
        static_assert(ranges::contains(nums, {3, 4}));
    #else
        static_assert(ranges::contains(nums, std::complex<double>{3, 4}));
    #endif
}

См. также

ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	находит первый элемент, удовлетворяющий определённым критериям (объект функции алгоритма)
ranges::search (C++20)	ищет первое вхождение диапазона элементов (объект функции алгоритма)
ranges::binary_search (C++20)	определяет, существует ли элемент в диапазоне, используя двоичный поиск (объект функции алгоритма)
ranges::includes (C++20)	определяет, является ли одна последовательность подпоследовательностью другой (объект функции алгоритма)
ranges::all_ofranges::any_ofranges::none_of (C++20)(C++20)(C++20)	проверяет, выполняется ли предикат `true` для всех, хотя бы одного или ни одного из элементов диапазона (объект функции алгоритма)

Поддержка компиляторов
Автономное и хостированное
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Именованные требования
Макросы тестирования возможностей (C++20)
Библиотека поддержки языка
Библиотека концепций (C++20)
Библиотека диагностики
Библиотека управления памятью
Библиотека метапрограммирования (C++11)
Библиотека общих утилит
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека строк
Библиотека обработки текста
Библиотека численных операций
Библиотека даты и времени
Библиотека ввода/вывода
Библиотека файловой системы (C++17)
Библиотека поддержки параллелизма (C++11)
Библиотека управления выполнением (C++26)
Технические спецификации
Указатель символов
Внешние библиотеки

ru.cppreference.net

Namespaces

Variants