std::adjacent_find

Défini dans l'en‑tête `<algorithm>`
template< class ForwardIt > ForwardIt adjacent_find( ForwardIt first, ForwardIt last );	(1)	(constexpr depuis C++20)
template< class ForwardIt, class BinaryPred > ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPred p );	(2)	(constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt > ForwardIt adjacent_find( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last );	(3)	(depuis C++17)
template< class ExecutionPolicy, class ForwardIt, class BinaryPred > ForwardIt adjacent_find( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, BinaryPred p );	(4)	(depuis C++17)

Recherche dans la plage source [first, last) la première paire d'éléments adjacents satisfaisant la condition spécifiée.

1) Recherche la première paire d'éléments adjacents égaux. L'égalité est déterminée par operator==.

2) Recherche la première paire d'éléments adjacents satisfaisant le prédicat binaire donné p.

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

Ces surcharges ne participent à la résolution de surcharge que 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

first, last	-	la paire d'itérateurs définissant la plage source
p	-	prédicat binaire qui renvoie `true` si les éléments doivent être traités comme égaux. La signature du 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 accepter toutes les valeurs de type (éventuellement const) `Type1` et `Type2` quelle que soit la catégorie de valeur (ainsi, `Type1 &` n'est pas autorisé, pas plus que `Type1` sauf si `Type1` un déplacement est équivalent à une copie(depuis C++11)). Les types `Type1` et `Type2` doivent être tels qu'un objet de type `ForwardIt` puisse être déréférencé puis converti implicitement en chacun d'eux.
policy	-	la politique d'exécution à utiliser
Exigences de type
- `ForwardIt` doit satisfaire les exigences de LegacyForwardIterator.
- `BinaryPred` doit satisfaire les exigences de BinaryPredicate.

Valeur de retour

Le premier itérateur iter dans la plage source tel que l'expression suivante s'évalue à true:

1,3) bool(*iter == *std::next(iter))

2,4) bool(p(*iter, std::next(iter))

Si aucun itérateur de ce type n'est trouvé, last est renvoyé.

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):

1) Exactement

min(M+1,N-1)

comparaisons utilisant operator==.

2) Exactement

min(M+1,N-1)

applications du prédicat p.

3)

𝓞(N)

comparaisons utilisant operator==.

4)

𝓞(N)

applications du prédicat p.

Exceptions

3,4) Pendant l'exécution :

Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est levée.
Si une exception non interceptée est levé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é).

Implémentation possible

adjacent_find (1)

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

adjacent_find (2)

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

Exécuter ce code

#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 << "No matching adjacent elements\n";
    else
        std::cout << "The first adjacent pair of equal elements is at "
                  << 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 << "The entire vector is sorted in ascending order\n";
    else
        std::cout << "The last element in the non-decreasing subsequence is at "
                  << std::distance(v1.begin(), i2) << ", *i2 = " << *i2 << '\n';
}

Sortie :

The first adjacent pair of equal elements is at 4, *i1 = 40
The last element in the non-decreasing subsequence is at 7, *i2 = 41

Rapports de défauts

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

DR	Appliqué à	Comportement publié	Comportement correct
LWG 240	C++98	l'exigence de complexité était peu claire	rendue claire

Voir aussi

ranges::adjacent_find (C++20)	trouve les deux premiers éléments adjacents qui sont égaux (ou satisfont un prédicat donné) (objet fonction d'algorithme)
unique	supprime les éléments dupliqués consécutifs dans une plage (patron de fonction & objet fonction d'algorithme)
ranges::unique (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 linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de vues (ranges) (C++20)
Bibliothèque d'algorithmes
Bibliothèque de 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 de systèmes de fichiers (C++17)
Bibliothèque de support de 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