Schleifen in C: For, While, Do While Schleifeping Aussagen [Beispiele]

Was ist eine Schleife in C?

Kloping Anweisungen in C werden so lange wiederholt, bis die angegebene Bedingung nicht mehr erfüllt ist. Eine Schleife in C besteht aus zwei Teilen: dem Schleifenkörper und einer Kontrollanweisung. Die Kontrollanweisung enthält Bedingungen, die den Schleifenkörper so lange ausführen, bis die angegebene Bedingung nicht mehr erfüllt ist. Der Zweck einer C-Schleife ist es, denselben Code mehrmals zu wiederholen.

Arten von Schleifen in C

Abhängig von der Position einer Kontrollanweisung in einem Programm, looping Anweisungen in C werden in zwei Typen unterteilt:

1. Eingangskontrollierte Schleife
2. Regelkreis verlassen

In einer Eintrittsschleife in C wird eine Bedingung geprüft, bevor der Schleifenkörper ausgeführt wird. Sie wird auch Vorprüfungsschleife genannt.

In einer ausgangsgesteuerten Schleife wird eine Bedingung nach Ausführung des Schleifenkörpers geprüft. Sie wird auch als Nachprüfungsschleife bezeichnet.

Beispielschleife

Die Kontrollbedingungen müssen klar definiert und spezifiziert sein, sonst wird die Schleife unendlich oft ausgeführt. Eine Schleife, die ununterbrochen ausgeführt wird und die Anweisungen beliebig oft wiederholt, wird als Endlosschleife bezeichnet. Eine Endlosschleife wird auch als „Endlosschleife“ bezeichnet. Im Folgenden sind einige Merkmale einer Endlosschleife aufgeführt:

1. Es ist keine Abbruchbedingung angegeben.
2. Die festgelegten Bedingungen werden nie erfüllt.

Die angegebene Bedingung bestimmt, ob der Schleifenkörper ausgeführt wird oder nicht.

Die Programmiersprache „C“ bietet uns drei Arten von Schleifenkonstrukten:

1. Die while-Schleife
2. Die do-while-Schleife
3. Die for-Schleife

While-Schleife in C

Eine while-Schleife ist die einfachste Schleife.ping Struktur. Die Syntax der While-Schleife in der Programmiersprache C lautet wie folgt:

Syntax der While-Schleife in C

while (condition) {
             statements;
}

Es handelt sich um eine eintrittsgesteuerte Schleife. In einer While-Schleife wird eine Bedingung ausgewertet, bevor ein Schleifenkörper verarbeitet wird. Wenn eine Bedingung wahr ist, wird nur dann der Hauptteil einer Schleife ausgeführt. Nachdem der Hauptteil einer Schleife ausgeführt wurde, kehrt die Steuerung wieder zum Anfang zurück und die Bedingung wird überprüft, ob sie wahr ist. Derselbe Prozess wird ausgeführt, bis die Bedingung falsch wird. Sobald die Bedingung falsch wird, verlässt die Steuerung die Schleife.

Nach dem Verlassen der Schleife geht die Steuerung zu den Anweisungen über, die unmittelbar nach der Schleife stehen. Der Rumpf einer Schleife kann mehr als eine Anweisung enthalten. Wenn es nur eine Anweisung enthält, sind die geschweiften Klammern nicht zwingend erforderlich. Es empfiehlt sich jedoch, die geschweiften Klammern zu verwenden, auch wenn der Text nur eine einzige Aussage enthält.

Wenn in einer While-Schleife die Bedingung nicht wahr ist, wird der Schleifenkörper nicht einmal ausgeführt. Anders ist es bei der do-while-Schleife, die wir gleich sehen werden.

Das folgende Programm veranschaulicht eine While-Schleife im C-Programmierbeispiel:

#include<stdio.h>
#include<conio.h>
int main()
{
	int num=1;	//initializing the variable
	while(num<=10)	//while loop with condition
	{
		printf("%d\n",num);
		num++;		//incrementing operation
	}
	return 0;
}

Ausgang:

1
2
3
4
5
6
7
8
9
10

Das obige Programm veranschaulicht die Verwendung einer While-Schleife. Im obigen Programm haben wir mithilfe einer While-Schleife Zahlenreihen von 1 bis 10 gedruckt.

While-Schleife in der C-Programmierung

1. Wir haben initialisiert Variable Die Variable `num` hat den Wert 1. Da wir die Zahlen von 1 bis 10 ausgeben möchten, wird die Variable mit dem Wert 1 initialisiert. Wenn Sie die Zahlen ab 0 ausgeben möchten, weisen Sie ihr bei der Initialisierung den Wert 0 zu.
2. In einer while-Schleife haben wir eine Bedingung (num<=10) bereitgestellt, was bedeutet, dass die Schleife den Rumpf ausführt, bis der Wert von num 10 wird. Danach wird die Schleife beendet und die Steuerung wird außerhalb der Schleife liegen.
3. Im Hauptteil einer Schleife haben wir eine Druckfunktion zum Drucken unserer Nummer und eine Inkrementoperation zum Erhöhen des Werts pro Ausführung einer Schleife. Der Anfangswert von num ist 1, nach der Ausführung wird er 2 und bei der nächsten Ausführung wird er 3. Dieser Vorgang wird fortgesetzt, bis der Wert 10 erreicht. Dann wird die Reihe auf der Konsole gedruckt und die Schleife beendet.

