Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies.


Politique de confidentialité
Introduction et syntaxe de base
Pointeurs et fonctions
Programmation OO
Structures de données
La bibliothèque standard (STL)

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

 

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.

Nous utilisons le mot algorithme dans ce cours pour faire référence à ce que fait la fonction.

Fonction all_of 

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
                

Fonction any_of 

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
                

Fonction none_of

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
                

Fonction for_each

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
                

Fonction for_each_n 

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
                

Partager ce cours avec tes amis :
Rédigé par ESSADDOUKI Mostafa
ESSADDOUKI
The education of the 21st century opens up opportunities to not merely teach, but to coach, mentor, nurture and inspire.