C ++ STD pour la boucle

«Les boucles STD :: For-out sont une capacité différente qui sert le même objectif que les techniques de boucle générale comme« pour »,« while »et« do-while »qui sont soutenues par la langue C ++. Cette boucle prend une fonction qui parcourt chaque élément du conteneur avant de revenir. Pour que cette boucle fonctionne, elle doit être incluse car elle est spécifiée dans le fichier d'en-tête «algorithme»: #include chaque fois que vous irez à travers les éléments d'un tableau ou d'un conteneur et effectuez diverses opérations sur eux, comme l'accès, le changement, etc. Bien que vous puissiez obtenir le même résultat en entrant dans l'ensemble pour Loop, l'utilisation de cette méthode vous fera gagner du temps, réduira le nombre de codes de programme et réduira la probabilité de certains bogues."

Syntaxe de Std :: for_Each () boucle en c++

La syntaxe de STD :: pour chaque boucle (), nous avons déployé en C ++ est la suivante:

for_each (Begin_iterator, end_iterator, func)

Où Func est une fonction à un paramètre qui prend chaque élément de la gamme [commencer, fin] comme argument, et commence et finit les itérateurs d'entrée faisant référence aux points de départ et de finition de la région dans la séquence pour évaluer. Ci-dessous, nous avons expliqué la fonctionnalité de chaque paramètre.

Begin_iterator: un itérateur d'entrée faisant référence à la première position dans la séquence que nous utilisons pour l'évaluation qui commence la plage.

end_iterator: Un itérateur d'entrée fait référence à la fin de la plage dans la séquence d'évaluation que nous utilisons.

Func: une fonction avec un argument qui prend chaque composant de la plage [début, fin] comme argument. Le paramètre de la fonction peut être fourni soit «par-référence» ou «par valeur."Cette fonction peut ou non produire un résultat.

Exemple 1

Regardons un exemple simple où nous utilisons la fonction std :: pour chaque () pour sortir chaque élément à l'intérieur de la plage [start, fin].

#inclure
#inclure
#inclure
void display_item (int item)
std :: cout<
int main()
std :: tableau int_array = 2,4,6, -6,0,110, -2,77;
std :: cout<<"Displaying the items: \n";
std :: for_each (int_array.begin (), int_array.end (), display_item);
retour 0;

Le code commence à partir de la section d'en-tête. Nous avons trois fichiers d'en-tête de C++. Pour utiliser la boucle std :: for_each, nous avons ajouté le fichier d'en-tête d'algorithme. Ensuite, nous avons créé la fonction void comme affichage_item, qui prend un élément d'entrée du type de données int. À l'intérieur de cette fonction, nous n'avons que la commande std :: cout pour cette variable d'élément.

Ensuite, nous avons la fonction principale où nous avons déclaré et initialisé un tableau. La boucle std :: for_each est utilisée pour faire du vélo sur chaque élément du tableau donné. La fonction display_item est appelée pour afficher le tableau d'éléments dans la plage [commencer, fin] pour une seule fois.

Exemple 2

Utilisation de Std :: pour chacun pour apporter des modifications persistantes à la collection. La fonction fournie prend les paramètres «par-référence» pour modifier définitivement les éléments de la collection.

