Namespaces
Variants

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

From 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 dans une plage
(modèle de fonction)