Quelles sont les instructions de contrôle qui implémentent les structures de boucles en langage C ?

Les instructions de contrôle qui implémentent les structures de boucle en langage C incluent : l'instruction while, l'instruction do-while et l'instruction for. La forme générale est "while (expression) {bloc d'instructions}", "do {bloc d'instructions}". while (expression);", "pour (expression 1; expression 2; expression 3) {bloc d'instructions}".

La soi-disant boucle (Loop) consiste à exécuter le même morceau de code à plusieurs reprises, par exemple, pour calculer la valeur de 1+2+3+ ...+99+100, Il faut répéter l'opération d'addition 99 fois.

boucle while

La forme générale de la boucle while est :

while(表达式){
    语句块
}

Cela signifie, calculez d'abord l'expression " Valeur, lorsque la valeur est vraie (pas 0), exécutez le « bloc d'instructions » ; après avoir exécuté le « bloc d'instructions », calculez à nouveau la valeur de l'expression, si elle est vraie, continuez à exécuter le « bloc d'instructions ». .. Ce processus sera répété, jusqu'à ce que la valeur de l'expression soit fausse (0), quittez la boucle et exécutez le code après un certain temps.

Nous appelons généralement « l'expression » une condition de boucle et le « bloc d'instructions » un corps de boucle. L'ensemble du processus de boucle est le processus consistant à évaluer constamment la condition de boucle et à exécuter le code du corps de la boucle.

Utilisez une boucle while pour calculer la valeur de 1 ajoutée à 100 :

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

Résultats d'exécution :

5050

Code analyse :

1) Lorsque le programme s'exécute jusqu'à while, parce que i=1 et i<=100 sont vrais, le corps de la boucle sera exécuté après l'exécution, la valeur de i devient 2 et ; la valeur de la somme devient 1.

2) Ensuite, il continuera à juger si i<=100 est vrai, car à ce moment-là, i=2, i<=100 est vrai, donc le corps de la boucle continue d'être exécuté après l'exécution ; , la valeur de i devient 3, somme La valeur devient 3.

3) Répétez l'étape 2).

4) Lorsque la boucle atteint la 100ème fois, la valeur de i passe à 101 et la valeur de sum passe à 5050 car i<=100 n'est plus vrai à ce moment, la boucle est quittée et la boucle n'est plus exécutée, puis exécutez le code derrière la boucle while.

L'idée générale de la boucle while est la suivante : définir une condition de boucle avec des variables, c'est-à-dire une expression avec des variables ; ajouter une instruction supplémentaire au corps de la boucle afin qu'elle puisse modifier la condition de la boucle ; La valeur de la variable. De cette façon, à mesure que la boucle continue de s'exécuter, les valeurs des variables dans la condition de boucle continueront de changer. Il y aura éventuellement un moment où la condition de boucle n'est plus vraie et la boucle entière se terminera.

Que se passe-t-il si la condition de boucle ne contient pas de variables ?

1) Si la condition de boucle est vraie, la boucle while continuera à s'exécuter et ne se terminera jamais, devenant une "boucle infinie". Par exemple :

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

Lors de l'exécution du programme, "1" sera affiché en continu jusqu'à ce que l'utilisateur force sa fermeture.

2) Si la condition de boucle n'est pas vraie, la boucle while ne sera pas exécutée une seule fois. Par exemple :

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

Exécutez le programme et rien ne sera affiché.

Regardez un autre exemple, en comptant le nombre de caractères saisis dans une ligne à partir du clavier :

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

Résultats d'exécution :

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

La condition de boucle dans cet exemple de programme est getchar()!='n'，

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

n++;La condition de boucle dans cet exemple de programme est

Cela signifie que tant que le caractère saisi au clavier n'est pas un retour chariot, la boucle continuera. Le corps de la boucle

termine le comptage du nombre de caractères saisis. boucle do-while

En plus de la boucle while, il existe également une boucle do-while en langage C.

La forme générale d'une boucle do-while est :

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

La différence entre une boucle do-while et une boucle while est qu'elle exécutera l'instruction " block" d'abord, puis Déterminez si l'expression est vraie. Si elle est vraie, continuez la boucle ; si elle est fausse, terminez la boucle. Par conséquent, la boucle do-while doit exécuter le « bloc » au moins une fois.

Utilisez do-while pour calculer la valeur de 1 ajoutée à 100 :

5050

Résultat de l'exécution :

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

while(i<=100);;Notez le

point-virgule final

, c'est un incontournable.

Les boucles While et do-while ont leurs propres caractéristiques, vous pouvez choisir de manière appropriée. La boucle While est souvent utilisée dans la programmation réelle.

En plus de la boucle while, il existe également une boucle for en langage C, qui est plus flexible à utiliser et peut remplacer complètement la boucle while. boucle for

Ci-dessus on utilise une boucle while pour calculer la valeur de 1 ajoutée à 100, le code est le suivant :

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

On peut voir que les instructions ①②③ sont placées à différents endroits et que la structure du code est relativement lâche. Afin de rendre le programme plus compact, vous pouvez utiliser une boucle for à la place, comme indiqué ci-dessous :

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

Dans la boucle for, les instructions ①②③ sont regroupées et la structure du code est claire en un coup d'œil.

La forme générale de la boucle for est :

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

Son processus d'exécution est :

1) Exécutez d'abord "expression 1".

2) Exécutez ensuite "expression 2". Si sa valeur est vraie (non-0), alors exécutez le corps de la boucle, sinon terminez la boucle.

3) Exécutez "expression 3" après avoir exécuté le corps de la boucle.

4) Répétez les étapes 2) et 3) jusqu'à ce que la valeur de "expression 2" soit fausse, puis terminez la boucle.

<🎜>Dans les étapes ci-dessus, 2) et 3) sont une boucle et seront exécutées à plusieurs reprises. La fonction principale de l'instruction for est d'exécuter en continu les étapes 2) et 3). <🎜>

“表达式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语言教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!