#inclure
#inclure
#inclure
void func_uppercase (std :: string & str_val)
pour (int i = 0; iif (str_val [i]> = 'a' et str_val [i] <= 'z')
str_val [i] = (char) (str_val [i] - 'a' + 'a');



int main()
std :: cout<<"output: \n";
std :: tableau str_array = "le", "programme", "de",
"C ++";
std :: for_each (str_array.begin (), str_array.end (), func_uppercase);
pour (int i = 0; istd :: cout<
retour 0;

Ici, dans l'étape initiale, nous avons importé les fichiers d'en-tête pour l'implémentation du programme. Après cela, nous avons construit une fonction FUNC_UPPERCASE pour transformer la chaîne de cas inférieure en chaîne de cas supérieure. Ensuite, nous avons déployé la méthode principale où nous avons défini un tableau de chaînes qui a toute la baisse. La boucle std :: for_each est utilisée pour itérer sur tous les caractères de chaîne. La boucle std :: for_each invoque la fonction func_uppercase comme un argument pour chaque caractère de chaîne dans la plage [begin, fin]. Après cela, nous avons une boucle pour imprimer tous les caractères de la chaîne après la conversion dans le haut du cas.

Vous pouvez visualiser dans l'écran de sortie que tous les caractères de chaîne minuscules sont transformés en majuscules.

Exemple 3

L'exemple qui suit utilise une fonction lambda pour augmenter chaque membre dans un vecteur avant de calculer sa somme en utilisant un opérateur surchargé () dans l'objet d'une fonction, également connu sous le nom de Functor.

#inclure
#inclure
#inclure
struct add
Add () add = 0;
void opérateur () (int n) add + = n;
int add;
;
int main()

STD :: Vector Nombres 4, 5, 1, 8, 16, 221;
std :: cout << "Numbers before: ";
pour (auto n: nombres)
std :: cout << n << " ";

std :: cout << '\n';
std :: for_each (nombres.begin (), nombres.end (), [] (int & n) n ++; );
Ajouter a = std :: for_each (nombres.begin (), nombres.end (), add ());
std :: cout << "Numbers after: ";
pour (auto n: nombres)
std :: cout << n << " ";

std :: cout << '\n';
std :: cout << "Result: " << a.add << '\n';

Ici, nous avons établi une structure et attribué un nom ajouté. La fonction add () y est également définie, et à l'intérieur de cette fonction, nous initialisons la variable Ajouter avec le nombre zéro. De plus, la fonction vide est créée avec l'opérateur de nom, ce qui incrémente la valeur de n. Vient ensuite la méthode principale de ce programme.

À l'intérieur de la méthode principale, nous avons déclaré la classe vectorielle où nous avons initialisé la liste des nombres aléatoires. Nous avons imprimé les nombres en utilisant la boucle pour. Après cela, nous avons Std :: For_Each Loop pour l'itération sur chaque élément de la liste des nombres, puis chaque élément de la liste est incrémenté. Nous avons imprimé les nombres après l'opération de boucle For_Each. En fin de compte, nous avons affiché la somme des nombres en créant l'objet en invoquant la variable ADD.

Les nombres sont générés avant et après la boucle For_Each comme sortie. De plus, la somme des nombres s'affiche ci-dessous.

Exemple 4

L'impression d'élément dans n'importe quel conteneur est possible avec la fonction std :: for_each. Pour comprendre comment l'utiliser, voyez l'exemple où nous avons imprimé un vecteur et une carte ci-dessous.

#inclure
#inclure
#inclure
#inclure
Utilisation de Namespace Std;
void function_1 (int i)

couter << i << " ";

void function_2 (paire P1)

couter << p1.first << "->" << p1.second << endl;

int main()

vecteur Array 2, 5, 1, 9, 3, 8;
carte map_val;
map_val ['a'] = 2;
map_val ['b'] = 3;
map_val ['c'] = 6;
map_val ['d'] = 5;
map_val ['e'] = 8;
map_val ['f'] = 9;
couter << "Displaying the vector\n";
pour_ach (tableau.begin (), tableau.end (), function_1);
couter << "\n";
couter << "Displaying the map\n";
for_each (map_val.begin (), map_val.end (), function_2);
couter << "\n";
retour 0;

Nous avons défini la fonction comme fonction_1 où la variable «i» est déclarée, et à l'intérieur de cette fonction, nous avons affiché le «i» avec la commande cout. Ensuite, nous avons construit une autre fonction comme fonction_2, qui est appelée la classe de paire, et définissait l'objet P. À l'intérieur de la fonction_2, nous avons défini chaque élément d'une paire pour la carte. Ensuite, dans la fonction principale, nous initialisons un tableau de vecteurs et des valeurs de cartographie. Ensuite, nous utilisons la boucle FOR_EACH pour les vecteurs et les cartes d'itération sur chaque élément.

L'exécution du programme ci-dessus a généré la sortie suivante.

Conclusion

Par conséquent, l'utilisation de std :: for_each () a l'avantage de fabriquer le niveau du produit du programme et de réduire la taille de la base de code. De plus, O (n) est la complexité temporelle. Vous pouvez utiliser std :: for_each () dans n'importe quelle situation où chaque élément doit subir beaucoup de traitement et a une grande base de code. Le plus flexible std :: for_each (). Tout type de conteneur peut être utilisé avec itération. En plus de std :: for_each (), il nous permet de créer un algorithme qui fonctionne avec un itérateur.