'\n' wird zu Formatierungszwecken verwendet, was bedeutet, dass der Wert in einer neuen Zeile ausgegeben wird.

Do-While-Schleife in C

Eine do…while-Schleife in C ähnelt der while-Schleife, außer dass die Bedingung immer nach dem Schleifenkörper ausgeführt wird. Man spricht auch von einer ausgangsgesteuerten Schleife.

Die Syntax der do while-Schleife in der Programmiersprache C lautet wie folgt:

Syntax der Do-While-Schleife in C

 do {
  statements
} while (expression);

Wie wir in einer while-Schleife gesehen haben, wird der Hauptteil genau dann ausgeführt, wenn die Bedingung erfüllt ist. In einigen Fällen müssen wir den Hauptteil der Schleife mindestens einmal ausführen, auch wenn die Bedingung falsch ist. Diese Art von Operation kann durch die Verwendung einer do-while-Schleife erreicht werden.

In der do-while-Schleife wird der Hauptteil einer Schleife immer mindestens einmal ausgeführt. Nachdem der Hauptteil ausgeführt wurde, wird die Bedingung überprüft. Wenn die Bedingung erfüllt ist, wird der Hauptteil einer Schleife erneut ausgeführt, andernfalls wird die Steuerung aus der Schleife übergeben.

Ähnlich wie bei der while-Schleife werden die Anweisungen, die unmittelbar nach der Schleife stehen, ausgeführt, sobald die Steuerung die Schleife verlässt.

Der entscheidende Unterschied zwischen der while- und der do-while-Schleife besteht darin, dass in der while-Schleife das while am Anfang geschrieben wird. In der do-while-Schleife wird die while-Bedingung am Ende geschrieben und mit einem Semikolon (;) abgeschlossen.

Das folgende Schleifenprogramm in C veranschaulicht die Funktionsweise einer do-while-Schleife:

Unten sehen Sie ein Beispiel für eine Do-While-Schleife in C zum Drucken einer Tabelle mit Nummer 2:

#include<stdio.h>
#include<conio.h>
int main()
{
	int num=1;	//initializing the variable
	do	//do-while loop 
	{
		printf("%d\n",2*num);
		num++;		//incrementing operation
	}while(num<=10);
	return 0;
}

Ausgang:

2
4
6
8
10
12
14
16
18
20

Im obigen Beispiel haben wir die Multiplikationstabelle von 2 mithilfe einer do-while-Schleife gedruckt. Mal sehen, wie das Programm die Serie drucken konnte.

Do-While-Schleife in der C-Programmierung

1. Zuerst haben wir eine Variable „num“ mit dem Wert 1 initialisiert. Anschließend haben wir eine do-while-Schleife geschrieben.
2. In einer Schleife haben wir eine Druckfunktion, die die Reihe druckt, indem sie den Wert von num mit 2 multipliziert.
3. Nach jeder Erhöhung erhöht sich der Wert von num um 1 und wird auf dem Bildschirm ausgedruckt.
4. Anfangs ist der Wert von num 1. Im Hauptteil einer Schleife wird die Druckfunktion folgendermaßen ausgeführt: 2*num, wobei num=1, dann 2*1=2, daher wird der Wert zwei gedruckt. Dies wird so lange fortgesetzt, bis der Wert von num 10 wird. Danach wird die Schleife beendet und eine Anweisung ausgeführt, die sich unmittelbar nach der Schleife befindet. Geben Sie in diesem Fall 0 zurück.

For-Schleife in C

Eine for-Schleife ist eine effizientere Schleifenstruktur in der C-Programmierung. Die allgemeine Struktur der for-Schleifensyntax in C ist wie folgt:

Syntax der For-Schleife in C

for (initial value; condition; incrementation or decrementation ) 
{
  statements;
}

1. Der Anfangswert der for-Schleife wird nur einmal ausgeführt.
2. Die Bedingung ist ein boolescher Ausdruck, der den Zähler nach jeder Iteration mit einem festen Wert vergleicht und stoppt.ping Die for-Schleife wird beendet, wenn false zurückgegeben wird.
3. Durch die Inkrementierung/Dekrementierung wird der Zähler um einen eingestellten Wert erhöht (oder verringert).

Das folgende Programm veranschaulicht die For-Schleife im C-Programmierbeispiel:

