Les instructions de contrôle sont utilisées pour contrôler le flux d'exécution du programme afin d'implémenter diverses méthodes structurelles du programme. Elles sont composées de définisseurs d'instructions spécifiques. Il existe neuf types d'instructions de contrôle en langage C.

Peut être divisé en trois catégories suivantes :

Les instructions de jugement conditionnel sont également appelées instructions de branchement : instructions if et instructions switch.
Instructions d'exécution de boucle : instruction do while, instruction while, instruction for.
Instructions Turn : instruction break, instruction goto, instruction continue, instruction return.

【2】Instruction de branche (structure de sélection)

Si vous étudiez dur, obtenez une bonne offre lors du recrutement scolaire et atteignez le sommet de votre vie. Si vous n'étudiez pas, l'obtention du diplôme signifie le chômage et la vente de patates douces à la maison. C'est le choix !

【2.1】instruction if

【2.1.1】Structure grammaticale

Quelle est la structure grammaticale de l’instruction if ?

// 语法结构：No.1
if(表达式)
	语句;
// 语法结构：No.2
if(表达式)
	语句1;
else
	语句2;

// 语法结构：No.3 多分支
if(表达式1)
语句1;
else if(表达式2)
	语句2;
else
	语句3;

【Exemple de code】

// No.1 代码
#include <stdio.h>

int main() {
	int age = 0;
	scanf("%d", &age);
	if (age < 18)
		printf("未成年！\n");

	return 0;
}

// No.2 代码
#include <stdio.h>

int main(int argc, char** argv) {
	int age = 0;
	scanf("%d", &age);

	if (age < 18)
		printf("未成年！\n");
	else {
		printf("成年！\n");
	}
		
	return 0;
}

// No.3 代码
#include <stdio.h>

int main(int argc, char** argv) {
	int age = 0;
	scanf("%d", &age);


	if (age < 18) {
		printf("少年\n");
	}  
	else if (age >= 18 && age < 30) {
		printf("青年\n");
	}  
	else if (age >= 30 && age < 50) {
		printf("中年\n");
	}  
	else if (age >= 50 && age < 80) {
		printf("老年\n");
	}  
	else {
		printf("老寿星\n");
	}

	return 0;
}

Expliquez : Si le résultat de l'expression est vrai, l'instruction est exécutée. En langage C, 0 signifie faux et non-0 signifie vrai .

Comment devrions-nous utiliser les blocs de code si plusieurs instructions doivent être exécutées si la condition est vraie.

#include <stdio.h>
int main()
{
	if (表达式)
	{
		语句列表1；
	}
	else
	{
		语句列表2；
	}
	return 0;
}

La paire de { } ici est un bloc de code.

【2.1.2】Laisser vide sinon

Quand vous écrivez ce code :

#include <stdio.h>
int main()
{
	int a = 0;
	int b = 2;
	if (a == 1)
		if (b == 2)
			printf("hehe\n");
		else
			printf("haha\n");
	return 0;
}

Après modification : correspondance de else : else correspond au if le plus proche.

//适当的使用{}可以使代码的逻辑更加清楚。
//代码风格很重要
#include <stdio.h>
int main()
{
	int a = 0;
	int b = 2;
	if (a == 1)
	{
		if (b == 2)
		{
			printf("hehe\n");
		}
	}
	else
	{
		printf("haha\n");
	}
	return 0;
}

【2.1.3】Comparaison des formes d'écriture

Parmi les codes suivants : le Code 2 et le Code 4 sont meilleurs, avec une logique plus claire et moins sujets aux erreurs.

//代码1
if (condition) {
	return x;
}
return y;
//代码2
if (condition)
{
	return x;
}
else
{
	return y;
}

//代码3
int num = 1;
if (num == 5)
{
	printf("hehe\n");
}
//代码4
int num = 1;
if (5 == num)
{
	printf("hehe\n");
}

【2.1.4】Pratique

