Verschachtelte Schleifen in C++

Verschachtelte Schleifen In C



Wenn wir in C++ den Block des Codes wiederholen müssen, verwenden wir die „Schleifen“ an dieser Stelle. Dies reduziert unsere Zeit, den gleichen Code immer wieder einzugeben. Wir verwenden die „Schleifen“ in C++, um einen Codeabschnitt zu wiederholen. Die „Loops“-Methode ist ein sehr effizienter und zeitsparender Prozess in der C++-Programmierung. Es gibt verschiedene Arten von Schleifen, die von der C++-Sprache bereitgestellt werden, wie „for-Schleife“, „while-Schleife“, „do-while-Schleife“ und „verschachtelte Schleife“. Die „verschachtelte Schleife“ bedeutet, dass wir zwei Schleifen ineinander platzieren, oder wir können auch sagen, dass eine Schleife eine andere Schleife enthält.

Hier werden wir in diesem Handbuch nur die „verschachtelten“ Schleifen in C++ untersuchen. Die Codes, in denen wir diese „verschachtelten“ Schleifen verwenden, sind wie folgt:







Beispiel 1:



Während wir in C++ arbeiten, müssen wir die Header-Datei einbinden, daher fügen wir hier die Header-Datei „iostream“ ein. Die Header-Dateien sind enthalten, damit wir die darin deklarierten Methoden oder Funktionen in unserem Code nutzen können. Darunter fügen wir den Namespace „std“ hinzu und rufen an dieser Stelle die Methode „main()“ auf.



Dann verwenden wir die „for“-Schleife, in die wir auch eine weitere „for“-Schleife einfügen; es wird die „verschachtelte for-Schleife“ genannt. In der ersten „for“-Schleife initialisieren wir die Variable „a“ vom Datentyp „int“ mit „1“. Hier wird auch die Bedingung platziert, die „a <= 3“ sagt und dann „++a“ im Wert von „a“ erhöht. Wir platzieren „cout“ unter dieser „for“-Schleife, um hier Text auszugeben. In der nächsten „for“-Schleife initialisieren wir eine „b“-Variable vom Datentyp „int“ mit dem Wert „1“. Die Bedingung, die wir hier hinzufügen, ist „b <= 4“ und wird ebenfalls erhöht. Wir platzieren ein weiteres „cout“ unterhalb dieses „nested for“.





Code 1:

#include
Verwenden des Namensraums std;
int main ( ) {
für ( int a = 1 ; A < = 3 ; ++a ) {
cout << „Meine for-Schleife:“ << A << endl;
für ( int b = 1 ; B < = 4 ; ++b ) {
cout << '     Meine verschachtelte Schleife: ' << B << endl;
}
}
zurückkehren 0 ;
}



Ausgabe:

Das Ergebnis der angegebenen „verschachtelten Schleife“ wird nun hier gerendert. Die erste „cout“-Anweisung erscheint dreimal, da wir ihre Bedingung auf „3“ angepasst haben, und die zweite „cout“-Anweisung erscheint viermal, da wir ihre Bedingung im Code auf „4“ angepasst haben.

Beispiel 2:

Die Funktion „main()“ wird aufgerufen. Anschließend initialisieren wir die Variablen „myNewWeek“ und „weekDays“ mit den Werten „2“ bzw. „7“. Die „verschachtelte for-Schleife“, die wir im Folgenden verwenden, besteht aus zwei „for“-Schleifen, die wir ineinander positionieren. Die „i <= myNewWeek“-Bedingung und das „++i“-Inkrement im Wert von „i“ werden hier in der ersten „for“-Schleife platziert, mit der wir die „i“-Variable des „int“-Datentyps initialisieren „1“. Wir positionieren „cout“ unterhalb dieser „for“-Schleife, um hier etwas Text zu drucken. In der folgenden „for“-Schleife initialisieren wir eine Variable namens „j“ vom Datentyp „int“ mit dem Wert „1“.

Hier fügen wir die Bedingung „j <= WeekDays“ hinzu und erhöhen sie. Ein weiterer „cout“ befindet sich unterhalb dieser „nested for“-Schleife.

Code 2:

#include
Verwenden des Namensraums std;
int main ( ) {
int myNewWeek = 2 , Wochentage = 7 ;

für ( int i = 1 ; ich < = meineNeueWoche; ++i ) {
cout << „Die Woche ist:“ << ich << endl;
für ( int j = 1 ; J < = Wochentage; ++j ) {
cout << '    Der Wochentag ist: ' << J << endl;
}
}
zurückkehren 0 ;
}

Ausgabe:

So wird nun die bereits erwähnte „Nested Loop“ dargestellt. Der Code zeigt nun drei Instanzen der ersten „cout“-Anweisung (deren Bedingung auf „2“ festgelegt ist) und vier Instanzen der zweiten „cout“-Anweisung (deren Bedingung auf „7“ festgelegt ist).

Beispiel 3:

Hier wollen wir das „@“-Symbol in einem dreieckigen Muster mit der „nested for“-Schleife darstellen. Dazu platzieren wir die erste „for“-Schleife und passen ihre Bedingung auf „i <= 6“ an, nachdem wir die Variable „int i“ mit dem Wert „1“ initialisiert haben.

