Namespaces
Variants

std::find_first_of

С ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы для диапазонов (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Операции, не изменяющие последовательность    
Пакетные операции
(C++17)
Операции поиска
Операции, изменяющие последовательность
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разделения
(C++11)    

Операции сортировки
Операции двоичного поиска
(по разбитым диапазонам)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции с кучей
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановки


Политики выполнения (C++17)
(только для пояснения*)(C++26)

Численные операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory> алгоритмы

Специализированные <random> алгоритмы
Библиотека C









 
Определено в заголовке <algorithm>
template< class InputIt, class ForwardIt >
InputIt find_first_of( InputIt first1, InputIt last1,
                       ForwardIt first2, ForwardIt last2 );
(1) (constexpr начиная с C++20)
template< class InputIt, class ForwardIt, class BinaryPred >
InputIt find_first_of( InputIt first1, InputIt last1,
                       ForwardIt first2, ForwardIt last2,
                       BinaryPred p );
(2) (constexpr начиная с C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt1 find_first_of( ExecutionPolicy&& policy,
                          ForwardIt1 first1, ForwardIt1 last1,
                          ForwardIt2 first2, ForwardIt2 last2 );
(3) (начиная с C++17)
template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryPred >
ForwardIt1 find_first_of( ExecutionPolicy&& policy,
                          ForwardIt1 first1, ForwardIt last1,
                          ForwardIt2 first2, ForwardIt2 last2,
                          BinaryPred p );
(4) (начиная с C++17)

Ищет в исходном диапазоне [first1, last1) любой из элементов целевого диапазона [first2, last2).

1) Элементы сравниваются с помощью operator==.
2) Элементы сравниваются с помощью заданного бинарного предиката p.
3,4) То же, что (1,2), но выполняется в соответствии с policy.
Эти перегрузки участвуют в разрешении перегрузки только если значение следующего выражения равно true:

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

(до C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

(начиная с C++20)

Параметры

first1, last1 - пара итераторов, определяющая исходный диапазон
first2, last2 - пара итераторов, определяющая целевой диапазон
p - бинарный предикат, который возвращает truetrue, если элементы следует считать равными.

Сигнатура предиката должна быть эквивалентна следующей:

bool pred(const Type1 &a, const Type2 &b);

Хотя сигнатура не обязательно должна содержать const &const &, функция не должна модифицировать переданные ей объекты и должна быть в состоянии принимать все значения типа (возможно, const) Type1 и Type2 независимо от категории значения (таким образом, Type1 & не допускается, как и Type1 если только для Type1 перемещение не эквивалентно копированию(начиная с C++11)).
Типы Type1 и Type2 должны быть такими, что объекты типов ForwardIt1 и ForwardIt2 можно разыменовать и затем неявно преобразовать в Type1 и Type2 соответственно. ​

policy - политика выполнения для использования
Требования к типам
-
InputIt должен удовлетворять требованиям LegacyInputIterator.
-
ForwardIt должен удовлетворять требованиям LegacyForwardIterator.
-
ForwardIt1 должен удовлетворять требованиям LegacyForwardIterator.
-
ForwardIt2 должен удовлетворять требованиям LegacyForwardIterator.
-
BinaryPred должен удовлетворять требованиям BinaryPredicate.

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

Итератор на первый элемент в исходном диапазоне, который соответствует элементу из целевого диапазона.

Если целевой диапазон пуст или такой элемент не найден, возвращается last1.

Сложность

Пусть N1 равно std::distance(first1, last1) и N2 равно std::distance(first2, last2):

1) Не более N1⋅N2 сравнений с помощью operator==.
2) Не более N1⋅N2 применений p.
3) 𝓞(N1⋅N2) сравнений с помощью operator==.
4) 𝓞(N1⋅N2) применений p.

Исключения

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

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

find_first_of (1)
template<class InputIt, class ForwardIt>
InputIt find_first_of(InputIt first1, InputIt last1,
                      ForwardIt first2, ForwardIt last2)
{
    for (; first1 != last1; ++first1)
        for (ForwardIt it = first2; it != last2; ++it)
            if (*first1 == *it)
                return first1;
    return last1;
}
find_first_of (2)
template<class InputIt, class ForwardIt, class BinaryPred>
InputIt find_first_of(InputIt first1, InputIt last1,
                      ForwardIt first2, ForwardIt last2,
                      BinaryPred p)
{
    for (; first1 != last1; ++first1)
        for (ForwardIt it = first2; it != last2; ++it)
            if (p(*first1, *it))
                return first1;
    return last1;
}

Пример

Следующий код ищет любое из указанных целых чисел в векторе целых чисел:

#include <algorithm>
#include <iostream>
#include <vector>

auto print_sequence = [](const auto id, const auto& seq, int pos = -1)
{
    std::cout << id << "{ ";
    for (int i{}; const auto& e : seq)
    {
        const bool mark{i == pos};
        std::cout << (i++ ? ", " : "");
        std::cout << (mark ? "[ " : "") << e << (mark ? " ]" : "");
    }
    std::cout << " }\n";
};

int main()
{
    const std::vector<int> v{0, 2, 3, 25, 5};
    const auto t1 = {19, 10, 3, 4};
    const auto t2 = {1, 6, 7, 9};
    
    auto find_any_of = [](const auto& v, const auto& t)
    {
        const auto result = std::find_first_of(v.begin(), v.end(),
                                               t.begin(), t.end());
        if (result == v.end())
        {
            std::cout << "No elements of v are equal to any element of ";
            print_sequence("t = ", t);
            print_sequence("v = ", v);
        }
        else
        {
            const auto pos = std::distance(v.begin(), result);
            std::cout << "Found a match (" << *result << ") at position " << pos;
            print_sequence(", where t = ", t);
            print_sequence("v = ", v, pos);
        }
    };
    
    find_any_of(v, t1);
    find_any_of(v, t2);
}

Вывод:

Found a match (3) at position 2, where t = { 19, 10, 3, 4 }
v = { 0, 2, [ 3 ], 25, 5 }
No elements of v are equal to any element of t = { 1, 6, 7, 9 }
v = { 0, 2, 3, 25, 5 }

Отчёты о дефектах

Следующие отчёты о дефектах, изменяющих поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Применено к Поведение в опубликованном виде Корректное поведение
LWG 576 C++98 first1 и last1 должны были быть LegacyForwardIteratorами они должны быть только LegacyInputIteratorами
LWG 1205 C++98 возвращаемое значение было неясным, если целевой диапазон пуст в этом случае возвращается last1

Смотрите также

ищет любой из набора элементов
(объект функции алгоритма)
находит первый элемент, удовлетворяющий определённым критериям
(шаблон функции & объект функции алгоритма)