[Code d'exercice] Déterminez si un nombre est impair.

#include <stdio.h>

// 判断一个数是否为奇数 
int main(int argc, char** argv) {
	int val = 0;
	scanf("%d", &val);

	if (val % 2 == 0)
		printf("偶数！\n");
	else
		printf("奇数！\n");
}

[Code d'exercice] Afficher des nombres impairs entre 1 et 100

#include <stdio.h>

int main(int argc, char** argv) {
	int num = 1;

	while (num <= 100) {
		if(num % 2 == 0)
			printf("%d->偶数！\n", num);
		else
			printf("%d->奇数！\n", num);
		num++;
	}
	return 0;
}

【2.2】instruction de commutation

【3.2.1】Structure grammaticale

L'instruction switch est également une instruction de branche et est souvent utilisée dans des situations multibranches.

【Par exemple】

Entrée 1, sortie lundi
Entrée 2, sortie mardi
Entrée 3, sortie mercredi
Entrée 4, sortie jeudi
Entrez 5 et sortez vendredi
Entrez 6 et sortez samedi
Entrez 7 et sortez dimanche

Ensuite, je ne l'ai pas écrit comme si... sinon si... sinon si. La forme est trop compliquée, nous devons donc avoir une forme grammaticale différente.

C'est l'instruction switch.

switch(整型表达式)
{
	语句项(是一些case语句)；
}

case 整形常量表达式:
	语句;

【3.2.2】instruction de coupure dans l'interrupteur

Dans l'instruction switch, nous ne pouvons pas implémenter directement la branche, ce n'est qu'en utilisant break que nous pouvons obtenir la vraie branche.

【Exemple de code】

int main(int argc, char** argv) {
	int day = 1;

	switch (day) {
		case 1:
			printf("星期一\n");
			break;
		case 2:
			printf("星期二\n");
			break;
		case 3:
			printf("星期三\n");
			break;
		case 4:
			printf("星期四\n");
			break;
		case 5:
			printf("星期五\n");
			break;
		case 6:
			printf("星期六\n");
			break;
		case 7:
			printf("星期天\n");
			break;
	}
	return 0;
}

Parfois nos besoins changent :

Entrée 1-5, la sortie est « jour de la semaine » ;
Entrez 6-7 et affichez « week-end » ;

Notre code devrait donc être implémenté comme ceci :

#include <stdio.h>

int main(int argc, char** argv) {
	int day = 0;

	switch (day)
	{
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			printf("weekday\n");
			break;
		case 6:
		case 7:
			printf("weekend\n");
			break;
	}
	
	return 0;
}

L'effet réel de l'instruction break est de diviser la liste d'instructions en différentes parties de branche.

[Bonnes habitudes de programmation]

Ajoutez une instruction break après la dernière instruction case (la raison de cet écriture est d'éviter d'oublier d'ajouter une instruction break après la dernière instruction case).

【3.2.3】clause par défaut

Que se passe-t-il si la valeur de l'expression ne correspond à la valeur d'aucune balise case ? En fait, ce n'est rien, la structure est juste que toutes les instructions sont ignorées. Le programme ne se terminera pas et aucune erreur ne sera signalée, car cette situation n'est pas considérée comme une erreur en C. Mais que se passe-t-il si vous ne voulez pas ignorer les valeurs d’expressions qui ne correspondent pas à toutes les balises ? Vous pouvez ajouter une clause par défaut à la liste des instructions et mettre l'étiquette suivantedefault：

Écrivez-le partout où une étiquette de cas peut apparaître. Lorsque la valeur de l'expression switch ne correspond pas aux valeurs de toutes les étiquettes de cas, l'instruction suivant la clause par défaut sera exécutée. Par conséquent, une seule clause par défaut peut apparaître dans chaque instruction switch. Mais elle peut apparaître n'importe où dans la liste des instructions, et le flux d'instructions exécutera la clause par défaut tout comme une étiquette de cas.

[Bonnes habitudes de programmation]

C'est une bonne habitude de mettre une clause par défaut dans chaque instruction switch, peut-être même une pause à la fin.

#include <stdio.h>

int main(int argc, char** argv) {
	int day = 0;

	switch (day)
	{
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			printf("weekday\n");
			break;
		case 6:
		case 7:
			printf("weekend\n");
			break;
		default:
			printf("day的值不在1-7范围内！");
	}
	
	return 0;
}

【3.2.4】Pratique

#include <stdio.h>
int main()
{
	int n = 1;				
	int m = 2;					// n=1, m=2
	switch (n)
	{
	case 1:
		m++;					// n=1, m=3			
	case 2:
		n++;					// n=2, m=3		
	case 3:
		switch (n)				// n=2, m=3		
		{//switch允许嵌套使用
		case 1:
			n++;
		case 2:
			m++;				
			n++;				// n=3, m=4		
			break;
		}
	case 4:
		m++;					// n=3, m=5		
		break;
	default:
		break;
	}
    
	printf("m = %d, n = %d\n", m, n);		// 打印结果m=5， n=3
	return 0;
}

【3】Instruction de boucle

【3.1】boucle while

【3.1.1】Format de grammaire

Le langage C nous présente : l'instruction while, qui peut implémenter des boucles.

while(表达式)
	循环语句;

Le flux d’exécution de l’instruction while :

[Exemple de code] Imprimez les numéros 1 à 10 sur l'écran.

#include <stdio.h>

int main(int argc, char** argv) {
	int iVal = 0;

	while (iVal < 10) {
		printf("%d ", iVal + 1);
		iVal++;
	}

	return 0;
}

// 打印结果：1 2 3 4 5 6 7 8 9 10

Le code ci-dessus m'a aidé à comprendre la syntaxe de base de l'instruction while, alors apprenons-en plus :

【3.1.2】instruction d'intrusion while

#include <stdio.h>

int main(int argc, char** argv) {
	int iVal = 0;

	while (iVal < 10) {
		if (iVal == 5) {
			break;
		}

		printf("%d ", iVal + 1);
		iVal = iVal + 1;
	}
}

// 打印结果：1 2 3 4 5  （后面就结束了）

[Résumé] Le rôle du break dans la boucle while : En fait, tant qu'un break est rencontré dans la boucle, toutes les boucles suivantes seront arrêtées et la boucle se terminera directement. Donc : le break in while est utilisé pour terminer la boucle en permanence .

【3.1.3】continuer dans l'instruction while

#include <stdio.h>

int main(int argc, char** argv) {
	int iVal = 0;

	while (iVal < 10) {
		if (iVal == 5) {
			continue;
		}

		printf("%d ", iVal + 1);
		iVal = iVal + 1;
	}
}

// 打印结果：1 2 3 4 5 （后面就死循环了）

[Résumé] Le rôle de continue dans la boucle while est le suivant : continue est utilisé pour terminer cette boucle, c'est-à-dire que le code après continue dans cette boucle ne sera pas exécuté à nouveau, mais passera directement à la partie jugement de l'instruction while. Faire le jugement d'entrée pour le cycle suivant .

【3.1.4】Pratique

[Présentation de la fonction]

int getchar ( void );
/*
	描述：
		从stdin中获取字符
	返回值：
		如果成功，则返回所读取的字符(提升为int值)。
		返回类型为int，以适应特殊值EOF(-1)，它表示失败。
		如果标准输入位于文件末尾，则该函数返回EOF并设置stdin的EOF(-1)指示器(feof)。
*/	
	
int putchar ( int character );
/*
	描述：
		将字符写入标准输出，将字符写入标准输出(stdout)。
	参数：
		要读取的字符变量。
	返回值：
		如果发生写错误，则返回EOF并设置错误指示器(error)。
*/

//代码1
#include <stdio.h>
int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)
		putchar(ch);
	return 0;
}
// 这里的代码适当的修改是可以用来清理缓冲区的。

//代码2
#include <stdio.h>
int main()
{
	char ch = '\0';
	while ((ch = getchar()) != EOF)
	{
		if (ch < ‘0’ || ch > ‘9’)
			continue;
		putchar(ch);
	}
	return 0;
}
//这个代码的作用是：只打印数字字符，跳过其他字符的。

【3.2】pour la boucle

Nous connaissons déjà la boucle while, mais pourquoi avons-nous besoin d'une boucle for ?

【3.2.1】Format de grammaire

for(表达式1; 表达式2; 表达式3)
	循环语句;

/*
解释：
	表达式1：表达式1为初始化部分，用于初始化循环变量的。
	表达式2：表达式2为条件判断部分，用于判断循环时候终止。
	表达式3：表达式3为调整部分，用于循环条件的调整。
*/

Le processus d’exécution de l’instruction for :

[Exemple de code] Utilisez une boucle for pour imprimer les nombres 1 à 10 sur l'écran.

int main(int argc, char** argv) {
	for (int i = 0; i < 10; i++) {
		printf("%d ", i + 1);
	}
}

Comparons maintenant la boucle for et la boucle while :

#include <stdio.h>

int main(int argc, char** argv) {
	int i = 0;

	//实现相同的功能，使用while
	i = 1;//初始化部分
	while (i <= 10)//判断部分
	{
		printf("hehe\n");
		i = i + 1;//调整部分
	}
	//实现相同的功能，使用while
	for (i = 1; i <= 10; i++)
	{
		printf("hehe\n");
	}
}

On peut constater qu'il y a encore trois conditions nécessaires pour la boucle dans la boucle while, mais en raison de problèmes de style, les trois parties sont susceptibles de s'écarter très loin, ce n'est donc pas suffisamment centralisé et pratique pour trouver des modifications. Par conséquent, le style de boucle for est supérieur ; la boucle for est également utilisée le plus fréquemment.

【3.2.2】instruction d'intrusion while

Nous avons constaté que break et continue peuvent également apparaître dans la boucle for et que leur signification est la même que dans la boucle while.

//代码1
#include <stdio.h>
int main()
{
	int i = 0;
	for (i = 1; i <= 10; i++)
	{
		if (i == 5)
			break;
		printf("%d ", i);
	}
	return 0;
}

【3.2.3】continuer dans l'instruction while

Nous avons constaté que break et continue peuvent également apparaître dans la boucle for et que leur signification est la même que dans la boucle while.

//代码2
#include <stdio.h>
int main()
{
	int i = 0;
	for (i = 1; i <= 10; i++)
	{
		if (i == 5)
			continue;
		printf("%d ", i);
	}
	return 0;
}

【3.2.4】Variables de contrôle de boucle de l'instruction for

【Suggestions】：

Les variables de boucle ne peuvent pas être modifiées dans le corps de la boucle for pour éviter que la boucle for ne perde le contrôle.
Il est recommandé que la valeur de la variable de contrôle de boucle de l'instruction for soit écrite au format « plage avant fermée puis ouverte ».

int i = 0;
//前闭后开的写法
for(i=0; i<10; i++)
{}
//两边都是闭区间
for(i=0; i<=9; i++)
{}

【3.2.5】Quelques variantes de la boucle for

#include <stdio.h>

int main()
{
	//代码1
	for (;;)
	{
		printf("hehe\n");
	}
	//for循环中的初始化部分，判断部分，调整部分是可以省略的，但是不建议初学时省略，容易导致问题。
	
	//代码2
	int i = 0;
	int j = 0;
	//这里打印多少个hehe?
	for (i = 0; i < 10; i++)
	{
		for (j = 0; j < 10; j++)
		{
			printf("hehe\n");
		}
	}

	//代码3
	int i = 0;
	int j = 0;
	//如果省略掉初始化部分，这里打印多少个hehe?
	for (; i < 10; i++)
	{
		for (; j < 10; j++)
		{
			printf("hehe\n");
		}
	}

	//代码4-使用多余一个变量控制循环
	int x, y;
	for (x = 0, y = 0; x < 2 && y < 5; ++x, y++)
	{
		printf("hehe\n");
	}
	return 0;
}

【3.3】 faire une boucle while

【3.3.1】Format de grammaire

do
	循环语句;
while(表达式);

Le flux d'exécution de l'instruction do while :

【Exemple de code】

#include <stdio.h>

int main(int argc, char** argv) {
	int i = 10;
	do {
	
		printf("%d\n", i);
	
	} while (i < 10);

	return 0;
}

【3.3.2】instruction break in do while

#include <stdio.h>

int main()
{
	int i = 10;
	do
	{
		if (5 == i)
			break;
		printf("%d\n", i);
	} while (i < 10);
	return 0;
}

【3.3.3】continuez dans l'instruction do while

#include <stdio.h>

int main()
{
	int i = 10;
	do
	{
		if (5 == i)
			continue;
		printf("%d\n", i);
	} while (i < 10);
	return 0;
}

【3.4】Exercices complets

[Exercice 1] Calculez la factorielle de n.

#include <stdio.h>

int main(int argc, char** argv) {
	// 接收要计算的乘积.
	int n = 0;
	scanf("%d", &n);

	// 计算
	int result = 1;
	for (int i = 1; i <= n; i++) {
		result *= i;
	}
	// 打印
	printf("%d\n", result);

	return 0;
}

【Exercice 2】Calculez 1!+2!+3!+……+10!

int main(int argc, char** argv) {
	// 接收要计算的乘积.
	int n = 0;
	scanf("%d", &n);

	int result = 0;
	int ret = 1;
	for (int i = 1; i <= n; i++) {
		ret = ret * i;

		result = result + ret;
	}
	// 打印
	printf("%d\n", result);
}

[Exercice 3] Trouvez un nombre n spécifique dans un tableau ordonné.

#include <stdio.h>

int main(int argc, char** argv) {
	int buffer[] = { 1,2,3,4,5,6,7,8,9,10 };
	int size = sizeof(buffer) / sizeof(int);

	// 要查找的值
	int k = 4;
	// 暴力循环查找
	int i = 0;
	for (i = 0; i < size; i++) {
		if (k == buffer[i]) {
			printf("找到了->要找的值为%d\n", i);
			break;
		}
	}

	// 没有找到的话，说明遍历的一圈。
	if (i == size) {
		printf("没有找到\n");
	}

	return 0;
}

[Exercice 4] Écrivez du code pour démontrer que plusieurs caractères se déplacent des deux côtés et convergent vers le milieu.

#include <stdio.h>
#include <windows.h>

int main(int argc, char** argv) {
	char arr1[] = "welcome to lesson!!!!";
	char arr2[] = "#####################";

	int leftSub = 0;
	int rightSub = sizeof(arr1) / sizeof(arr1[0]) - 1;

	printf("%s\n", arr2);
	Sleep(1000);
	while (leftSub <= rightSub) {
		arr2[leftSub] = arr1[leftSub];
		arr2[rightSub] = arr1[rightSub];
		printf("%s\n", arr2);

		Sleep(1000);	// Sleep() 系统休眠, 头文件包含<windows.h>
		leftSub++;
		rightSub--;
	}
	return 0;
}

[Exercice 5] Écrivez du code pour simuler le scénario de connexion de l'utilisateur et ne pouvez vous connecter que trois fois. (Vous n'êtes autorisé à saisir le mot de passe que trois fois. Si le mot de passe est correct, vous serez invité à vous connecter. Si vous saisissez le mauvais mot de passe trois fois, vous quitterez le programme.

#include <stdio.h>
#include <string.h>

int main(int argc, char** argv) {
	char user[] = "shaxiang";
	char password[20] = { 0 };

	int i = 0;
	for (i = 0; i < 3; i++) {
		printf("请输入密码:> ");
		scanf("%s", password);

		if (strcmp(password, "shaxiang") == 0) {
			printf("登陆成功！\n");
			break;
		}
		else
		{
			printf("密码错误！\n");
		}
	}

	if (i >= 3) {
		printf("密码错误3次，没有机会了！\n");
	}

	return 0;
}

[Exercice 6] Mise en œuvre du jeu de devinettes

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>

void Menu() {
	printf("********************************\n");
	printf("*********    1、play    ********\n");
	printf("*********    0、exit    ********\n");
	printf("********************************\n");
}

void Game() {
	// 用户输入猜到的数字
	int num = rand() % 100 + 1;
	printf("随机数生成成功：请输入猜想的数组:> \n");
	
	int in = 0;
	while (1) {
		scanf("%d", &in);

		if (in > num) {
			printf("猜大了！\n");
		}
		else if (in < num) {
			printf("猜小了！\n");
		}
		else
		{
			printf("恭喜你猜对了！\n");
			break;
		}
	}
}

int main(int argc, char** argv) {
	int in = 0;

	do {
		Menu();
		printf("是否继续猜数字>: ");
		scanf("%d", &in);
		switch (in) {
		case 1:
			// 生成随机数种子
			srand((unsigned int)time(NULL));
			Game();
			break;
		case 0:
			printf("已退出！\n");
			break;
		default:
			printf("错误选择，请重新选择！\n");
		}
	} while (in);
}

【4】Algorithme de demi-recherche

[Image]

#include <stdio.h>

int main(int argc, char** argv) {
	int buffer[] = { 1,2,3,4,5,6,7,8,9,10 };
	// 要查找的值
	int findK = 4;
	
	// 二分查找
	int leftSub = 0;
	int rightSub = sizeof(buffer) / sizeof(int) - 1;
	
	while (leftSub <= rightSub) {
		int mid = (leftSub + rightSub) / 2;
		if (findK < buffer[mid]) {
			rightSub = mid - 1;
		}
		else if (findK > buffer[mid]) {
			leftSub = mid + 1;
		}
		else
		{
			printf("找到了->[%d]下标为[%d]\n", findK, mid);
			break;
		}
	}

	if (leftSub > rightSub) {
		printf("未找到[%d]的下标!", findK);
	}

	return 0;
}

【5】 déclaration aller à

Le langage C fournit des instructions goto dont on peut abuser à volonté et des étiquettes pour marquer les sauts. En théorie, les instructions goto ne sont pas nécessaires. En pratique, il est facile d'écrire du code sans instructions goto. Cependant, dans certains cas, les instructions goto sont toujours nécessaires L'utilisation la plus courante consiste à terminer le traitement de certaines structures profondément imbriquées.

Par exemple : sauter de deux ou plusieurs couches de boucles à la fois. L'utilisation de break dans ce cas de boucles multicouches ne permettra pas d'atteindre l'objectif. Il ne peut sortir que de la boucle la plus interne vers la boucle du niveau précédent.

Les scénarios pour lesquels le langage goto est vraiment adapté sont les suivants :

for (...)
{
	for (...)
	{
		if (disaster)
			goto error;
	}
}
…
error :
if (disaster)
// 处理错误情况

Voici un exemple d'utilisation d'une instruction goto, puis de remplacement de l'instruction goto par une implémentation de boucle :

#include <stdio.h>
#include <windows.h>
int main()
{
	system("shutdown -s -t 60");
	char input[10] = { 0 };
	
again:
	printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
	scanf("%s", input);

	if (0 == strcmp(input, "我是猪")) {
		system("shutdown -a");
	}
	else {
		goto again;
	}

	return 0;
}

Et si les instructions goto ne sont pas applicables, vous pouvez utiliser des boucles :

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
int main_24()
{
	char input[10] = { 0 };
	system("shutdown -s -t 60");
	while (1)
	{
		printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
		scanf("%s", input);
		if (0 == strcmp(input, "我是猪"))
		{
			system("shutdown -a");
			break;
		}
	}
	return 0;
}

shutdown_Encyclopédie Baidu (baidu.com)

【C】Instructions de branchement et de boucle

【1】Qu'est-ce qu'une déclaration ?

【2】Instruction de branche (structure de sélection)

【2.1】instruction if

【2.1.1】Structure grammaticale

【2.1.2】Laisser vide sinon

【2.1.3】Comparaison des formes d'écriture

【2.1.4】Pratique

【2.2】instruction de commutation

【3.2.1】Structure grammaticale

【3.2.2】instruction de coupure dans l'interrupteur

【3.2.3】clause par défaut

【3.2.4】Pratique

【3】Instruction de boucle

【3.1】boucle while

【3.1.1】Format de grammaire

【3.1.2】instruction d'intrusion while

【3.1.3】continuer dans l'instruction while

【3.1.4】Pratique

【3.2】pour la boucle

【3.2.1】Format de grammaire

【3.2.2】instruction d'intrusion while

【3.2.3】continuer dans l'instruction while

【3.2.4】Variables de contrôle de boucle de l'instruction for

【3.2.5】Quelques variantes de la boucle for

【3.3】 faire une boucle while

【3.3.1】Format de grammaire

【3.3.2】instruction break in do while

【3.3.3】continuez dans l'instruction do while

【3.4】Exercices complets

【4】Algorithme de demi-recherche

【5】 déclaration aller à

おすすめ