Welche Steueranweisungen implementieren Schleifenstrukturen in der C-Sprache?

Zu den Steueranweisungen, die Schleifenstrukturen in der C-Sprache implementieren, gehören: while-Anweisung, do-while-Anweisung und for-Anweisung. Die allgemeine Form ist „while (Ausdruck) {Anweisungsblock}“, „do {Anweisungsblock}“. while (Ausdruck);“, „für (Ausdruck 1; Ausdruck 2; Ausdruck 3) {Anweisungsblock}“.

Die sogenannte Schleife (Loop) besteht darin, denselben Code wiederholt auszuführen, um beispielsweise den Wert von 1+2+3+ zu berechnen ...+99+100, Der Additionsvorgang muss 99 Mal wiederholt werden.

while-Schleife

Die allgemeine Form der while-Schleife ist:

while(表达式){
    语句块
}

Das bedeutet, dass zuerst der „Ausdruck“ berechnet wird „Wert: Wenn der Wert wahr ist (nicht 0), führen Sie den „Anweisungsblock“ aus. Berechnen Sie nach der Ausführung des „Anweisungsblocks“ den Wert des Ausdrucks erneut. Wenn er wahr ist, führen Sie den „Anweisungsblock“ weiter aus. .. Dieser Vorgang wird wiederholt. Bis der Wert des Ausdrucks falsch (0) ist, verlassen Sie die Schleife und führen Sie den Code nach einer Weile aus.

Wir nennen den „Ausdruck“ normalerweise eine Schleifenbedingung und den „Anweisungsblock“ einen Schleifenkörper. Der gesamte Schleifenprozess ist der Prozess der ständigen Beurteilung der Schleifenbedingung und der Ausführung des Schleifenkörpercodes.

Verwenden Sie eine While-Schleife, um den Wert von 1 addiert zu 100 zu berechnen:

#include <stdio.h>
int main(){
    int i=1, sum=0;
    while(i<=100){
        sum+=i;
        i++;
    }
    printf("%d\n",sum);
    return 0;
}

Laufende Ergebnisse:

5050

Code Analyse:

1) Wenn das Programm bis while läuft, wird der Schleifenkörper nach der Ausführung ausgeführt, da i=1 und i<=100 wahr sind; der Wert von i wird 2 und Der Wert der Summe wird 1.

2) Als nächstes wird weiterhin beurteilt, ob i<=100 wahr ist, da zu diesem Zeitpunkt i=2, i<=100 wahr ist, sodass der Schleifenkörper nach der Ausführung weiterhin ausgeführt wird , der Wert von i wird 3, sum Der Wert wird 3.

3) Wiederholen Sie Schritt 2).

4) Wenn die Schleife das 100. Mal erreicht, ändert sich der Wert von i auf 101 und der Wert von sum ändert sich auf 5050, da i<=100 zu diesem Zeitpunkt nicht mehr wahr ist, wird die Schleife verlassen und Der Schleifenkörper wird nicht mehr ausgeführt, und dann wird der Code hinter der while-Schleife ausgeführt.

Die Gesamtidee der while-Schleife ist wie folgt: Legen Sie eine Schleifenbedingung mit Variablen fest, das heißt, ein Ausdruck mit Variablen fügt dem Schleifenkörper eine zusätzliche Anweisung hinzu, damit er die Schleifenbedingung ändern kann Der Wert der Variablen. Auf diese Weise ändern sich die Werte der Variablen in der Schleifenbedingung weiter, während die Schleife weiter ausgeführt wird. Es wird schließlich einen Moment geben, in dem die Schleifenbedingung nicht mehr wahr ist und die gesamte Schleife endet.

Was passiert, wenn die Schleifenbedingung keine Variablen enthält?

1) Wenn die Schleifenbedingung wahr ist, wird die while-Schleife weiter ausgeführt und endet nie, wodurch sie zu einer „Endlosschleife“ wird. Zum Beispiel:

#include <stdio.h>
int main(){
    while(1){
        printf("1");
    }
    return 0;
}