#include<stdio.h>
int main()
{
	int number;
	for(number=1;number<=10;number++)	//for loop to print 1-10 numbers
	{
		printf("%d\n",number);		//to print the number
	}
	return 0;
}

Ausgang:

1
2
3
4
5
6
7
8
9
10

Das obige Programm druckt die Zahlenreihe von 1 bis 10 mithilfe einer for-Schleife.

For-Schleife in der C-Programmierung

1. Wir haben eine Variable vom Datentyp int deklariert, um Werte zu speichern.
2. In der for-Schleife haben wir im Initialisierungsteil der Variablennummer den Wert 1 zugewiesen. Im Bedingungsteil haben wir unsere Bedingung und dann den Inkrementteil angegeben.
3. Im Hauptteil einer Schleife haben wir eine Druckfunktion, um die Zahlen in einer neuen Zeile in der Konsole zu drucken. Wir haben den Wert 2 in „number“ gespeichert. Nach der ersten Iteration wird der Wert erhöht und wird 2. Jetzt hat die Variable „number“ den Wert 10. Die Bedingung wird erneut überprüft und da die Bedingung erfüllt ist, wird die Schleife ausgeführt und 1 auf dem Bildschirm gedruckt. Diese Schleife wird so lange ausgeführt, bis der Wert der Variablen 10 erreicht. Danach wird die Schleife beendet und eine Reihe von XNUMX-XNUMX wird auf dem Bildschirm gedruckt.

In C kann die for-Schleife in jedem Teil mehrere durch Kommas getrennte Ausdrücke enthalten.

Beispielsweise:

for (x = 0, y = num; x < y; i++, y--) { 
  statements; 
}

Außerdem können wir den Anfangswertausdruck, die Bedingung und/oder das Inkrement überspringen, indem wir ein Semikolon hinzufügen.

Beispielsweise:

int i=0;
int max = 10;
for (; i < max; i++) {
  printf("%d\n", i);
}

Beachten Sie, dass Schleifen auch dort verschachtelt werden können, wo es eine äußere und eine innere Schleife gibt. Bei jeder Iteration der äußeren Schleife wiederholt die innere Schleife ihren gesamten Zyklus.

Betrachten Sie das folgende Beispiel mit mehreren Bedingungen in einer For-Schleife, das verschachtelte For-Schleifen in der C-Programmierung verwendet, um eine Multiplikationstabelle auszugeben:

#include <stdio.h>
int main() {
int i, j;
int table = 2;
int max = 5;
for (i = 1; i <= table; i++) { // outer loop
  for (j = 0; j <= max; j++) { // inner loop
    printf("%d x %d = %d\n", i, j, i*j);
  }
  printf("\n"); /* blank line between tables */
}}

Ausgang:

1 x 0 = 0
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5

2 x 0 = 0
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10

Die Verschachtelung von for-Schleifen ist beliebig tief möglich. Die verschachtelten Schleifen sollten ausreichend eingerückt sein, um den Code lesbar zu machen. In manchen C-Versionen ist die Verschachtelung auf 15 Schleifen beschränkt, in anderen sind mehr möglich.

Die verschachtelten Schleifen werden hauptsächlich in Array-Anwendungen verwendet, die wir in weiteren Tutorials sehen werden.

Neben den drei Schleifentypen bietet C zwei Anweisungen, die den Ablauf einer Schleife von innen heraus verändern.

Break-Anweisung in C

Die break-Anweisung wird hauptsächlich in verwendet switch-AnweisungEs ist auch nützlich, um sofort anzuhalten.ping eine Schleife.

Wir betrachten das folgende Programm, das einen Break zum Verlassen einer While-Schleife einführt:

#include <stdio.h>
int main() {
int num = 5;
while (num > 0) {
  if (num == 3)
    break;
  printf("%d\n", num);
  num--;
}}

Ausgang:

5
4

Fortsetzung der Aussage in C

Wenn Sie zur nächsten Iteration springen, aber in der Schleife bleiben möchten, sollten Sie die continue-Anweisung verwenden.

Beispielsweise:

#include <stdio.h>
int main() {
int nb = 7;
while (nb > 0) {
  nb--;
  if (nb == 5)
    continue;
 printf("%d\n", nb);
}}

Ausgang:

6
4
3
2
1

Daher wird der Wert 5 übersprungen.

Welche Schleife soll ausgewählt werden?

Die Auswahl einer Schleife ist für einen Programmierer immer eine schwierige Aufgabe. Um eine Schleife auszuwählen, führen Sie die folgenden Schritte aus:

1. Analysieren Sie das Problem und prüfen Sie, ob eine Vortest- oder Nachtestschleife erforderlich ist.
2. Falls ein Vortest erforderlich ist, verwenden Sie eine while- oder for-Schleife.
3. Wenn ein Nachtest erforderlich ist, verwenden Sie eine Do-While-Schleife.

Häufig gestellte Fragen