Dann wenden wir auch die Erhöhung des Werts von „i“ an. Darunter haben wir ein weiteres „for“, in das wir eine weitere Bedingung einfügen, die „j <= i“ besagt, nachdem wir die Variable „j“ als „int“ mit dem Wert „1“ initialisiert haben. Auch hier wird der Wert dieser „j“-Variablen erhöht. Jetzt fügen wir das „cout“ an der Stelle hinzu, an der das „@“-Symbol platziert ist. Dadurch wird das „@“-Symbol nun dreieckig dargestellt.

Code 3:

#include
Verwenden des Namensraums std;
int main ( ) {
für ( int i = 1 ; ich < = 6 ; i++ ) {
für ( int j = 1 ; J < = ich; j++ ) {
cout << „@“ ;
}
cout << endl;
}

zurückkehren 0 ;
}

Ausgabe:

Dieses Ergebnis erhalten wir aufgrund der „verschachtelten Schleife“, die wir im bereitgestellten Code verwendet haben. Hier können wir sehen, dass das „@“-Symbol in einem dreieckigen Muster erscheint.

Beispiel 4:

Wir möchten die „nested for“-Schleife verwenden, um das „@“-Symbol in einem Dreiecksmuster anzuzeigen. Dazu positionieren wir die erste „for“-Schleife. Dann initialisieren wir die Variable „int a“ mit dem Wert „1“ und setzen ihre Bedingung auf „a <= 8“. Als nächstes erhöhen wir in diesem Fall auch den Wert von „a“. Dann haben wir ein weiteres „for“, bei dem wir die Variable „b“ als „int“ mit dem Wert „1“ initialisieren, mit einer anderen Bedingung, die „b <= a“ angibt. Der Wert von „a“ wird ebenfalls erhöht. Das „cout“ wird nun an der Stelle hinzugefügt, an der wir das „*“-Symbol platzieren. Dies führt nun dazu, dass die Konsole das „*“-Zeichen in einem Dreiecksmuster anzeigt.

Code 4:

#include
Verwenden des Namensraums std;
int main ( ) {
für ( int a = 1 ; A < = 8 ; a++ ) {
für ( int b = 1 ; B < = ein; b++ ) {
cout << „*  “ ;
}
cout << endl;
}
zurückkehren 0 ;
}

Ausgabe:

Dieses Ergebnis haben wir durch die Verwendung einer „verschachtelten Schleife“ im oben genannten Code erhalten. Hier können wir beobachten, dass das „@“-Symbol in einem Dreieck angeordnet ist.

Beispiel 5:

Jetzt wollen wir nur die Primzahl rendern. Daher deklarieren wir die Variablen „x“ und „y“ als „int“-Variablen. Dann platzieren wir nacheinander zwei „for“-Schleifen, die als „verschachtelte for“-Schleifen bezeichnet werden. Die erste Schleife enthält die Bedingung „x <= 50“, nachdem die Variable „x“ mit „2“ initialisiert wurde. In dieser Schleife führen wir auch die Inkrementierung des Werts von „x“ durch.

Dann haben wir eine weitere Schleife, in der wir eine weitere Bedingung hinzufügen, die „y <= (x/y)“ lautet, nachdem wir der Variablen „y“ einen Wert „2“ zugewiesen haben. Wir erhöhen auch den Wert von „y“ innerhalb dieser Schleife. Darunter verwenden wir das „if“, das die „!(x%y)“-Bedingung prüft. Wenn der Faktor hier nicht gefunden wird, wird dieser Wert nicht gedruckt, da wir die „break“-Anweisung hinzufügen und uns dem zweiten „if“ zuwenden, das wir im Folgenden hinzufügen. Hier wird erneut die Bedingung überprüft, die „y > (x/y)“ lautet. Wenn dies der Fall ist, wird dieser Wert und außerdem „ist eine Primzahl“ ausgegeben.

Code 5:

#include
Verwenden des Namensraums std;
int main ( ) {
int x, y;
für ( x = 2 ; X < = fünfzig ; x++ ) {
für ( y = 2 ; Und ( X / Und ) ) cout << X << „  ist eine Primzahl.“ << endl;
}
zurückkehren 0 ;
}

Ausgabe:

Jetzt werden hier alle Primzahlen gerendert, die wir erhalten, nachdem wir die „nested for“-Schleife in unserem Code angewendet haben.

Abschluss

In diesem Leitfaden dreht sich alles um die verschachtelten Schleifen in C++ und es wird erklärt, dass wir die „verschachtelten Schleifen“ immer dann verwenden, wenn wir die Wiederholung des Codeabschnitts wünschen. Wir haben dieses Konzept gründlich untersucht und gelernt, wie wir die „verschachtelten Schleifen“ in unseren Codes nutzen können. Wir haben mehrere Beispiele gezeigt, in denen wir die „verschachtelten Schleifen“ zusammen mit ihren Erklärungen verwendet haben, und die Ergebnisse all dieser Codes hier in diesem Handbuch dargestellt.