C ++ Std for_each Loop

„Die STD :: For-Each-Loops sind eine andere Fähigkeit, die das gleiche Ziel wie allgemeine Schleifentechniken wie„ für “,„ während “und„ Do-the-the “-Techniken dient, die von der C ++-Sprache unterstützt werden. Diese Schleife übernimmt eine Funktion, die vor der Rückkehr durch jedes Element des Containers verläuft. Damit diese Schleife funktioniert, muss sie enthalten sein, da sie in der Header -Datei „Algorithmus“ angegeben ist: #include, wenn Sie die Elemente eines Arrays oder eines Containers durchführen und verschiedene Operationen ausführen, wie z. B. Zugriff, Änderung usw. Obwohl Sie das gleiche Ergebnis erhalten, indem Sie die gesamte für die Schleife eingeben, sparen Sie diese Methode, schneiden Sie die Anzahl der Programmcodes ab und senken Sie die Wahrscheinlichkeit einiger Fehler.”

Syntax von Std :: for_each () Schleife in C++

Die Syntax von Std :: Für jede () Schleife, die wir in C ++ bereitgestellt haben, lautet wie folgt:

for_each (begin_iterator, end_iterator, func)

Dabei ist Func eine Ein-Parameter. Im Folgenden haben wir die Funktionalität jedes Parameters erklärt.

begin_iterator: Ein Eingangs -Iterator, der sich auf die erste Position in der Sequenz bezieht, die wir zur Bewertung verwenden, die den Bereich beginnt.

end_iterator: Ein Eingaberator bezieht sich auf das Ende des Bereichs in der von uns verwendeten Bewertungssequenz.

Func: Eine Funktion mit einem Argument, das jede Komponente des Bereichs [Start, Ende] als Argument nimmt. Der Parameter der Funktion kann entweder "By-Reference" oder "By-Wert" geliefert werden.Diese Funktion kann ein Ergebnis erzeugen oder nicht.

Beispiel 1

Schauen wir uns ein unkompliziertes Beispiel an, in dem wir die STD :: für jede () -Funktion verwenden, um jedes Element im Bereich [Start, Ende] auszugeben, um jedes Element auszugeben.

#enthalten
#enthalten
#enthalten
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.begin (), int_array.end (), display_item);
Rückkehr 0;

Der Code beginnt aus dem Header -Abschnitt. Wir haben drei Header -Dateien von C++. Für die Verwendung der STD :: FOR_EACH -Schleife haben wir die Algorithmus -Header -Datei hinzugefügt. Anschließend haben wir die Hohlraumfunktion als display_item erstellt, die ein Eingabelement des Datentyps int annimmt. In dieser Funktion haben wir nur den Befehl STD :: Cout für diese Elementvariable.

Als nächstes haben wir die Hauptfunktion, in der wir ein Array deklariert und initialisiert haben. Die Std :: for_each -Schleife wird verwendet, um jedes Element im angegebenen Array zu radeln. Die Funktion display_item wird aufgerufen, um das Array der Elemente innerhalb des Bereichs [Beginnen Sie, enden] für nur eine Zeit anzuzeigen.

Beispiel 2

Verwenden von STD :: Damit sich jeder anhaltende Änderungen an der Sammlung vornehmen,. Die bereitgestellte Funktion nimmt die Parameter „By-Reference“ an, um die Elemente der Sammlung dauerhaft zu ändern.

