1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MACWILLIAM: Parlons de boucles, l'une des communes

2
00:00:09,760 --> 00:00:13,380
constructions de programmation, nous verrons tout au long de CS50.

3
00:00:13,380 --> 00:00:15,570
Nous allons utiliser des boucles lorsque l'on veut effectuer une

4
00:00:15,570 --> 00:00:17,200
tâche plus d'une fois.

5
00:00:17,200 --> 00:00:20,700
Par exemple, on peut vouloir imprimer "hi" ou d'impression 100 fois

6
00:00:20,700 --> 00:00:22,700
toutes les lettres de l'alphabet.

7
00:00:22,700 --> 00:00:26,030
Dans ces deux cas, nous avons une chose que nous voulons faire

8
00:00:26,030 --> 00:00:28,700
plusieurs fois, d'imprimer quelque chose.

9
00:00:28,700 --> 00:00:31,970
Cependant, ce que nous imprimons à chaque fois peut varier.

10
00:00:31,970 --> 00:00:34,530
Donc, nous pouvons faire quelque chose de légèrement différent sur chaque

11
00:00:34,530 --> 00:00:37,820
itération, ou parcourir, de la boucle.

12
00:00:37,820 --> 00:00:41,280
Nous allons voir trois types de boucles en C, tandis que

13
00:00:41,280 --> 00:00:44,700
boucles, des boucles, et faire des boucles while.

14
00:00:44,700 --> 00:00:47,850
Bien que ces trois types de boucles ont une syntaxe différente,

15
00:00:47,850 --> 00:00:50,630
les idées derrière eux sont identiques.

16
00:00:50,630 --> 00:00:53,930
Nous allons définir un certain bloc de code entre accolades,

17
00:00:53,930 --> 00:00:57,810
appelé le corps de la boucle, que nous voulons faire exécuter

18
00:00:57,810 --> 00:00:59,790
un certain nombre de fois.

19
00:00:59,790 --> 00:01:03,370
En changeant les valeurs des variables utilisées dans le corps, nous

20
00:01:03,370 --> 00:01:07,570
peut faire notre boucle faire quelque chose de différent chaque fois qu'il est exécuté.

21
00:01:07,570 --> 00:01:10,750
Avec une boucle, nous écrire, nous allons également besoin de décider si l'

22
00:01:10,750 --> 00:01:12,400
boucle s'arrêtera.

23
00:01:12,400 --> 00:01:15,650
Si nous ne le faisons pas, alors notre fidèle ordinateur va continuer

24
00:01:15,650 --> 00:01:19,040
pour exécuter cette boucle jusqu'à ce que nous tuons le programme.

25
00:01:19,040 --> 00:01:22,490
Dans Scratch, nous pourrions utiliser la répétition n fois

26
00:01:22,490 --> 00:01:24,600
bloquer pour créer une boucle.

27
00:01:24,600 --> 00:01:28,200
Toutes les pièces à l'intérieur d'un bloc que ledit Répétez 10

28
00:01:28,200 --> 00:01:30,130
serait géré 10 fois.

29
00:01:30,130 --> 00:01:34,160
Et puis, nous aimerions passer aux morceaux après cette boucle.

30
00:01:34,160 --> 00:01:38,140
Donc, notre condition d'arrêt est tout simplement, ce bloc a été

31
00:01:38,140 --> 00:01:39,830
exécuter 10 fois.

32
00:01:39,830 --> 00:01:43,900
Donc, nous allons recréer ce en C. Pour Scratch pour assurer

33
00:01:43,900 --> 00:01:46,920
que les pièces à l'intérieur du bloc de répétition sont exécutées

34
00:01:46,920 --> 00:01:51,180
exactement 10 fois, Scratch a besoin de garder une trace de chaque

35
00:01:51,180 --> 00:01:53,750
l'exécution du bloc de répétition.

36
00:01:53,750 --> 00:01:56,790
Pour garder une trace de combien de fois notre corps de la boucle a été

37
00:01:56,790 --> 00:02:00,360
exécuté, nous allons créer une variable appelée i.

38
00:02:00,360 --> 00:02:03,400
Nous allons commencer i à zéro, puisque notre boucle

39
00:02:03,400 --> 00:02:04,650
n'a pas encore été exécuté.

40
00:02:10,009 --> 00:02:10,949
Bien

41
00:02:10,949 --> 00:02:15,560
Maintenant, nous allons utiliser le mot-clé alors que de commencer notre boucle.