Beim Ausführen des Programms wird kontinuierlich „1“ ausgegeben, bis der Benutzer das Schließen erzwingt.

2) Wenn die Schleifenbedingung nicht wahr ist, wird die while-Schleife kein einziges Mal ausgeführt. Zum Beispiel:

#include <stdio.h>
int main(){
    while(0){
        printf("1");
    }
    return 0;
}

Führen Sie das Programm aus und es wird nichts ausgegeben.

Sehen Sie sich ein weiteres Beispiel an, in dem die Anzahl der über die Tastatur in eine Zeile eingegebenen Zeichen gezählt wird:

#include <stdio.h>
int main(){
    int n=0;
    printf("Input a string:");
    while(getchar()!=&#39;\n&#39;) n++;
    printf("Number of characters: %d\n", n);
    return 0;
}

Laufende Ergebnisse:

Input a string:c.biancheng.net↙
Number of characters: 15

Die Schleifenbedingung in diesem Beispielprogramm ist getchar()!='n'， Die Bedeutung besteht darin, dass die Schleife fortgesetzt wird, solange das über die Tastatur eingegebene Zeichen kein Wagenrücklauf ist. Der Schleifenkörper n++; schließt die Zählung der Anzahl der eingegebenen Zeichen ab.

do-while-Schleife

Zusätzlich zur while-Schleife gibt es in der C-Sprache auch eine do-while-Schleife.

Die allgemeine Form einer Do-While-Schleife ist:

do{
    语句块
}while(表达式);

Der Unterschied zwischen einer Do-While-Schleife und einer While-Schleife besteht darin, dass sie die „Anweisung“ ausführt Block“ zuerst und bestimmen Sie dann, ob der Ausdruck wahr ist. Wenn er wahr ist, setzen Sie die Schleife fort; wenn er falsch ist, beenden Sie die Schleife. Daher muss die do-while-Schleife den „Block“ mindestens einmal ausführen.

Verwenden Sie do-while, um den Wert von 1 addiert zu 100 zu berechnen:

#include <stdio.h>
int main(){
    int i=1, sum=0;
    do{
        sum+=i;
        i++;
    }while(i<=100);
    printf("%d\n", sum);
    return 0;
}

Laufergebnis:

5050

Beachten Sie das while(i<=100);abschließende Semikolon ;, das ist ein Muss.

While-Schleife und Do-While haben ihre eigenen Eigenschaften, Sie können sie entsprechend auswählen, während die While-Schleife häufig in der tatsächlichen Programmierung verwendet wird.

Zusätzlich zur while-Schleife gibt es in der C-Sprache auch eine for-Schleife, die flexibler einsetzbar ist und die while-Schleife vollständig ersetzen kann.

for-Schleife

Oben verwenden wir eine while-Schleife, um den Wert von 1 addiert zu 100 zu berechnen. Der Code lautet wie folgt:

#include <stdio.h>
int main(){
    int i, sum=0;
    i = 1;  //语句①
    while(i<=100 /*语句②*/ ){
        sum+=i;
        i++;  //语句③
    }
    printf("%d\n",sum);
    return 0;
}

Es ist ersichtlich, dass die Anweisungen ①②③ an verschiedenen Stellen platziert sind und die Codestruktur relativ locker ist. Um das Programm kompakter zu machen, können Sie stattdessen eine for-Schleife verwenden, wie unten gezeigt:

#include <stdio.h>
int main(){
    int i, sum=0;
    for(i=1/*语句①*/; i<=100/*语句②*/; i++/*语句③*/){
        sum+=i;
    }
    printf("%d\n",sum);
    return 0;
}

In der for-Schleife sind die Anweisungen ①②③ gruppiert und die Codestruktur ist auf einen Blick klar.

Die allgemeine Form der for-Schleife ist:

for(表达式1; 表达式2; 表达式3){
    语句块
}

Ihr laufender Prozess ist:

1) Führen Sie zuerst „Ausdruck 1“ aus.

2) Führen Sie dann „Ausdruck 2“ aus. Wenn sein Wert wahr ist (nicht 0), führen Sie den Schleifenkörper aus, andernfalls beenden Sie die Schleife.

