C Language
Iterationsanweisungen / -schleifen: für, während, währenddessen

Syntax

• /* alle Versionen */
• für ([Ausdruck]; [Ausdruck]; [Ausdruck]) eine_Anweisung
• for ([Ausdruck]; [Ausdruck]; [Ausdruck]) {null oder mehrere Anweisungen}
• while (Ausdruck) one_statement
• while (Ausdruck) {null oder mehrere Anweisungen}
• one_statement while (Ausdruck);
• do {eine oder mehrere Anweisungen} while (Ausdruck);
• // seit C99 zusätzlich zum obigen Formular
• for (Deklaration; [Ausdruck]; [Ausdruck]) one_statement;
• for (Deklaration; [Ausdruck]; [Ausdruck]) {null oder mehrere Anweisungen}

Bemerkungen

for ([<expression>]; [<expression>]; [<expression>]) <statement>
while (<expression>) <statement>

for ([declaration expression]; [expression] [; [expression]]) statement

do <statement> while (<expression>);

Für Schleife

Um einen Codeblock immer wieder auszuführen, kommen Schleifen ins Bild. Die for Schleife ist zu verwenden, wenn ein Codeblock eine festgelegte Anzahl von Malen ausgeführt werden soll. Um zum Beispiel ein Array der Größe n mit den Benutzereingaben zu füllen, müssen wir scanf() n mal ausführen.

#include <stddef.h>          // for size_t

int array[10];               // array of 10 int

for (size_t i = 0; i < 10; i++)    // i starts at 0 and finishes with 9
{
   scanf("%d", &array[i]);
}

Auf diese Weise wird der scanf() Funktion scanf() n mal (in unserem Beispiel 10-mal) ausgeführt, jedoch nur einmal geschrieben.

Hier ist die Variable i der Schleifenindex und wird am besten als dargestellt deklariert. Der Typ size_t ( size type ) sollte für alles verwendet werden, was Datenobjekte zählt oder durchläuft.

Diese Möglichkeit, Variablen innerhalb von for deklarieren, ist nur für Compiler verfügbar, die auf den C99-Standard aktualisiert wurden. Wenn Sie aus irgendeinem Grund immer noch bei einem älteren Compiler stecken, können Sie den Schleifenindex vor der for Schleife angeben:

#include <stddef.h>        /* for size_t */
size_t i;
int array[10];             /* array of 10 int */

for (i = 0; i < 10; i++)       /* i starts at 0 and finishes at 9 */
{
   scanf("%d", &array[i]);
}

While-Schleife

Eine while Schleife wird verwendet, um einen Code auszuführen, während eine Bedingung erfüllt ist. Die while Schleife ist zu verwenden, wenn ein Codeblock mehrmals variabel ausgeführt werden soll. Der angezeigte Code erhält beispielsweise die Benutzereingabe, solange der Benutzer Zahlen einfügt, die nicht 0 . Wenn der Benutzer 0 einfügt, ist die while-Bedingung nicht mehr wahr, sodass die Ausführung die Schleife verlässt und mit dem nachfolgenden Code fortgesetzt wird:

int num = 1;

while (num != 0)
{
    scanf("%d", &num);
}

Do-While-Schleife

Im Gegensatz zu for und while do-while Schleifen prüfen do-while Schleifen die Wahrheit der Bedingung am Ende der Schleife. Dies bedeutet, dass der do Block einmal ausgeführt wird, und dann den Zustand des while am unteren Rand des Blocks. Das bedeutet, dass eine do-while Schleife immer mindestens einmal ausgeführt wird.

Diese do-while Schleife erhält beispielsweise Zahlen vom Benutzer, bis die Summe dieser Werte größer oder gleich 50 :

int num, sum;
num = sum = 0;

do 
{
  scanf("%d", &num);
  sum += num;

} while (sum < 50);

do-while Loops sind bei den meisten Programmierstilen relativ selten.

Struktur und Ablauf der Kontrolle in einer for-Schleife

for ([declaration-or-expression]; [expression2]; [expression3])
{
    /* body of the loop */
}

In einer for Schleife hat die Schleifenbedingung drei optionale Ausdrücke.

• Der erste Ausdruck, declaration-or-expression , initialisiert die Schleife. Es wird genau einmal am Anfang der Schleife ausgeführt.

• Der zweite Ausdruck, expression2 , ist die Testbedingung . Sie wird erst nach der Initialisierung ausgeführt. Wenn die Bedingung true , dann tritt die Steuerung in den Körper der Schleife. Wenn nicht, verschiebt es sich am Ende der Schleife nach außerhalb des Schleifenrumpfes. Anschließend wird diese Bedingung nach jeder Ausführung des Hauptteils sowie der Aktualisierungsanweisung überprüft. Wenn dies true , true das Steuerelement zurück zum Anfang des Loop-Körpers. Die Bedingung soll in der Regel eine Überprüfung der Anzahl der Male, die der Body der Schleife ausführt, sein. Dies ist die primäre Möglichkeit, eine Schleife zu verlassen, die andere Möglichkeit besteht darin, Sprunganweisungen zu verwenden .
• Der dritte Ausdruck, expression3 , ist die Aktualisierungsanweisung . Sie wird nach jeder Ausführung des Hauptteils der Schleife ausgeführt. Sie wird häufig verwendet, um eine Variable zu erhöhen, die die Anzahl der Ausführungen des Schleifenkörpers zählt, und diese Variable wird Iterator genannt .