42
00:02:20,100 --> 00:02:24,180
Maintenant, nous avons besoin de savoir quand notre boucle s'arrête, mais

43
00:02:24,180 --> 00:02:26,730
laissons cela pour l'instant, puis y revenir.

44
00:02:30,970 --> 00:02:32,150
Très bien.

45
00:02:32,150 --> 00:02:35,260
A l'intérieur de notre boucle, nous allons simplement imprimer un message, comme

46
00:02:35,260 --> 00:02:38,535
"Salut". Nous pouvons utiliser la fonction printf pour cela.

47
00:02:48,400 --> 00:02:49,230
Très bien.

48
00:02:49,230 --> 00:02:54,210
Alors maintenant, nous allons enregistrer qu'une itération du corps de la boucle est

49
00:02:54,210 --> 00:02:55,750
été exécutée.

50
00:02:55,750 --> 00:03:00,320
Nous pouvons faire cela en ajoutant 1 ou incrémentation, notre compteur

51
00:03:00,320 --> 00:03:01,740
variable, i.

52
00:03:01,740 --> 00:03:09,180
Pour ce faire, on peut dire i est égal à i + 1, ou plus

53
00:03:09,180 --> 00:03:16,520
simplement, i plus plus.

54
00:03:16,520 --> 00:03:17,320
Grande.

55
00:03:17,320 --> 00:03:21,810
Alors maintenant, nous pouvons voir que chaque fois que notre boucle est exécutée, notre

56
00:03:21,810 --> 00:03:24,500
variable compteur augmente d'une unité.

57
00:03:24,500 --> 00:03:29,410
Donc, nous savons exactement combien d'itérations, nous avons couru si loin.

58
00:03:29,410 --> 00:03:31,630
Après une itération de la boucle, la valeur de notre

59
00:03:31,630 --> 00:03:34,270
de i sera 1.

60
00:03:34,270 --> 00:03:37,460
Après deux itérations, je serai 2.

61
00:03:37,460 --> 00:03:42,640
Et au bout de 10 itérations, je serai 10.

62
00:03:42,640 --> 00:03:46,780
Donc, si nous voulons exécuter cette boucle exactement 10 fois, puis

63
00:03:46,780 --> 00:03:49,240
c'est à ce moment que nous voulons arrêter.

64
00:03:49,240 --> 00:03:53,860
Donc, nous voulons exécuter cette boucle while i est inférieur à 10, et

65
00:03:53,860 --> 00:03:57,630
c'est exactement ce que nous allons écrire, alors que je

66
00:03:57,630 --> 00:04:02,450
est inférieur à 10.

67
00:04:02,450 --> 00:04:06,380
Cette condition semble juste comme les conditions que nous avons utilisées dans le cas

68
00:04:06,380 --> 00:04:07,830
blocs else.

69
00:04:07,830 --> 00:04:11,690
Après que le corps de notre boucle a été exécutée, notre programme

70
00:04:11,690 --> 00:04:14,690
va revenir en arrière à la condition boucles.

71
00:04:14,690 --> 00:04:17,290
Si la condition est vraie, alors le corps de l'

72
00:04:17,290 --> 00:04:18,990
boucle sera exécutée à nouveau.

73
00:04:18,990 --> 00:04:22,190
Si la condition n'est plus le cas, alors notre boucle ne sera pas

74
00:04:22,190 --> 00:04:25,700
plus courir et passer à la ligne de code suivante

75
00:04:25,700 --> 00:04:27,876
en dessous de notre boucle.

76
00:04:27,876 --> 00:04:28,550
Très bien.

77
00:04:28,550 --> 00:04:30,740
Donc, nous allons jeter un coup d'oeil à un deuxième type de

78
00:04:30,740 --> 00:04:33,000
boucle, la boucle for.

79
00:04:33,000 --> 00:04:37,310
A côté de la clé alors que, entre parenthèses, nous avons eu une chose,

80
00:04:37,310 --> 00:04:39,840
à la condition que nécessaire pour être vrai pour le

81
00:04:39,840 --> 00:04:42,010
corps de la boucle doit être exécutée.

82
00:04:42,010 --> 00:04:45,440
Cela signifie que nous devions créer notre variable compteur à l'extérieur

83
00:04:45,440 --> 00:04:48,760
de la boucle et n'oubliez pas de l'incrémenter à un moment donné

84
00:04:48,760 --> 00:04:51,050
à l'intérieur de la boucle.

