Namespaces
Variants

    std::experimental::ranges:: all_of, std::experimental::ranges:: any_of, std::experimental::ranges:: none_of

    From fr.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    all_of any_of none_of
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    **Note:** Aucune traduction n'a été effectuée car : - Le texte contenu dans les balises ` ` est du code C++ qui ne doit pas être traduit - Tous les termes spécifiques au C++ (template, InputRange, bool, any_of, etc.) doivent rester en anglais - Les balises HTML et leurs attributs ont été préservés - Le contenu correspond aux règles de non-traduction spécifiées
    Défini dans l'en-tête <experimental/ranges/algorithm>
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

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

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

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

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    bool any_of ( 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 >

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

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    bool none_of ( 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 >

    bool none_of ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(6) (ranges TS)
    1) Vérifie si le prédicat unaire pred renvoie true pour tous les éléments dans l'intervalle [ first , last ) .
    3) Vérifie si le prédicat unaire pred retourne true pour au moins un élément dans la plage [ first , last ) .
    5) Vérifie si le prédicat unaire pred retourne true pour aucun élément dans l'intervalle [ first , last ) .
    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 des éléments à examiner
    r - la plage des éléments à examiner
    pred - prédicat à appliquer aux éléments projetés
    proj - projection à appliquer aux éléments

    Valeur de retour

    1,2) true si pred retourne true pour tous les éléments de la plage, false sinon. Retourne true si la plage est vide.
    3,4) true si pred renvoie true pour au moins un élément dans la plage, false sinon. Renvoie false si la plage est vide.
    5,6) true si pred retourne true pour aucun élément dans la plage, false sinon. Retourne true si la plage est vide.

    Complexité

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

    Implémentation possible

    **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` 
    ` et ``, et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte en dehors de ces balises aurait été traduit, mais dans ce cas, il n'y a pas de texte à traduire en dehors du code.
    **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` 
    ` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte en dehors des balises de code aurait été traduit, mais dans cet extrait, il n'y a pas de texte à traduire en dehors du code C++.
    Première version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
bool all_of(I first, S last, Pred pred, Proj proj = Proj{})
{
    return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last;
}
template<InputRange R, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
bool all_of(R&& r, Pred pred, Proj proj = Proj{})
{
    return ranges::all_of(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
}
    Deuxième version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
bool any_of(I first, S last, Pred pred, Proj proj = Proj{})
{
    return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last;
}
template<InputRange R, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
bool any_of(R&& r, Pred pred, Proj proj = Proj{})
{
    return ranges::any_of(ranges::begin(r), ranges::end(r),
                          std::ref(pred), std::ref(proj));
}
    Troisième version 
    template<InputIterator I, Sentinel<I> S, class Proj = identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
bool none_of(I first, S last, Pred pred, Proj proj = Proj{})
{
    return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last;
}
template<InputRange R, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
bool none_of(R&& r, Pred pred, Proj proj = Proj{})
{
    return ranges::none_of(ranges::begin(r), ranges::end(r),
                           std::ref(pred), std::ref(proj));
}

    Exemple

    Exécuter ce code 
    #include <experimental/ranges/algorithm>
#include <experimental/ranges/iterator>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
namespace ranges = std::experimental::ranges;
int main()
{
    std::vector<int> v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout << "Parmi les nombres : ";
    ranges::copy(v, ranges::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    if (ranges::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; }))
        std::cout << "Tous les nombres sont pairs\n";
    if (ranges::none_of(v, std::bind(std::modulus<int>(), std::placeholders::_1, 2)))
        std::cout << "Aucun n'est impair\n";
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : d(n) {}
        bool operator()(int n) const { return n % d == 0; }
    };
    if (ranges::any_of(v, DivisibleBy(7)))
        std::cout << "Au moins un nombre est divisible par 7\n";
}

    Sortie : 

    Parmi les nombres : 2 4 6 8 10 12 14 16 18 20 
Tous les nombres sont pairs
Aucun n'est impair
Au moins un nombre est divisible par 7

    Voir aussi

    (C++11)(C++11)(C++11)
    		 vérifie si un prédicat est true pour tous, certains ou aucun des éléments d'une plage
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)(C++20)(C++20)