Jede Ausführung des Schleifenkörpers wird als Iteration bezeichnet .

Beispiel:

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

Die Ausgabe ist:

0123456789

In dem obigen Beispiel wird zuerst i = 0 ausgeführt, wobei i initialisiert wird. Dann wird die Bedingung i < 10 geprüft, die als true bewertet wird. Das Steuerelement geht in den Körper der Schleife und der Wert von i wird gedruckt. Dann wechselt die Steuerung zu i++ , wobei der Wert von i von 0 auf 1 aktualisiert wird. Dann wird die Bedingung erneut geprüft und der Prozess wird fortgesetzt. Dies setzt sich fort, bis der Wert von i 10 wird. Dann wird die Bedingung i < 10 false ausgewertet, wonach die Steuerung die Schleife verlässt.

Unendliche Schleifen

Eine Schleife wird als eine unendliche Schleife bezeichnet, wenn die Steuerung in den Kreis der Schleife eintritt, diese jedoch nie verlässt. Dies geschieht, wenn die Testbedingung der Schleife niemals als false bewertet wird.

Beispiel:

for (int i = 0; i >= 0; )
{
    /* body of the loop where i is not changed*/
}

Im obigen Beispiel wird die Variable i , der Iterator, auf 0 initialisiert. Die Testbedingung ist anfangs true . i wird jedoch an keiner Stelle im Hauptteil geändert und der Aktualisierungsausdruck ist leer. Daher i wird 0 bleiben, und die Testbedingung wird nie bewerten false , zu einer Endlosschleife führt.

Angenommen, es gibt keine Sprunganweisungen, kann die Endlosschleife auch dadurch gebildet werden, dass die Bedingung explizit wahr bleibt:

while (true)
{
    /* body of the loop */
}

In einer for Schleife ist die Bedingungsanweisung optional. In diesem Fall ist die Bedingung immer true vacuously, zu einer Endlosschleife führt.

for (;;)
{
    /* body of the loop */
}

Doch in bestimmten Fällen kann der Zustand gehalten wird true absichtlich, mit der Absicht, die Schleife verlass eine mit Sprunganweisung wie break .

while (true)
{
    /* statements */
    if (condition)
    {
         /* more statements */
         break;
    }
}

Endlosschleifen und Duff's Device

Manchmal kann die direkte Schleife nicht vollständig im Schleifenkörper enthalten sein. Dies liegt daran, dass die Schleife durch einige Anweisungen B vorbereitet werden muss. Dann beginnt die Iteration mit einigen Anweisungen A , denen vor der Schleife erneut B folgt.

do_B();
while (condition) {
    do_A();
    do_B();
}

Um potenzielle Probleme beim Ausschneiden / Einfügen bei der zweimaligen Wiederholung von B im Code zu vermeiden, kann Duff's Device angewendet werden, um die Schleife von der Mitte des while Körpers aus mit einer switch-Anweisung zu starten und das Verhalten zu beeinflussen.

switch (true) while (condition) {
case false: do_A(); /* FALL THROUGH */
default:    do_B(); /* FALL THROUGH */
}

Duff's Device wurde eigentlich erfunden, um die Schleifenabwicklung zu implementieren. Stellen Sie sich vor, Sie wenden eine Maske auf einen Speicherblock an, wobei n ein vorzeichenbehafteter Integraltyp mit einem positiven Wert ist.

do {
    *ptr++ ^= mask;
} while (--n > 0);

Wenn n immer durch 4 teilbar wäre, könnten Sie dies leicht abwickeln als:

do {
    *ptr++ ^= mask;
    *ptr++ ^= mask;
    *ptr++ ^= mask;
    *ptr++ ^= mask;
} while ((n -= 4) > 0);

Mit Duff's Device kann der Code jedoch dieser Abwicklungsform folgen, die in der Mitte der Schleife an die richtige Stelle springt, wenn n nicht durch 4 teilbar ist.

switch (n % 4) do {
case 0: *ptr++ ^= mask; /* FALL THROUGH */
case 3: *ptr++ ^= mask; /* FALL THROUGH */
case 2: *ptr++ ^= mask; /* FALL THROUGH */
case 1: *ptr++ ^= mask; /* FALL THROUGH */
} while ((n -= 4) > 0);

Diese Art des manuellen Abrollens ist bei modernen Compilern selten erforderlich, da die Optimierungs-Engine des Compilers Schleifen im Namen des Programmierers abwickeln kann.