85
00:04:51,050 --> 00:04:54,320
L'en-tête pour notre boucle for, d'autre part, a trois

86
00:04:54,320 --> 00:04:58,510
parties, chacune d'elles seront séparées par un point-virgule.

87
00:04:58,510 --> 00:05:01,950
Dans notre premier tiers, nous pouvons déclarer un comptoir ou un assistant

88
00:05:01,950 --> 00:05:05,000
variables, nous aimerions utiliser dans notre boucle.

89
00:05:05,000 --> 00:05:07,350
En pratique, cela peut être vraiment utile.

90
00:05:07,350 --> 00:05:10,590
Nous n'avons vraiment pas besoin de cette variable, i, après notre tout

91
00:05:10,590 --> 00:05:13,650
boucle a été exécuté, si nous ne devrions pas avoir à le déclarer

92
00:05:13,650 --> 00:05:15,810
à l'extérieur de la boucle.

93
00:05:15,810 --> 00:05:19,080
Le deuxième tiers sera la condition qui doit être vraie

94
00:05:19,080 --> 00:05:21,850
pour le corps à être exécuté à nouveau, tout comme

95
00:05:21,850 --> 00:05:23,330
dans notre boucle while.

96
00:05:23,330 --> 00:05:26,350
Dans notre dernier tiers, on peut exécuter une instruction qui sera

97
00:05:26,350 --> 00:05:30,270
exécuté après chaque itération de la boucle, donc nous n'avons pas

98
00:05:30,270 --> 00:05:32,710
de l'intégrer dans le corps de la boucle.

99
00:05:32,710 --> 00:05:38,390
Donc, nous allons écrire une boucle for compte à rebours de 5 à 1.

100
00:05:38,390 --> 00:05:41,790
Nous allons commencer avec le mot-clé.

101
00:05:41,790 --> 00:05:44,680
Nous pouvons créer une variable premier compteur, que nous allons

102
00:05:44,680 --> 00:05:47,840
fixé à 5 cette fois puisque nous le compte à rebours,

103
00:05:47,840 --> 00:05:50,110
suivie d'un point-virgule.

104
00:05:50,110 --> 00:05:53,660
Suivant est notre condition, que nous y reviendrons.

105
00:05:53,660 --> 00:05:57,540
Troisièmement, nous aimerions diminuer notre variable compteur après

106
00:05:57,540 --> 00:05:59,620
chaque itération de la boucle.

107
00:05:59,620 --> 00:06:04,740
Ainsi, plutôt que de dire i plus plus, nous allons dire que je minus.

108
00:06:04,740 --> 00:06:05,300
Très bien.

109
00:06:05,300 --> 00:06:09,490
Donc, nous voulons que le corps de la boucle de tourner pendant que je demeure

110
00:06:09,490 --> 00:06:11,960
supérieur à 0.

111
00:06:11,960 --> 00:06:16,160
Dans le corps de la boucle, nous allons afficher la valeur de i.

112
00:06:16,160 --> 00:06:20,480
Pour ce faire, nous allons utiliser la fonction printf, en utilisant le d%

113
00:06:20,480 --> 00:06:21,650
espace réservé.

114
00:06:21,650 --> 00:06:24,820
Rappelez-vous, que sera remplacé à la

115
00:06:24,820 --> 00:06:27,040
valeur de i.

116
00:06:27,040 --> 00:06:32,060
Enfin, ajoutons une déclaration après notre boucle for.

117
00:06:32,060 --> 00:06:35,850
Quand nous courons cette boucle, je vais commencer à 5,

118
00:06:35,850 --> 00:06:38,070
donc 5 sera imprimé.

119
00:06:38,070 --> 00:06:42,000
Une fois que j'ai arrive à 0, la condition de poursuite, i est

120
00:06:42,000 --> 00:06:44,450
supérieur à 0, ne sont plus valables.

121
00:06:44,450 --> 00:06:47,330
Donc, notre boucle arrêter l'exécution, et nous verrons l'

122
00:06:47,330 --> 00:06:49,850
déclaration après la boucle.

123
00:06:49,850 --> 00:06:51,340
Donc, nous allons exécuter ce code.

124
00:06:51,340 --> 00:06:52,700
Tout d'abord, nous allons dresser une

125
00:06:52,700 --> 00:06:56,460
countdown.c avec make compte à rebours.

