C ++ std for_each loop

"La std :: per i loop è una capacità diversa che serve lo stesso obiettivo delle tecniche di looping generale come" per "per", "while" e "do-while" che sono supportati dal linguaggio C ++. Questo ciclo prende una funzione che funziona attraverso ciascun elemento del contenitore prima di tornare. Affinché questo ciclo funzioni, deve essere incluso perché è specificato nel file di intestazione "Algoritmo": #include ogni volta che si iterirà attraverso gli elementi di un array o un contenitore e effettuare varie operazioni su di essi, come l'accesso, la modifica, ecc. Sebbene tu possa ottenere lo stesso risultato inserendo l'intero ciclo per loop, usando questo metodo ti farà risparmiare tempo, taglierà il numero di codici di programma e abbasserà la probabilità di alcuni bug."

Sintassi di std :: for_each () loop in c++

La sintassi di std :: per ogni () loop, abbiamo distribuito in C ++ è la seguente:

For_each (Begin_iterator, end_iterator, func)

Laddove il func è una funzione di un parametro che prende ogni elemento dall'intervallo [inizio, fine] come argomento, e l'inizio e la fine sono gli iteratori di input che si riferiscono ai punti di partenza e finitura della regione nella sequenza per valutare. Di seguito, abbiamo spiegato la funzionalità di ciascun parametro.

Begin_iterator: Un iteratore di input che si riferisce alla prima posizione nella sequenza che stiamo usando per la valutazione che inizia l'intervallo.

end_iterator: Un iteratore di input si riferisce alla fine dell'intervallo nella sequenza di valutazione che stiamo usando.

Func: Una funzione con un argomento che prende ogni componente dell'intervallo [avvio, fine] come argomento. Il parametro della funzione può essere fornito "per riferimento" o "per valore."Questa funzione potrebbe o non potrebbe produrre un risultato.

Esempio 1

Diamo un'occhiata a un esempio semplice in cui utilizziamo la funzione std :: per ogni () per produrre ogni elemento all'interno dell'intervallo [avvio, fine].

#includere
#includere
#includere
void display_item (int item)
std :: cout<
int main ()
Std :: Array int_array = 2,4,6, -6,0,110, -2,77;
std :: cout<<"Displaying the items: \n";
std :: for_each (int_array.inizio (), int_array.end (), display_item);
restituzione 0;

Il codice inizia dalla sezione di intestazione. Abbiamo tre file di intestazione di C++. Per l'utilizzo di std :: for_each loop, abbiamo aggiunto il file di intestazione dell'algoritmo. Quindi, abbiamo creato la funzione void come display_item, che prende un elemento di input del tipo di dati int. All'interno di quella funzione, abbiamo solo il comando std :: cout per questa variabile elemento.

Successivamente, abbiamo la funzione principale in cui abbiamo dichiarato e inizializzato un array. Il ciclo std :: for_each viene utilizzato per scorrere su ciascun elemento nell'array dato. La funzione Display_Item viene chiamata per visualizzare l'array di elementi all'interno dell'intervallo [inizio, fine] per una sola volta.

Esempio 2

Utilizzando std :: per ognuno di apportare alterazioni persistenti alla collezione. La funzione fornita prende i parametri "per riferimento" per modificare in modo permanente gli elementi della raccolta.

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



