[Powered by Google Translate] TOMMY MACWILLIAM: Parlons de boucles, l'une des communes
constructions de programmation, nous verrons tout au long de CS50.
Nous allons utiliser des boucles lorsque l'on veut effectuer une
tâche plus d'une fois.
Par exemple, on peut vouloir imprimer "hi" ou d'impression 100 fois
toutes les lettres de l'alphabet.
Dans ces deux cas, nous avons une chose que nous voulons faire
plusieurs fois, d'imprimer quelque chose.
Cependant, ce que nous imprimons à chaque fois peut varier.
Donc, nous pouvons faire quelque chose de légèrement différent sur chaque
itération, ou parcourir, de la boucle.
Nous allons voir trois types de boucles en C, tandis que
boucles, des boucles, et faire des boucles while.
Bien que ces trois types de boucles ont une syntaxe différente,
les idées derrière eux sont identiques.
Nous allons définir un certain bloc de code entre accolades,
appelé le corps de la boucle, que nous voulons faire exécuter
un certain nombre de fois.
En changeant les valeurs des variables utilisées dans le corps, nous
peut faire notre boucle faire quelque chose de différent chaque fois qu'il est exécuté.
Avec une boucle, nous écrire, nous allons également besoin de décider si l'
boucle s'arrêtera.
Si nous ne le faisons pas, alors notre fidèle ordinateur va continuer
pour exécuter cette boucle jusqu'à ce que nous tuons le programme.
Dans Scratch, nous pourrions utiliser la répétition n fois
bloquer pour créer une boucle.
Toutes les pièces à l'intérieur d'un bloc que ledit Répétez 10
serait géré 10 fois.
Et puis, nous aimerions passer aux morceaux après cette boucle.
Donc, notre condition d'arrêt est tout simplement, ce bloc a été
exécuter 10 fois.
Donc, nous allons recréer ce en C. Pour Scratch pour assurer
que les pièces à l'intérieur du bloc de répétition sont exécutées
exactement 10 fois, Scratch a besoin de garder une trace de chaque
l'exécution du bloc de répétition.
Pour garder une trace de combien de fois notre corps de la boucle a été
exécuté, nous allons créer une variable appelée i.
Nous allons commencer i à zéro, puisque notre boucle
n'a pas encore été exécuté.
Bien
Maintenant, nous allons utiliser le mot-clé alors que de commencer notre boucle.
Maintenant, nous avons besoin de savoir quand notre boucle s'arrête, mais
laissons cela pour l'instant, puis y revenir.
Très bien.
A l'intérieur de notre boucle, nous allons simplement imprimer un message, comme
"Salut". Nous pouvons utiliser la fonction printf pour cela.
Très bien.
Alors maintenant, nous allons enregistrer qu'une itération du corps de la boucle est
été exécutée.
Nous pouvons faire cela en ajoutant 1 ou incrémentation, notre compteur
variable, i.
Pour ce faire, on peut dire i est égal à i + 1, ou plus
simplement, i plus plus.
Grande.
Alors maintenant, nous pouvons voir que chaque fois que notre boucle est exécutée, notre
variable compteur augmente d'une unité.
Donc, nous savons exactement combien d'itérations, nous avons couru si loin.
Après une itération de la boucle, la valeur de notre
de i sera 1.
Après deux itérations, je serai 2.
Et au bout de 10 itérations, je serai 10.
Donc, si nous voulons exécuter cette boucle exactement 10 fois, puis
c'est à ce moment que nous voulons arrêter.
Donc, nous voulons exécuter cette boucle while i est inférieur à 10, et
c'est exactement ce que nous allons écrire, alors que je
est inférieur à 10.
Cette condition semble juste comme les conditions que nous avons utilisées dans le cas
blocs else.
Après que le corps de notre boucle a été exécutée, notre programme
va revenir en arrière à la condition boucles.
Si la condition est vraie, alors le corps de l'
boucle sera exécutée à nouveau.
Si la condition n'est plus le cas, alors notre boucle ne sera pas
plus courir et passer à la ligne de code suivante
en dessous de notre boucle.
Très bien.
Donc, nous allons jeter un coup d'oeil à un deuxième type de
boucle, la boucle for.
A côté de la clé alors que, entre parenthèses, nous avons eu une chose,
à la condition que nécessaire pour être vrai pour le
corps de la boucle doit être exécutée.
Cela signifie que nous devions créer notre variable compteur à l'extérieur
de la boucle et n'oubliez pas de l'incrémenter à un moment donné
à l'intérieur de la boucle.
L'en-tête pour notre boucle for, d'autre part, a trois
parties, chacune d'elles seront séparées par un point-virgule.
Dans notre premier tiers, nous pouvons déclarer un comptoir ou un assistant
variables, nous aimerions utiliser dans notre boucle.
En pratique, cela peut être vraiment utile.
Nous n'avons vraiment pas besoin de cette variable, i, après notre tout
boucle a été exécuté, si nous ne devrions pas avoir à le déclarer
à l'extérieur de la boucle.
Le deuxième tiers sera la condition qui doit être vraie
pour le corps à être exécuté à nouveau, tout comme
dans notre boucle while.
Dans notre dernier tiers, on peut exécuter une instruction qui sera
exécuté après chaque itération de la boucle, donc nous n'avons pas
de l'intégrer dans le corps de la boucle.
Donc, nous allons écrire une boucle for compte à rebours de 5 à 1.
Nous allons commencer avec le mot-clé.
Nous pouvons créer une variable premier compteur, que nous allons
fixé à 5 cette fois puisque nous le compte à rebours,
suivie d'un point-virgule.
Suivant est notre condition, que nous y reviendrons.
Troisièmement, nous aimerions diminuer notre variable compteur après
chaque itération de la boucle.
Ainsi, plutôt que de dire i plus plus, nous allons dire que je minus.
Très bien.
Donc, nous voulons que le corps de la boucle de tourner pendant que je demeure
supérieur à 0.
Dans le corps de la boucle, nous allons afficher la valeur de i.
Pour ce faire, nous allons utiliser la fonction printf, en utilisant le d%
espace réservé.
Rappelez-vous, que sera remplacé à la
valeur de i.
Enfin, ajoutons une déclaration après notre boucle for.
Quand nous courons cette boucle, je vais commencer à 5,
donc 5 sera imprimé.
Une fois que j'ai arrive à 0, la condition de poursuite, i est
supérieur à 0, ne sont plus valables.
Donc, notre boucle arrêter l'exécution, et nous verrons l'
déclaration après la boucle.
Donc, nous allons exécuter ce code.
Tout d'abord, nous allons dresser une
countdown.c avec make compte à rebours.
Maintenant, nous pouvons exécuter ce code avec. / Compte à rebours.
Dans les deux boucles while et les boucles for, notre poursuite
condition sera vérifiée avant que le corps
de la boucle est exécutée.
Cela signifie que, si notre condition n'est pas initialement
vrai, alors le corps de notre boucle ne sera jamais exécuté.
Ainsi, il est parfois utile de vérifier l'état après la
corps de la boucle et non avant celui-ci.
Donc, nous allons écrire une boucle pour demander à l'utilisateur un certain nombre
jusqu'à ce qu'un nombre positif est fourni.
Si l'utilisateur saisit un nombre négatif, nous voulons leur demander
pour un autre nombre.
Il nous faudra donc cette invite à l'intérieur de la
corps de la boucle.
Toutefois, lorsque la boucle est exécuté pour la première fois, l'utilisateur
ne nous a donné le nombre encore.
Donc, il n'a pas de sens pour vérifier si elle est positive.
Au lieu de cela, nous voulons vérifier le nombre après que le corps de
la boucle est exécutée.
Nous pouvons le faire avec une boucle Do While.
Tout d'abord, nous allons créer une variable, n, qui tiendra
l'entrée de l'utilisateur.
Maintenant, nous allons utiliser le mot clé do, suivie d'accolades qui
va commencer le corps de notre boucle.
Dans le corps, on peut demander à l'utilisateur un numéro avec le
GetInt fonction.
Maintenant, nous allons vouloir le corps de cette boucle pour exécuter à nouveau si
l'utilisateur a tapé un nombre négatif, alors on va dire que tout n
est inférieure à 0.
Notez le point-virgule ici après l'instruction while.
Donc, nous allons exécuter ce code.
Tout d'abord, nous allons compiler ce faire avec positif.
Maintenant, nous pouvons exécuter le programme avec. / Positif.
Si nous donnons à ce programme un nombre négatif, comme négative
4, puis nous allons être à nouveau invité à un certain nombre depuis le
condition de notre boucle Do While était vrai.
Une fois que nous donnons un nombre positif, comme 8, puis le
état de notre do while ne sera plus vrai.
Ainsi, la boucle ne sera pas exécutée à nouveau.
Et c'est tout pour les trois types de boucles que nous allons utiliser dans C.
Mon nom est Tommy, et c'est CS50.