3) Führen Sie „Ausdruck 3“ aus, nachdem Sie den Schleifenkörper ausgeführt haben.

4) Wiederholen Sie die Schritte 2) und 3), bis der Wert von „Ausdruck 2“ falsch ist, und beenden Sie dann die Schleife.

In den obigen Schritten sind 2) und 3) eine Schleife und werden wiederholt ausgeführt. Die Hauptfunktion der for-Anweisung besteht darin, die Schritte 2) und 3) kontinuierlich auszuführen.

“表达式1”仅在第一次循环时执行，以后都不会再执行，可以认为这是一个初始化语句。“表达式2”一般是一个关系表达式，决定了是否还要继续下次循环，称为“循环条件”。“表达式3”很多情况下是一个带有自增或自减操作的表达式，以使循环条件逐渐变得“不成立”。

for循环的执行过程可用下图表示：

我们再来分析一下“计算从1加到100的和”的代码：

#include <stdio.h>
int main(){
    int i, sum=0;
    for(i=1; i<=100; i++){
        sum+=i;
    }
    printf("%d\n",sum);
    return 0;
}

运行结果：

5050

代码分析：

1) 执行到 for 语句时，先给 i 赋初值1，判断 i<=100 是否成立；因为此时 i=1，i<=100 成立，所以执行循环体。循环体执行结束后（sum的值为1），再计算 i++。

2) 第二次循环时，i 的值为2，i<=100 成立，继续执行循环体。循环体执行结束后（sum的值为3），再计算 i++。

3) 重复执行步骤 2)，直到第101次循环，此时 i 的值为101，i<=100 不成立，所以结束循环。

由此我们可以总结出for循环的一般形式：

for(初始化语句; 循环条件; 自增或自减){
    语句块
}

for循环中的三个表达式

for 循环中的“表达式1（初始化条件）”、“表达式2(循环条件)”和“表达式3（自增或自减）”都是可选项，都可以省略（但分号;必须保留）。

1) 修改“从1加到100的和”的代码，省略“表达式1（初始化条件）”：

int i = 1, sum = 0;
for( ; i<=100; i++){
    sum+=i;
}

可以看到，将i=1移到了 for 循环的外面。

2) 省略了“表达式2(循环条件)”，如果不做其它处理就会成为死循环。例如：

for(i=1; ; i++) sum=sum+i;

相当于：

i=1;
while(1){
    sum=sum+i;
    i++;
}

所谓死循环，就是循环条件永远成立，循环会一直进行下去，永不结束。死循环对程序的危害很大，一定要避免。

3) 省略了“表达式3(自增或自减)”，就不会修改“表达式2(循环条件)”中的变量，这时可在循环体中加入修改变量的语句。例如：

for( i=1; i<=100; ){
    sum=sum+i;
    i++;
}

4) 省略了“表达式1(初始化语句)”和“表达式3(自增或自减)”。例如：

for( ; i<=100 ; ){
    sum=sum+i;
    i++;
}

相当于：

while(i<=100){
    sum=sum+i;
    i++;
}

5) 3个表达式可以同时省略。例如：

for( ; ; )  语句

相当于：

while(1)  语句

6) “表达式1”可以是初始化语句，也可以是其他语句。例如：

for( sum=0; i<=100; i++ )  sum=sum+i;

7) “表达式1”和“表达式3”可以是一个简单表达式也可以是逗号表达式。

for( sum=0,i=1; i<=100; i++ )  sum=sum+i;

或：

for( i=0,j=100; i<=100; i++,j-- )  k=i+j;

8) “表达式2”一般是关系表达式或逻辑表达式，但也可是数值或字符，只要其值非零，就执行循环体。例如：

for( i=0; (c=getchar())!='\n'; i+=c );

又如：

for( ; (c=getchar())!='\n' ; )
    printf("%c",c);

相关推荐：《c语言教程》

Das obige ist der detaillierte Inhalt vonWelche Steueranweisungen implementieren Schleifenstrukturen in der C-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!