std::find_first_of

Défini dans l'en-tête `<algorithm>`
template< class InputIt, class ForwardIt > InputIt find_first_of( InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2 );	(1)	(constexpr depuis 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 depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2 );	(3)	(depuis 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)	(depuis C++17)

Recherche dans la plage source [first1, last1) l'un des éléments de la plage cible [first2, last2).

1) Les éléments sont comparés en utilisant operator==.

2) Les éléments sont comparés en utilisant le prédicat binaire donné p.

3,4) Identique à (1,2), mais exécuté selon policy.

Ces surcharges participent à la résolution de surcharge uniquement si la valeur de l'expression suivante est true:

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(jusqu'à C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(depuis C++20)

Paramètres

first1, last1	-	la paire d'itérateurs définissant la plage source
first2, last2	-	la paire d'itérateurs définissant la plage cible
p	-	prédicat binaire qui retourne `true` si les éléments doivent être considérés comme égaux. La signature de la fonction de prédicat doit être équivalente à la suivante : `bool pred(const Type1 &a, const Type2 &b);` Bien que la signature n'ait pas besoin d'avoir `const &`, la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) `Type1` et `Type2` indépendamment de la catégorie de valeur (ainsi, `Type1 &` n'est pas autorisé, ni `Type1` sauf si pour `Type1` un déplacement équivaut à une copie(depuis C++11)). Les types `Type1` et `Type2` doivent être tels que les objets de types `ForwardIt1` et `ForwardIt2` puissent être déréférencés puis implicitement convertis respectivement en `Type1` et `Type2`.
policy	-	la politique d'exécution à utiliser
Exigences de type
- `InputIt` doit satisfaire les exigences de LegacyInputIterator.
- `ForwardIt` doit satisfaire les exigences de LegacyForwardIterator.
- `ForwardIt1` doit satisfaire les exigences de LegacyForwardIterator.
- `ForwardIt2` doit satisfaire les exigences de LegacyForwardIterator.
- `BinaryPred` doit satisfaire les exigences de BinaryPredicate.

Valeur de retour

Itérateur vers le premier élément de la plage source qui correspond à un élément de la plage cible.

Si la plage cible est vide ou si aucun élément correspondant n'est trouvé, last1 est retourné.

Complexité

Étant donné $\scriptsize N_1$ $N 1$ comme std::distance(first1, last1) et $\scriptsize N_2$ $N 2$ comme std::distance(first2, last2):

1) Au plus

N 1 \cdotN 2

comparaisons en utilisant operator==.

2) Au plus

N 1 \cdotN 2

applications de p.

3)

𝓞(N 1 \cdotN 2)

comparaisons en utilisant operator==.

4)

𝓞(N 1 \cdotN 2)

applications de p.

Exceptions

3,4) Pendant le processus d'exécution :

Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est lancée.
Si une exception non interceptée est lancée lors de l'accès aux objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour les politiques standard, std::terminate est invoquée).

Implémentation possible

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;
}

Exemple

Le code suivant recherche l'un des entiers spécifiés dans un vecteur d'entiers :

Exécuter ce code

#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);
}

Sortie :

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 }

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement tel que publié	Comportement correct
LWG 576	C++98	`first1` et `last1` devaient être des LegacyForwardIterators	ils doivent seulement être des LegacyInputIterators
LWG 1205	C++98	la valeur de retour n'était pas claire si la plage cible est vide	retourne `last1` dans ce cas

Voir aussi

ranges::find_first_of (C++20)	recherche l'un quelconque d'un ensemble d'éléments (objet fonction d'algorithme)
findfind_iffind_if_not (C++11)	trouve le premier élément satisfaisant des critères spécifiques (modèle de fonction & objet fonction d'algorithme)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque des concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque des utilitaires généraux
Bibliothèque des conteneurs
Bibliothèque des itérateurs
Bibliothèque des plages (C++20)
Bibliothèque des algorithmes
Bibliothèque des chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants