Namespaces
Variants

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

    From es.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
    Definido en el encabezado <experimental/ranges/algorithm>
    template < InputIterator I, Sentinel < I > S, class T, class Proj = ranges:: identity >

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

    Devuelve el primer elemento en el rango [ first , last ) que satisface criterios específicos:

    1) find busca un elemento cuyo valor proyectado sea igual a value (es decir, value == ranges:: invoke ( proj, * i ) ).
    3) find_if busca un elemento para cuyo valor proyectado el predicado p devuelve true (es decir, ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ) es true ).
    5) find_if_not busca un elemento para cuyo valor proyectado el predicado q devuelve false (es decir, ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ) es false ).
    2,4,6) Igual que (1,3,5) , pero utiliza r como el rango fuente, como si usara ranges:: begin ( r ) como first y ranges:: end ( r ) como last .

    No obstante las declaraciones representadas anteriormente, el número real y el orden de los parámetros de plantilla para las declaraciones de algoritmos no está especificado. Por lo tanto, si se utilizan argumentos de plantilla explícitos al llamar a un algoritmo, el programa probablemente no sea portable.

    Contenido

    Parámetros

    first, last - el rango de elementos a examinar
    r - el rango de elementos a examinar
    value - valor contra el cual comparar los elementos proyectados
    pred - predicado a aplicar a los elementos proyectados
    proj - proyección a aplicar a los elementos

    Valor de retorno

    Iterador al primer elemento que satisface la condición. Si no se encuentra dicho elemento, retorna un iterador que compara igual a last .

    Complejidad

    Como máximo last - first aplicaciones del predicado y proyección.

    Implementación posible

    Primera versión 
    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;
}
    Segunda versión 
    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;
}
    Tercera versión 
    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;
}

    Ejemplo

    Esta sección está incompleta
    Razón: sin ejemplo

    Véase también

    (C++11)
    		 encuentra el primer elemento que satisface un criterio específico
    (function template & objeto función de algoritmo)
    (C++20)(C++20)(C++20)
    		encuentra los primeros dos elementos adyacentes que son iguales (o satisfacen un predicado dado)
    (function template)
    		encuentra la última secuencia de elementos en un cierto rango
    (function template)
    		busca cualquiera de un conjunto de elementos
    (function template)
    		encuentra la primera posición donde dos rangos difieren
    (function template)
    		busca un rango de elementos
    (function template)