#enthalten
#enthalten
#enthalten
void func_uppercase (std :: string & str_val)
für (int i = 0; iif (str_val [i]> = 'a' und str_val [i] <= 'z')
str_val [i] = (char) (str_val [i]-'a' + 'a');



int main ()
std :: Cout<<"output: \n";
std :: Array str_array = "das", "Programm", "von",
"C ++";
std :: for_each (str_array.begin (), str_array.end (), func_uppercase);
für (int i = 0; istd :: Cout<
Rückkehr 0;

Hier im ersten Schritt haben wir die Header -Dateien für die Implementierung des Programms importiert. Danach haben wir eine Funktion func_uppercase für die Transformation der unteren Case-Zeichenfolge in die Schnur obere Fälle konstruiert. Anschließend haben wir die Hauptmethode bereitgestellt, bei der wir eine Reihe von Zeichenfolgen definierten, die den gesamten niedrigeren Fall haben. Die Std :: for_each -Schleife wird verwendet, um alle Zeichenfolgenzeichen zu iterieren. Die Std :: for_each -Schleife ruft die Funktion func_uppercase als Argument für jedes Zeichenfolgenzeichen im Bereich auf [Beginnen Sie, Ende]. Danach haben wir eine für Schleife zum Drucken aller Stringzeichen nach der Konvertierung im oberen Fall.

Sie können im Ausgabebildschirm visualisieren, dass alle Untergrundzeichenzeichen in Großbuchstaben umgewandelt werden.

Beispiel 3

Das folgende Beispiel verwendet eine Lambda.

#enthalten
#enthalten
#enthalten
Struktur add
Add () add = 0;
void operator () (int n) add += n;
int add;
;
int main ()

STD :: Vektor Zahlen 4, 5, 1, 8, 16, 221;
std :: Cout << "Numbers before: ";
für (auto n: number)
std :: Cout << n << " ";

std :: Cout << '\n';
std :: for_each (Zahlen.begin (), Zahlen.end (), [] (int & n) n ++; );
Fügen Sie a = std :: for_each (Zahlen.begin (), Zahlen.End (), add ());
std :: Cout << "Numbers after: ";
für (auto n: number)
std :: Cout << n << " ";

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

Hier haben wir eine Struktur eingerichtet und einen Namen hinzugefügt. Die Funktion add () ist auch dort definiert, und in dieser Funktion initialisieren wir den Variablen -Add mit der Zahl Null. Außerdem wird die Hohlraumfunktion mit dem Namensoperator erstellt, der den Wert von n erhöht. Dann kommt die Hauptmethode dieses Programms.

In der Hauptmethode haben wir die Vektorklasse deklariert, in der wir die Liste der Zufallszahlen initialisiert haben. Wir haben die Zahlen mit der für die Loop verwendet. Danach haben wir STD :: FOR_EACH -Schleife für die Iteration über jedes Element in der Zahlenliste, und dann wird jedes Element in der Liste inkrementiert. Wir haben die Nummern nach der für die for_each Loop -Operation gedruckt. Am Ende haben wir die Summe der Nummern angezeigt, indem wir das Objekt als Erstellen der Variablen hinzufügen.

Die Zahlen werden vor und nach der For_each -Schleife als Ausgabe erzeugt. Auch die Summe der Zahlen wird unten angezeigt.

Beispiel 4

Elementdruck in jedem Container ist mit der STD :: for_each -Funktion möglich. Um zu verstehen, wie man es benutzt.

#enthalten
#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
void function_1 (int i)

Cout << i << " ";

void function_2 (Paar p1)

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

int main ()

Vektor Array 2, 5, 1, 9, 3, 8;
Karte 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.begin (), Array.end (), function_1);
Cout << "\n";
Cout << "Displaying the map\n";
for_each (MAP_VAL.begin (), map_val.end (), function_2);
Cout << "\n";
Rückkehr 0;

Wir haben die Funktion als Funktion_1 definiert, in der die Variable "I" deklariert ist, und in dieser Funktion haben wir das "I" mit dem Cout -Befehl angezeigt. Dann haben wir eine andere Funktion als Funktion_2 konstruiert, die als Paarklasse bezeichnet wird, und das Objekt P festgelegt. In der Funktion_2 haben wir jedes Element in einem Paar für die Karte definiert. Dann initialisieren wir innerhalb der Hauptfunktion ein Array von Vektoren und auch Kartwerte. Dann verwenden wir die für die Vektoren und die Karten für die Iteration in jedem Element.

Die Ausführung des obigen Programms erzeugte die folgende Ausgabe.

Abschluss

Daher hat die Verwendung von STD :: FOR_EACH () den Vorteil, dass das Programmproduktniveau und die Verkleinerung der Größe der Codebasis verkleinert werden. Zusätzlich ist O (n) die zeitliche Komplexität. Sie können STD :: for_each () in jeder Situation verwenden, wenn jedes Element viel Verarbeitung durchlaufen muss und eine große Codebasis hat. Desto flexibler std :: for_each (). Jede Art von Behälter kann mit Iteration verwendet werden. Über STD :: FOR_EACH () können wir einen Algorithmus erstellen, der mit einem Iterator arbeitet.