Appliquer un prédicat ou une fonction aux éléments d'une séquence en C++ - Bibliothèque STL

Les séquences sont très utiles pour stocker des éléments, mais parfois nous avons besoin d'un moyen de vérifier si tous ou certains éléments de la séquence vérifient un prédicat ou appliquent simplement une fonction sur chaque élément. Dans ce cours, nous découvrirons de nombreuses fonctions déjà définies dans la bibliothèque STL pour résoudre ces problèmes.

L'algorithme all_of détermine si chaque élément d'une séquence répond à certains critères spécifiés par l'utilisateur.

L'algorithme renvoie true si la séquence cible est vide ou si pred est true pour tous les éléments de la séquence ; sinon, il renvoie false.

Syntaxe

bool all_of([ep], it_debut, it_fin, pred);

Arguments

•  Une politique d'exécution std::execution facultative, ep (par défaut : std::execution ::seq)
•  Une paire d'objets InputIterator, it_debut et it_fin, représentant la séquence cible
•  Un prédicat unaire, pred, qui accepte un élément de la séquence cible.

Exemple 1

#include <iostream>   
#include <algorithm>    
#include <deque>       
using namespace std;

bool positif(int a){ return a>0; }

int main () {
  int vals1[] = {1,2,3,2,3,4,-5,13,8,9,6};
  int vals2[] = {1,2,3,2,3,4,5,13,8,9,6};
  deque<int> d1(vals1,vals1+11);  
  deque<int> d2(vals2,vals2+11);                      

  // Vérifier si tous les éléments sont positifs
  if(all_of(d1.begin(),d1.end(), positif)){
      cout<< "tous les éléments de d1 sont positifs";
  }
  else{
      cout<< "Il y a au moins un élément négatif ou nul dans d1";
  }
  cout<<'\n';

  if(all_of(d2.begin(),d2.end(), positif)){
      cout<< "tous les éléments de d2 sont positifs";
  }
  else{
      cout<< "Il y a au moins un élément négatif ou nul dans d2";
  }
  cout<<'\n';

  return 0;
}
        

Résultat

Il y a au moins un élément négatif ou nul dans d1
tous les éléments de d2 sont positifs
                

L'algorithme any_of détermine si un élément quelconque d'une séquence répond à certains critères spécifiés par l'utilisateur.

L'algorithme renvoie false si la séquence cible est vide ou si pred est true pour tout élément de la séquence ; sinon, il renvoie false.

Syntaxe

bool any_of([ep], it_debut, it_fin, pred);

Arguments

•  Une politique d'exécution std::execution facultative, ep (par défaut : std::execution ::seq)
•  Une paire d'objets InputIterator, it_debut et it_fin, représentant la séquence cible
•  Un prédicat unaire, pred, qui accepte un élément de la séquence cible.

Exemple 2

#include <iostream>   
#include <algorithm>    
#include <deque>     
using namespace std;

bool estpair(int a){ return a%2==0; }

int main () {
  int vals1[] = {1,2,3,2,3,4,5,13,8,9,6};
  int vals2[] = {1,5,3,9,3,13,5,13,21,9,35};
  deque<int> d1(vals1,vals1+11);  
  deque<int> d2(vals2,vals2+11);                      

  // Vérifier si la séquence d1 contient un nombre pair
  if(any_of(d1.begin(),d1.end(), estpair)){
      cout<< "La séquence d1 contient un nombre pair";
  }
  else{
      cout<< "La séquence d1 ne contient pas un nombre pair";
  }
  cout<<'\n';

  if(any_of(d2.begin(),d2.end(), estpair)){
      cout<< "La séquence d2 contient un nombre pair";
  }
  else{
      cout<< "La séquence d2 ne contient pas un nombre pair";
  }
  cout<<'\n';

  return 0;
}
        

Résultat

La séquence d1 contient un nombre pair
La séquence d2 ne contient pas un nombre pair
                

L'algorithme none_of détermine si aucun élément d'une séquence ne répond à certains critères spécifiés par l'utilisateur.

L'algorithme renvoie true si la séquence cible est vide ou si pred est true pour aucun élément de la séquence ; sinon, il renvoie false.

Syntaxe

bool none_of([ep], it_debut, it_fin, pred);

Arguments

•  Une politique d'exécution std::execution facultative, ep (par défaut : std::execution ::seq)
•  Une paire d'objets InputIterator, it_debut et it_fin, représentant la séquence cible
•  Un prédicat unaire, pred, qui accepte un élément de la séquence cible.