126
00:06:56,460 --> 00:06:59,320
Maintenant, nous pouvons exécuter ce code avec. / Compte à rebours.

127
00:07:02,340 --> 00:07:06,040
Dans les deux boucles while et les boucles for, notre poursuite

128
00:07:06,040 --> 00:07:09,010
condition sera vérifiée avant que le corps

129
00:07:09,010 --> 00:07:10,960
de la boucle est exécutée.

130
00:07:10,960 --> 00:07:13,840
Cela signifie que, si notre condition n'est pas initialement

131
00:07:13,840 --> 00:07:18,100
vrai, alors le corps de notre boucle ne sera jamais exécuté.

132
00:07:18,100 --> 00:07:22,060
Ainsi, il est parfois utile de vérifier l'état après la

133
00:07:22,060 --> 00:07:25,150
corps de la boucle et non avant celui-ci.

134
00:07:25,150 --> 00:07:28,270
Donc, nous allons écrire une boucle pour demander à l'utilisateur un certain nombre

135
00:07:28,270 --> 00:07:30,990
jusqu'à ce qu'un nombre positif est fourni.

136
00:07:30,990 --> 00:07:34,740
Si l'utilisateur saisit un nombre négatif, nous voulons leur demander

137
00:07:34,740 --> 00:07:36,260
pour un autre nombre.

138
00:07:36,260 --> 00:07:38,940
Il nous faudra donc cette invite à l'intérieur de la

139
00:07:38,940 --> 00:07:41,050
corps de la boucle.

140
00:07:41,050 --> 00:07:44,730
Toutefois, lorsque la boucle est exécuté pour la première fois, l'utilisateur

141
00:07:44,730 --> 00:07:46,750
ne nous a donné le nombre encore.

142
00:07:46,750 --> 00:07:49,640
Donc, il n'a pas de sens pour vérifier si elle est positive.

143
00:07:49,640 --> 00:07:54,020
Au lieu de cela, nous voulons vérifier le nombre après que le corps de

144
00:07:54,020 --> 00:07:55,720
la boucle est exécutée.

145
00:07:55,720 --> 00:08:00,310
Nous pouvons le faire avec une boucle Do While.

146
00:08:00,310 --> 00:08:03,560
Tout d'abord, nous allons créer une variable, n, qui tiendra

147
00:08:03,560 --> 00:08:05,230
l'entrée de l'utilisateur.

148
00:08:05,230 --> 00:08:09,960
Maintenant, nous allons utiliser le mot clé do, suivie d'accolades qui

149
00:08:09,960 --> 00:08:12,930
va commencer le corps de notre boucle.

150
00:08:12,930 --> 00:08:16,230
Dans le corps, on peut demander à l'utilisateur un numéro avec le

151
00:08:16,230 --> 00:08:18,480
GetInt fonction.

152
00:08:18,480 --> 00:08:23,230
Maintenant, nous allons vouloir le corps de cette boucle pour exécuter à nouveau si

153
00:08:23,230 --> 00:08:28,370
l'utilisateur a tapé un nombre négatif, alors on va dire que tout n

154
00:08:28,370 --> 00:08:30,420
est inférieure à 0.

155
00:08:30,420 --> 00:08:33,140
Notez le point-virgule ici après l'instruction while.

156
00:08:38,909 --> 00:08:40,679
Donc, nous allons exécuter ce code.

157
00:08:40,679 --> 00:08:44,780
Tout d'abord, nous allons compiler ce faire avec positif.

158
00:08:44,780 --> 00:08:49,340
Maintenant, nous pouvons exécuter le programme avec. / Positif.

159
00:08:49,340 --> 00:08:52,660
Si nous donnons à ce programme un nombre négatif, comme négative

160
00:08:52,660 --> 00:08:56,560
4, puis nous allons être à nouveau invité à un certain nombre depuis le

161
00:08:56,560 --> 00:09:00,490
condition de notre boucle Do While était vrai.

162
00:09:00,490 --> 00:09:04,690
Une fois que nous donnons un nombre positif, comme 8, puis le

163
00:09:04,690 --> 00:09:08,560
état de notre do while ne sera plus vrai.

164
00:09:08,560 --> 00:09:12,080
Ainsi, la boucle ne sera pas exécutée à nouveau.

165
00:09:12,080 --> 00:09:15,290
Et c'est tout pour les trois types de boucles que nous allons utiliser dans C.

166
00:09:15,290 --> 00:09:18,840
Mon nom est Tommy, et c'est CS50.