Industrielle Fertigung
Industrielles Internet der Dinge | Industrielle Materialien | Gerätewartung und Reparatur | Industrielle Programmierung |
home  MfgRobots >> Industrielle Fertigung >  >> Industrial programming >> C Sprache

Schleifen in C:For, While, Do While Schleifenanweisungen [Beispiele]

Was ist Loop in C?

Schleifenanweisungen in C Führen Sie die Folge von Anweisungen viele Male aus, bis die angegebene Bedingung falsch wird. Eine Schleife in C besteht aus zwei Teilen, einem Schleifenkörper und einer Steueranweisung. Die Steueranweisung ist eine Kombination einiger Bedingungen, die den Hauptteil der Schleife anweisen, ausgeführt zu werden, bis die angegebene Bedingung falsch wird. Der Zweck der C-Schleife besteht darin, denselben Code mehrmals zu wiederholen.

In diesem Tutorial lernen Sie-

Arten von Schleifen in C

Abhängig von der Position einer Steueranweisung in einem Programm werden Schleifenanweisungen in C in zwei Typen eingeteilt:

1. Eingangskontrollierte Schleife

2. Regelkreis verlassen

In einer Eintrittskontrollschleife in C, eine Bedingung wird geprüft, bevor der Rumpf einer Schleife ausgeführt wird. Sie wird auch als Vorprüfschleife bezeichnet.

In einer Ausgangsregelschleife , wird eine Bedingung nach der Ausführung des Schleifenkörpers überprüft. Sie wird auch als Nachprüfschleife bezeichnet.

Die Steuerbedingungen müssen gut definiert und spezifiziert sein, sonst wird die Schleife unendlich oft ausgeführt. Die Schleife, die die Ausführung nicht beendet und die Anweisungen mehrmals verarbeitet, wird als Endlosschleife bezeichnet . Eine Endlosschleife wird auch als „Endlosschleife“ bezeichnet .“ Im Folgenden sind einige Merkmale einer Endlosschleife aufgeführt:

1. Es ist keine Beendigungsbedingung angegeben.

2. Die angegebenen Bedingungen sind 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

Sr. Nein. Loop-Typ Beschreibung 1.Während LoopIn einer While-Schleife wird eine Bedingung ausgewertet, bevor ein Hauptteil der Schleife verarbeitet wird. Wenn eine Bedingung genau dann wahr ist, wird der Schleifenkörper ausgeführt. 2. Do-While-Schleife In einer do…while-Schleife wird die Bedingung immer nach dem Schleifenkörper ausgeführt. Sie wird auch als ausgangsgesteuerte Schleife bezeichnet. 3. For-Schleife In einer for-Schleife wird der Anfangswert nur einmal ausgeführt, dann testet die Bedingung und vergleicht den Zähler nach jeder Iteration mit einem festen Wert und stoppt die for-Schleife, wenn false zurückgegeben wird .

While-Schleife in C

Eine While-Schleife ist die einfachste Schleifenstruktur. Die While-Schleifensyntax in der Programmiersprache C lautet wie folgt:

Syntax der While-Schleife in C:

while (condition) {
             statements;
}

Es handelt sich um eine eingangsgesteuerte Schleife. In einer While-Schleife wird eine Bedingung ausgewertet, bevor ein Schleifenkörper verarbeitet wird. Wenn eine Bedingung wahr ist, dann und nur dann wird der Rumpf einer Schleife ausgeführt. Nachdem der Hauptteil einer Schleife ausgeführt wurde, geht die Steuerung wieder zurück zum Anfang, 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, die unmittelbar nach der Schleife sind. Der Rumpf einer Schleife kann mehr als eine Anweisung enthalten. Wenn es nur eine Anweisung enthält, sind die geschweiften Klammern nicht obligatorisch. Es ist jedoch eine gute Praxis, die geschweiften Klammern zu verwenden, selbst wenn wir eine einzelne Anweisung im Körper haben.

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

Das folgende Programm zeigt eine While-Schleife in einem 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;
}

Ausgabe:

1
2
3
4
5
6
7
8
9
10

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

While-Schleife in der C-Programmierung

  1. Wir haben eine Variable namens num mit dem Wert 1 initialisiert. Wir werden von 1 bis 10 drucken, daher wird die Variable mit dem Wert 1 initialisiert. Wenn Sie von 0 drucken möchten, weisen Sie während der Initialisierung den Wert 0 zu.
  2. In einer While-Schleife haben wir eine Bedingung angegeben (num<=10), was bedeutet, dass die Schleife den Hauptteil ausführt, bis der Wert von num 10 wird. Danach wird die Schleife beendet und die Steuerung fällt nach draußen die Schleife.
  3. Im Körper einer Schleife haben wir eine Druckfunktion, um unsere Zahl auszugeben, und eine Inkrement-Operation, um den Wert pro Ausführung einer Schleife zu erhöhen. Ein Anfangswert von num ist 1, nach der Ausführung wird es 2 und während der nächsten Ausführung wird es 3. Dieser Prozess wird fortgesetzt, bis der Wert 10 wird, und dann wird die Serie auf der Konsole ausgegeben und die Schleife beendet .

\n wird für Formatierungszwecke verwendet, was bedeutet, dass der Wert in einer neuen Zeile gedruckt 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. Dies wird auch als ausstiegsgesteuerte Schleife bezeichnet.

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 Körper genau dann ausgeführt, wenn die Bedingung wahr ist. In einigen Fällen müssen wir einen Schleifenkörper mindestens einmal ausführen, selbst 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 Rumpf einer Schleife immer mindestens einmal ausgeführt. Nachdem der Körper ausgeführt wurde, überprüft er die Bedingung. Wenn die Bedingung wahr ist, wird der Rumpf einer Schleife erneut ausgeführt, andernfalls wird die Steuerung aus der Schleife übertragen.

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

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 ist eine do-while-Schleife in einem C-Beispiel, um eine Tabelle mit Nummer 2 zu drucken:

