std:: adjacent_find

Recherche dans la plage [ first , last ) deux éléments consécutifs égaux.

Paramètres

Valeur de retour

Un itérateur vers le premier de la première paire d'éléments identiques, c'est-à-dire le premier itérateur it tel que * it == * ( it + 1 ) pour (1,2) ou p ( * it, * ( it + 1 ) ) ! = false pour (3,4) .

Si aucun élément de ce type n'est trouvé, last est retourné.

Complexité

Soit result la valeur de retour de adjacent_find , \(\scriptsize M\) M comme std:: distance ( first, result ) et \(\scriptsize N\) N comme std:: distance ( first, last ) :

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
• Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levé.

Implémentation possible

template<class ForwardIt>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first)
        if (*first == *next)
            return first;
    return last;
}

template<class ForwardIt, class BinaryPred>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPred p)
{
    if (first == last)
        return last;
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first)
        if (p(*first, *next))
            return first;
    return last;
}

Exemple

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v1{0, 1, 2, 3, 40, 40, 41, 41, 5};
    auto i1 = std::adjacent_find(v1.begin(), v1.end());
    if (i1 == v1.end())
        std::cout << "Aucun élément adjacent correspondant\n";
    else
        std::cout << "La première paire adjacente d'éléments égaux se trouve à "
                  << std::distance(v1.begin(), i1) << ", *i1 = "
                  << *i1 << '\n';
    auto i2 = std::adjacent_find(v1.begin(), v1.end(), std::greater<int>());
    if (i2 == v1.end())
        std::cout << "Le vecteur entier est trié en ordre croissant\n";
    else
        std::cout << "Le dernier élément de la sous-séquence non décroissante se trouve à "
                  << std::distance(v1.begin(), i2) << ", *i2 = " << *i2 << '\n';
}

La première paire adjacente d'éléments égaux se trouve à 4, *i1 = 40
Le dernier élément de la sous-séquence non décroissante se trouve à 7, *i2 = 41

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.

Voir aussi