Exemple 3

#include <iostream>   
#include <algorithm>    
#include <deque>       
using namespace std;

bool estpair(int a){ return a%2==0; }

int main () {
  int vals1[] = {1,2,3,2,3,4,5,13,8,9,6};
  int vals2[] = {1,5,3,9,3,13,5,13,21,9,35};
  deque<int> d1(vals1,vals1+11);  
  deque<int> d2(vals2,vals2+11);                      

  // Vérifier si la séquence d1 ne contient aucun nombre pair
  if(none_of(d1.begin(),d1.end(), estpair)){
      cout<< "La séquence d1 ne contient pas un nombre pair";
  }
  else{
      cout<< "La séquence d1 contient un nombre pair";
  }
  cout<<'\n';

    
  if(none_of(d2.begin(),d2.end(), estpair)){
      cout<< "La séquence d2 ne contient pas un nombre pair";
  }
  else{
      cout<< "La séquence d2 contient un nombre pair";
  }
  cout<<'\n';

  return 0;
}
        

Résultat

La séquence d1 contient un nombre pair
La séquence d2 ne contient pas un nombre pair
                

L'algorithme for_each applique une fonction définie par l'utilisateur à chaque élément d'une séquence.

L'algorithme applique fct à chaque élément de la séquence cible. Bien que for_each soit considéré comme une opération de séquence non-modificatrice, si it_debut est un itérateur mutable, fct peut accepter un argument non-const. Toutes les valeurs que fct renvoie sont ignorées.

Si vous omettez ep, for_each retournera fct. Sinon, for_each renvoie void.

Syntaxe

for_each([ep], it_debut, it_fin, fct);

Arguments

•  Une politique d'exécution std::execution facultative, ep (par défaut : std::execution ::seq)
•  Une paire d'objets InputIterator, it_debut et it_fin, représentant la séquence cible
•  Une fonction unaire, fct, qui accepte un élément de la séquence cible.

Exemple 4

#include <iostream>   
#include <algorithm>    
#include <deque>       
using namespace std;

void afficher(int a){ cout << a << " "; }
void puissance(int p){ cout<< p*p << " "; }

int main () {
  int vals[] = {1,2,3,2,3,4,5,13,8,9,6};
  deque<int> v(vals,vals+11);                      

  // Utiliser foreach pour afficher les éléments d'une séquence
  for_each(v.begin(),v.end(), afficher);
  cout<<'\n';

  // Multiplier chaque élément par lui-même
  for_each(v.begin(),v.end(), puissance);
  cout<<'\n';

  return 0;
}
        

Résultat

1 2 3 2 3 4 5 13 8 9 6 
1 4 9 4 9 16 25 169 64 81 36
                

L'algorithme for_each_n applique une fonction définie par l'utilisateur aux n premiers éléments d'une séquence.

L'algorithme applique fct à chaque élément de la séquence cible. Bien que for_each_n soit considéré comme une opération de séquence non-modificatrice, si it_begin est un itérateur mutable, fct peut accepter un argument non-const. Toutes les valeurs que fct renvoie sont ignorées. Elle renvoie it_begin+n.

Syntaxe

InputIterator for_each_n([ep], it_begin, n, fct);

Arguments

•  Une politique d'exécution std::execution facultative, ep (par défaut : std::execution ::seq)
•  Un InputIterator it_debut représentant le premier élément de la séquence cible
•  Un nombre entier n représentant le nombre d'itérations souhaité pour que l'intervalle semi-ouvert représentant la séquence cible soit compris entre it_debut et it_debut+n.
•  Une fonction unaire fct qui accepte un élément de la séquence cible.

Exemple 5

#include <iostream>   
#include <algorithm>    
#include <deque>       
using namespace std;

void afficher(int a){ cout << a << " "; }
void puissance(int p){ cout<< p*p << " "; }

int main () {
  int vals[] = {1,2,3,2,3,4,5,13,8,9,6};
  deque<int> v(vals,vals+11);                      

  // Utiliser foreach pour afficher les 4 premiers éléments d'une séquence
  for_each_n(v.begin(), 4, afficher);
  cout<<'\n';

  // Multiplier les 4 premiers éléments par eux-mêmes
  for_each_n(v.begin(), 4, puissance);
  cout<<'\n';

  return 0;
}
        

Résultat

1 2 3 2 
1 4 9 4