#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;
}

Ausgabe:

2
4
6
8
10
12
14
16
18
20

Im obigen Beispiel haben wir eine Multiplikationstabelle von 2 mit 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. Dann haben wir eine do-while-Schleife geschrieben.
  2. In einer Schleife haben wir eine Druckfunktion, die die Serie druckt, indem sie den Wert von num mit 2 multipliziert.
  3. Nach jedem Inkrement erhöht sich der Wert von num um 1 und wird auf dem Bildschirm ausgegeben.
  4. Am Anfang ist der Wert von num 1. In einem Schleifenkörper wird die Druckfunktion auf diese Weise 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 unmittelbar nach der Schleife ausgeführt. 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-Schleifen-Syntax in C ist wie folgt:

Syntax der For-Schleife in C:

for (initial value; condition; incrementation or decrementation ) 
{
  statements;
}
  • Der Anfangswert der for-Schleife wird nur einmal ausgeführt.
  • Die Bedingung ist ein boolescher Ausdruck, der den Zähler nach jeder Iteration testet und mit einem festen Wert vergleicht und die for-Schleife stoppt, wenn false zurückgegeben wird.
  • Die Inkrementierung/Dekrementierung erhöht (oder verringert) den Zähler um einen festgelegten Wert.

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;
}

Ausgabe:

1
2
3
4
5
6
7
8
9
10

Das obige Programm gibt die Zahlenreihe von 1-10 mit einer for-Schleife aus.

For Loop in 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 angegeben und dann den Inkrementteil.
  3. Im Rumpf einer Schleife haben wir eine Druckfunktion, um die Zahlen in einer neuen Zeile in der Konsole auszugeben. Wir haben den Wert Eins in Zahl gespeichert, nach der ersten Iteration wird der Wert erhöht und wird 2. Jetzt hat die Variable Zahl den Wert 2. Die Bedingung wird erneut überprüft und da die Bedingung wahr ist, wird eine Schleife ausgeführt, und es werden zwei auf dem Bildschirm gedruckt. Diese Schleife wird so lange ausgeführt, bis der Wert der Variablen 10 wird. Danach wird die Schleife beendet und eine Reihe von 1-10 wird auf dem Bildschirm ausgegeben.

In C kann die for-Schleife mehrere Ausdrücke haben, die in jedem Teil durch Kommas getrennt sind.

Zum Beispiel:

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.

Zum Beispiel:

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 Schleife 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, die eine verschachtelte for-Schleife 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 */
}}

Ausgabe:

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 kann bis zu jeder Ebene erfolgen. Die verschachtelten Schleifen sollten ausreichend eingerückt sein, um den Code lesbar zu machen. In einigen Versionen von „C“ ist die Verschachtelung auf bis zu 15 Schleifen begrenzt, einige bieten jedoch mehr.

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

Break-Anweisung in C

Die break-Anweisung wird hauptsächlich in der switch-Anweisung verwendet. Es ist auch nützlich, um eine Schleife sofort zu stoppen.

Wir betrachten das folgende Programm, das eine Unterbrechung einführt, um eine While-Schleife zu verlassen:

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

Ausgabe:

5
4

Continue-Anweisung in C

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

Zum Beispiel:

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

Ausgabe:

6
4
3
2
1

Der Wert 5 wird also übersprungen.

Welche Schleife soll ausgewählt werden?

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

  • Analysieren Sie das Problem und prüfen Sie, ob es einen Pre-Test oder eine Post-Test-Schleife erfordert.
  • Wenn ein Vortest erforderlich ist, verwenden Sie eine while- oder for-Schleife.
  • Wenn ein Nachtest erforderlich ist, verwenden Sie eine do-while-Schleife.

Zusammenfassung

  • Schleife in C definieren:Eine Schleife ist eines der Schlüsselkonzepte jeder Programmiersprache. Schleifen in der C-Sprache werden mit bedingten Anweisungen implementiert.
  • Ein Block von Schleifenkontrollanweisungen in C wird so oft ausgeführt, bis die Bedingung falsch wird.
  • Es gibt zwei Arten von Schleifen in der C-Programmierung:eingangsgesteuert und ausgangsgesteuert.
  • Listen Sie verschiedene Schleifensteuerungsanweisungen in C auf:Die C-Programmierung bietet uns 1) While 2) Do-While und 3) For Loop Control-Anweisungen.
  • Die Programmierung von For- und While-Schleifen in C sind eingabegesteuerte Schleifen in der Sprache C.
  • Do-while ist eine Ausgangskontrollschleife in C.

C Sprache

  1. C# while und do...while-Schleife
  2. C# for-Schleife
  3. C#-Foreach-Schleife
  4. C++ für Schleife
  5. Bessere Möglichkeiten zur Fehlerbehebung bei Automatisierungs- und Prozessregelkreisen
  6. Unterschied zwischen while und do-while:An Beispielen erklärt
  7. Armstrong-Nummer im JAVA-Programm mit For-Schleife
  8. Palindrom-Zahlenprogramm in Java mit While- und For-Schleife
  9. Python For &While-Schleifen:Enumerate, Break, Continue-Anweisung
  10. SINUMERIK 840D-Programmierung WHILE-Schleifenverwendung