int main ()
std :: cout<<"output: \n";
Std :: Array str_array = "il", "programma", "di",
"C ++";
std :: for_each (str_array.inizio (), str_array.end (), func_uppercase);
per (int i = 0; istd :: cout<
restituzione 0;

Qui nel passaggio iniziale, abbiamo importato i file di intestazione per l'implementazione del programma. Successivamente, abbiamo costruito una funzione func_uppercase per trasformare la stringa minuscola nella stringa del caso superiore. Quindi, abbiamo distribuito il metodo principale in cui abbiamo definito una serie di stringhe che ha tutto il minuscolo. Il ciclo std :: for_each è usato per iterare su tutti i caratteri della stringa. Lo std :: for_each loop invoca la funzione func_uppercase come argomento per ogni carattere stringa nell'intervallo [inizio, fine]. Successivamente, abbiamo un ciclo per stampare tutti i caratteri della stringa dopo la conversione nella parte superiore del caso.

È possibile visualizzare nella schermata di output che tutti i caratteri della stringa minuscola vengono trasformati in maiuscolo.

Esempio 3

L'esempio che segue impiega una funzione Lambda per aumentare ciascun membro in un vettore prima di calcolare la loro somma usando un operatore sovraccarico () nell'oggetto di una funzione, noto anche come functor.

#includere
#includere
#includere
struct aggiungi
Add () add = 0;
void operator () (int n) add += n;
int add;
;
int main ()

Std :: Vector numeri 4, 5, 1, 8, 16, 221;
std :: cout << "Numbers before: ";
per (auto n: numeri)
std :: cout << n << " ";

std :: cout << '\n';
std :: for_each (numeri.inizio (), numeri.end (), [] (int & n) n ++; );
Aggiungi a = std :: for_each (numeri.inizio (), numeri.end (), add ());
std :: cout << "Numbers after: ";
per (auto n: numeri)
std :: cout << n << " ";

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

Qui, abbiamo stabilito una struttura e assegnato un nome aggiunto. La funzione add () è anche definita lì e all'interno di quella funzione, inizializziamo la variabile aggiunta con il numero zero. Inoltre, la funzione void viene creata con il nome operatore, che aumenta il valore di n. Quindi arriva il metodo principale di questo programma.

All'interno del metodo principale, abbiamo dichiarato la classe vettoriale in cui abbiamo inizializzato l'elenco dei numeri casuali. Abbiamo stampato i numeri usando il loop. Successivamente, abbiamo std :: for_each loop per l'iterazione su ciascun elemento nell'elenco dei numeri, quindi ogni elemento nell'elenco viene incrementato. Abbiamo stampato i numeri dopo l'operazione Loop For_each. Alla fine, abbiamo visualizzato la somma dei numeri creando l'oggetto come invocando la variabile ADD.

I numeri vengono generati prima e dopo il loop For_each come output. Inoltre, la somma dei numeri viene visualizzata di seguito.

Esempio 4

La stampa di elementi in qualsiasi contenitore è possibile con la funzione std :: for_each. Per capire come usarlo, vedere l'esempio in cui abbiamo stampato un vettore e una mappa qui sotto.

#includere
#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
void function_1 (int i)

cout << i << " ";

void function_2 (coppia P1)

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

int main ()

vettore array 2, 5, 1, 9, 3, 8;
carta geografica 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;
cout << "Displaying the vector\n";
for_each (array.inizio (), array.end (), function_1);
cout << "\n";
cout << "Displaying the map\n";
for_each (map_val.inizio (), map_val.end (), function_2);
cout << "\n";
restituzione 0;

Abbiamo definito la funzione come function_1 in cui è dichiarata la variabile "i" e all'interno di quella funzione, abbiamo visualizzato "i" con il comando cout. Quindi, abbiamo costruito un'altra funzione come function_2, che è chiamata classe coppia, e impostare l'oggetto p. All'interno della funzione_2, abbiamo definito ogni elemento in una coppia per la mappa. Quindi, all'interno della funzione principale, inizializziamo un array di vettori e anche i valori di mappa. Quindi, utilizziamo il loop For_each per i vettori e le mappe per l'iterazione su ciascun elemento.

L'esecuzione del programma sopra ha generato il seguente output.

Conclusione

Pertanto, l'utilizzo di std :: for_each () ha il vantaggio di creare il livello del prodotto e ridurre le dimensioni della base di codice. Inoltre, O (N) è la complessità temporale. Puoi usare std :: for_each () in qualsiasi situazione in cui ogni elemento deve passare attraverso un sacco di elaborazione e ha una base di codice grande. The più flessibile std :: for_each (). Qualsiasi tipo di contenitore può essere utilizzato con iterazione. Oltre a std :: for_each (), ci consente di creare un algoritmo che opera con un iteratore.