Namespaces
Variants

std::experimental::ranges:: find, std::experimental::ranges:: find_if, std::experimental::ranges:: find_if_not

From cppreference.net
C++
Experimental
Ranges
Algorithms library
Non-modifying sequence operations
find find_if find_if_not
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutations
**Note:** Le code C++ et les termes techniques n'ont pas été traduits conformément aux instructions, car ils font partie intégrante de la syntaxe du langage de programmation. Seul le texte descriptif a été traduit en français.
Défini dans l'en-tête <experimental/ranges/algorithm>
template < InputIterator I, Sentinel < I > S, class T, class Proj = ranges:: identity >

requires IndirectRelation < ranges:: equal_to <> , projected < I, Proj > , const T * >

I find ( I first, S last, const T & value, Proj proj = Proj { } ) ;
(1) (ranges TS)
template < InputRange R, class T, class Proj = ranges:: identity >

requires IndirectRelation < ranges:: equal_to <> ,
projected < ranges:: iterator_t < R > , Proj > , const T * >

ranges:: safe_iterator_t < R > find ( R && r, const T & value, Proj proj = Proj { } ) ;
(2) (ranges TS)
template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

IndirectUnaryPredicate < projected < I, Proj >> Pred >

I find_if ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
(3) (ranges TS)
template < InputRange R, class Proj = ranges:: identity ,

IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

ranges:: safe_iterator_t < R > find_if ( R && r, Pred pred, Proj proj = Proj { } ) ;
(4) (ranges TS)
template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

IndirectUnaryPredicate < projected < I, Proj >> Pred >

I find_if_not ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
(5) (ranges TS)
template < InputRange R, class Proj = ranges:: identity ,

IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

ranges:: safe_iterator_t < R > find_if_not ( R && r, Pred pred, Proj proj = Proj { } ) ;
(6) (ranges TS)

Retourne le premier élément de la plage [ first , last ) qui satisfait des critères spécifiques :

1) find recherche un élément dont la valeur projetée est égale à value (c'est-à-dire, value == ranges:: invoke ( proj, * i ) ).
3) find_if recherche un élément pour lequel le prédicat appliqué à la valeur projetée p renvoie true (c'est-à-dire, ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ) est true ).
5) find_if_not recherche un élément pour lequel le prédicat appliqué à la valeur projetée q retourne false (c'est-à-dire, ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ) est false ).
2,4,6) Identique à (1,3,5) , mais utilise r comme plage source, comme si on utilisait ranges:: begin ( r ) comme first et ranges:: end ( r ) comme last .

Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

Table des matières

Paramètres

first, last - la plage d'éléments à examiner
r - la plage d'éléments à examiner
value - valeur à comparer aux éléments projetés
pred - prédicat à appliquer aux éléments projetés
proj - projection à appliquer aux éléments

Valeur de retour

Itérateur vers le premier élément satisfaisant la condition. Si aucun élément de ce type n'est trouvé, retourne un itérateur qui compare égal à last .

Complexité

Au plus last - first applications du prédicat et de la projection.

Implémentation possible

Première version 
template<InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity>
    requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>, const T*>
I find(I first, S last, const T& value, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(proj, *first) == value)
            break;
    return first;
}
Deuxième version 
template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
I find_if(I first, S last, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *first)))
            break;
    return first;
}
Troisième version 
template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
I find_if_not(I first, S last, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (!ranges::invoke(pred, ranges::invoke(proj, *first)))
            break;
    return first;
}

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

(C++11)
trouve le premier élément satisfaisant des critères spécifiques
(modèle de fonction)
trouve les deux premiers éléments adjacents qui sont égaux (ou satisfont un prédicat donné)
(modèle de fonction)
trouve la dernière séquence d'éléments dans une certaine plage
(modèle de fonction)
recherche l'un quelconque d'un ensemble d'éléments
(modèle de fonction)
trouve la première position où deux plages diffèrent
(modèle de fonction)
recherche une plage d'éléments
(modèle de fonction)