std::all_of, std::any_of, std::none_of

Défini dans l'en-tête `<algorithm>`
template< class InputIt, class UnaryPred > bool all_of( InputIt first, InputIt last, UnaryPred p );	(1)	(depuis C++11) (constexpr depuis C++20)
template< class InputIt, class UnaryPred > bool any_of( InputIt first, InputIt last, UnaryPred p );	(2)	(depuis C++11) (constexpr depuis C++20)
template< class InputIt, class UnaryPred > bool none_of( InputIt first, InputIt last, UnaryPred p );	(3)	(depuis C++11) (constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt, class UnaryPred > bool all_of( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPred p );	(4)	(depuis C++17)
template< class ExecutionPolicy, class ForwardIt, class UnaryPred > bool any_of( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPred p );	(5)	(depuis C++17)
template< class ExecutionPolicy, class ForwardIt, class UnaryPred > bool none_of( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPred p );	(6)	(depuis C++17)

1) Vérifie si le prédicat unaire p retourne true pour tous les éléments de la plage [first, last).

2) Vérifie si le prédicat unaire p retourne true pour au moins un élément de la plage [first, last).

3) Vérifie si le prédicat unaire p retourne true pour aucun des éléments de la plage [first, last).

4-6) Identique à (1-3), mais exécuté selon 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 d'éléments à examiner
policy	-	la politique d'exécution à utiliser
p	-	prédicat unaire . L'expression `p(v)` doit être convertible en `bool` pour chaque argument `v` de type (éventuellement const) `VT`, où `VT` est le type de valeur de `InputIt`, indépendamment de la catégorie de valeur, et ne doit pas modifier `v`. Ainsi, un type de paramètre de `VT&`n'est pas autorisé, ni `VT` sauf si pour `VT` un déplacement équivaut à une copie(depuis C++11).
Exigences de type
- `InputIt` doit satisfaire les exigences de LegacyInputIterator.
- `ForwardIt` doit satisfaire les exigences de LegacyForwardIterator.
- `UnaryPred` doit satisfaire les exigences de Predicate.

Valeur de retour

La plage a un `true` élément	Oui		Non
La plage a un `false` élément	Oui	Non	Oui	Non^[1]
`all_of`	`false`	`true`	`false`	`true`
`any_of`	`true`	`true`	`false`	`false`
`none_of`	`false`	`false`	`true`	`true`

↑ La plage est vide dans ce cas.

Complexité

1-6) Au plus std::distance(first, last) applications de p.

Exceptions

4-6) Pendant le processus d'exécution :

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

Notes

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_parallel_algorithm`	`202506L`	(C++26)	Algorithmes de plage parallèles, (4-6)

Implémentation possible

Voir aussi les implémentations de

all_of dans libstdc++ et libc++.
any_of dans libstdc++ et libc++.
none_of dans libstdc++ et libc++.

all_of
template<class InputIt, class UnaryPred> constexpr bool all_of(InputIt first, InputIt last, UnaryPred p) { return std::find_if_not(first, last, p) == last; }
any_of
template<class InputIt, class UnaryPred> constexpr bool any_of(InputIt first, InputIt last, UnaryPred p) { return std::find_if(first, last, p) != last; }
none_of
template<class InputIt, class UnaryPred> constexpr bool none_of(InputIt first, InputIt last, UnaryPred p) { return std::find_if(first, last, p) == last; }

Exemple

Exécuter ce code

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
 
int main()
{
    std::vector<int> v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout << "Among the numbers: ";
    std::copy(v.cbegin(), v.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    
    if (std::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; }))
        std::cout << "All numbers are even\n";
    
    using namespace std::placeholders;
    if (std::none_of(v.cbegin(), v.cend(), std::bind(std::modulus<>(), _1, 2)))
        std::cout << "None of them are odd\n";
    
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : d(n) {}
        bool operator()(int n) const { return n % d == 0; }
    };
    
    if (std::any_of(v.cbegin(), v.cend(), DivisibleBy(7)))
        std::cout << "At least one number is divisible by 7\n";
}

Sortie :

Among the numbers: 2 4 6 8 10 12 14 16 18 20
All numbers are even
None of them are odd
At least one number is divisible by 7

Voir aussi

ranges::all_ofranges::any_ofranges::none_of

(C++20)(C++20)(C++20)

vérifie si un prédicat est true pour tous, certains ou aucun des éléments d'une plage
(objet fonction d'algorithme)

[1] La plage est vide dans ce cas.

[1]

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 de la 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 plages (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ème de fichiers (C++17)
Bibliothèque de support de la 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