>> DOUG LLOYD: Très bien, alors Parlons boucles.
Donc boucles sont plutôt cool parce qu'ils permettent à votre programme
pour exécuter des lignes de code Encore et encore et encore.
À plusieurs reprises, sans avoir à copier et coller ou autrement les répéter.
Il ya trois principaux sortes de boucles vous verrez.
Vous aurez probablement l'occasion d'utiliser chacun que vous progressez dans CS50.
Certains de ces boucles sont assez familier pour vous à partir de zéro,
Encore une fois, comme nous l'avons fait avec les conditionnels, nous allons les mettre côte à côte
si il ya une analogie, nous pouvons tirer.
>> Première est toujours à partir de zéro, ce qui se compare à tout (vrai).
Ceci est ce que nous appelons une boucle infinie.
Les lignes de code entre l'bouclés accolades, un peu comme les pièces du puzzle
qui forme l'intérieur de la C du jamais bloquer,
exécutera plusieurs reprises de haut en bas, encore et encore et encore,
pour toujours.
Après tout, si vous vous souvenez de notre discussion des expressions booléennes,
vrai est toujours vrai.
Donc, si nous faisons quelque chose de si longtemps que vrai
est true-- il semble un peu vrai Silly-- est toujours vrai, donc il sera toujours exécuté.
Il va courir pour toujours et toujours et à jamais jusqu'à ce que nous
trouver un moyen de sortir de lui avec une déclaration de rupture, qui encore une fois,
nous avons vu il ya un peu de temps nous parlaient commutateur.
>> Ou autrement juste tuer notre programme, qui, incidemment,
si jamais vous vous trouvez dans une situation une boucle infinie
et vous ne savez pas comment l'arrêter votre programme de fonctionner.
Il suffit de frapper contrôle et C et qui va tuer votre programme pour vous.
Mais cela, encore une fois, est appelé une boucle infinie.
Il est une boucle qui se déroulera toujours.
Maintenant, alors que les boucles ne sont pas toujours infinie, parce aussi
nous pouvons remplacer l'opérateur booléen expression avec quelque chose
un peu plus utile que simplement vrai.
Alors, voici un autre exemple.
Bien que certains booléenne et expression et accolades puis bouclés.
Voilà à peu près analogue répéter jusqu'à ce que, à partir de zéro.
Bien que dans une seconde, je vais expliquer la différence.
>> Donc, dans C, si l'expression booléenne à l'intérieur de la boucle while
true, les lignes de code entre les accolades
exécutera plusieurs reprises encore et encore et encore jusqu'à expression booléenne
false.
Ainsi, par exemple, vous pourriez avoir une sorte de comptoir.
Donc, vous dites au début de cette boucle dire int x est égal à zéro.
Alors que x est inférieur à 100, faire un couple choses à l'intérieur que les accolades,
puis à la fin de votre boucle, vous dites x plus plus, vous êtes incrémenter x.
Finalement x obtiendront à 100 et vous
arrêter parce que la condition x est inférieur à 100
ne sera plus vrai que Dès que x est égal à 100.
100 est égale ou supérieure à 100.
>> Maintenant un peu de prêter à confusion, le comportement du bloc zéro est inversée.
Donc, être très prudent si cela est votre première incursion dans l'utilisation de boucles.
Fondamentalement, la répétition jusqu'à ce bloc dans Scratch
se répéter quelque chose Encore et encore et encore,
jusqu'à ce que l'expression, l'opérateur booléen expression dans l'hexagone est vrai.
Donc, il continuera à le faire jusqu'à ce qu'il est vrai.
Pendant ce temps, la boucle while continuer à le faire jusqu'à ce qu'elle soit fausse.
Ils sont donc tout à fait semblable, mais il n'y a que peu de distinction juste
faire attention d'autant plus que vous faites votre première incursion de la transition
Scratch au c.
Le prochain type de boucle est en fait assez similaire.
On l'appelle la boucle Do While.
Cette boucle va exécuter toutes les lignes de code entre les accolades fois,
puis il va vérifier l'expression booléenne.
Si l'expression booléenne true,
il va revenir en arrière et répéter ce processus encore et encore
et plus jusqu'à ce que le booléenne l'expression est évaluée à false.
Donc, cette boucle, contrairement à une boucle while, est garantie pour exécuter au moins une fois.
Cela peut être très utile.
>> Enfin, nous avons une boucle for.
Pour les boucles sont sorte de syntaxiquement inesthétique
et il ya beaucoup de choses ici, si patient avec moi
comme nous essayons de briser ces pièces à part.
Généralement, le cas d'utilisation d'une boucle for est que vous
vouloir répéter quelque chose d'un certain nombre de fois.
Dans cet exemple ici, Je dois le bloc de répétition
à partir de zéro, ce qui est analogue à la boucle for
en C, répéter quelque chose de 10 fois.
Et la boucle sur la gauche là, qui
est une boucle que quatre ferait la même chose.
Cela irait à 10 fois.
Compter à partir de zéro, nous incrémenter chaque passage de la boucle.
Et nous continuons à faire ce que jusqu'à ce que i est inférieur à 10.
>> Donc ce qui arrive?
Il ya tout un tas de code là.
Brisons le bas pour ce qui se passe l'étape
par étape, comme nous creusons à travers une boucle for.
La première chose qui est arrivé est la variable compteur est le centre.
Tout à la gauche de ce premier virgule à l'intérieur des parenthèses
est exécuté.
Dans ce cas, nous sommes disant int i est égal à 0.
Déclarer une nouvelle variable appelée i, que les variables est un type integer
et nous disons la valeur à l'intérieur cette variable sera nul.
>> La deuxième chose que nous faisons est Nous évaluons ensuite immédiatement
l'expression booléenne.
Expression booléenne est à la milieu des deux points-virgules.
I est inférieur à 10.
Cela est vrai ici, à droite?
Nous avons simplement dit i est égal à zéro, et ainsi de 0 est inférieur à 10,
et ainsi de cette condition est vrai et nous allons maintenant
procéder à exécuter le corps de la boucle.
Si elle était fausse.
Si, par exemple, je l'ai dit au lieu de i est égal à 0, il ai dit que je équivaut à 15,
int i est égal à 15.
Bien 15 est égale ou supérieure 10, de sorte que nous ne serait jamais entrer dans le corps de la boucle
parce que l'expression booléenne il évaluerait être faux.
>> Après nous passons par de haut en bas, nous rencontrons que la fermeture accolade,
une troisième chose qui se passe.
Le compteur variable est incrémenté, ou plutôt, les lignes
code d'une déclaration après la deuxième point-virgule à l'intérieur de la
Pour les boucles entre parenthèses est exécutée.
Nous commençons donc par disant int i est égal à 0.
Ensuite, nous vérifions si oui ou non l'expression booléenne est vraie.
0 est inférieur à 10, il est tellement vrai.
Nous allons donc procéder dans le corps de la boucle.
Les choses vont se produire à l'intérieur de la boucle, et lorsque nous rencontrons que bouclés fermeture
accolade, la prochaine chose que nous faire est nous disons i plus, plus.
Je étais zéro maintenant i est un.
Ensuite, nous vérifions de nouveau la valeur de l'expression booléenne dans le milieu.
L'un est inférieur à 10.
Nous allons donc à travers ce traiter encore et encore.
Nous arriverons à la clôture accolade à nouveau.
Nous allons incrémenter i de 1-2 et 2-3.
Et ainsi de suite et ainsi de suite et ainsi de suite, jusqu'à ce que Finalement, je de valeur devient 10.
Est de 10 à moins de 10?
Non.
Compter de 0, nous sommes passés par 10 itérations de boucle.
Nous avons répété 10 fois, juste comme nous l'avons fait dans le bloc-notes.
Et si ce est essentiellement le processus pour une boucle de quatre.
>> Maintenant, emportant la code réel et de le mettre
en seulement quelques déclarations générales de base.
Voici ce qui arrive.
Toutes les déclarations contenues dans le commencer sont exécutés en premier.
Vous pouvez avoir plus d'un.
Ensuite, l'expression booléenne est vérifiée.
Si l'expression est évaluée à true, exécuter le corps de la boucle une fois.
Si l'expression est évaluée false, nous aurons terminé.
Nous ne pas exécuter la corps de la boucle du tout.
Après nous avons exécuté le corps de la boucle une fois,
nous faisons alors ce qui est en la partie d'incrémentation il.
Qui est habituellement va être quelque chose comme i plus, plus
ou quelque chose comme ça, modifie une variable compteur.
Puis, après on incrémente, nous vérifier à nouveau l'expression
et répéter ces étapes plus et plus et encore jusqu'à l'expression est
plus vrai.
>> Alors, quels sont les cas d'utilisation pour une boucle?
Utilisez vous utilisez une boucle while quand vous voulez une boucle pour répéter
un nombre indéterminé de fois, mais il pourrait peut-être pas exécuter tous.
Un exemple très commun de une boucle tout en étant utilisé
est d'exécuter le flux de contrôle pour un jeu.
Vous pourriez ne pas savoir combien de temps le utilisateur va jouer,
mais vous voulez garder faire la même chose.
Mise à jour des postes de différents sprites sur la carte.
Vous voulez garder les choses se déplaçant à tout moment,
mais vous ne savez pas quand le utilisateur va arrêter de jouer
ou quand ils vont de manquer de vie.
Donc, une boucle while est vraiment bon pour quelque chose comme ça.
Voilà un bon cas d'utilisation.
>> Pour une boucle Do While, il est assez similaire.
Vous voulez une boucle pour répéter un inconnu nombre de fois, mais au moins une fois.
Vous pouvez utiliser cela pour un jeu aussi, mais vraiment un cas d'utilisation commune
est invitant l'utilisateur pour l'entrée.
Généralement, vous pourriez dire quelque chose comme, me donner un nombre entier positif,
et vous pouvez mettre ce que à l'intérieur d'une boucle Do While.
Ainsi, il sera toujours leur demander au moins une fois pour un nombre entier positif.
Si on vous donne un entier positif, vous pourriez sortir de la boucle.
Vous pourriez être terminé.
L'expression booléenne en le tout faire pourrait être fausse.
>> Et vous ne serez pas leur demander à nouveau.
Si on vous donne un nombre négatif où ils tapent un mot ou quelque chose qui est
pas vraiment utile de vous, vous pourriez utiliser la
Do While boucle pour revenir en arrière et faire encore et encore et encore.
Vous voulez certainement à poser à vous donner un certain nombre une fois,
mais vous ne savez pas combien de fois Après cela, ils pourraient être nuisibles.
Et donc un do alors qu'il est un grand usage cas pour inviter l'utilisateur à l'entrée.
Et un pour les boucles utiliser cas est généralement lorsque
vous voulez répéter une boucle un nombre discret de temps,
si vous ne pourriez pas connaître le nombre de fois
au moment où le programme est compilé.
>> Ainsi, par exemple, peut-être vous avez un programme où vous inviter l'utilisateur à un certain nombre.
Et ils entrent 100.
Et puis votre boucle for dans ce cas exécuter 100 fois.
Ou peut-être ils entrent 1000 dans votre programme
puis exécutez la boucle 1000 fois.
Il est un certain nombre de fois.
Ils ne sont pas nécessairement savoir ce que ce nombre
est le moment le programme est compilé.
Il est pas comme une boucle while où il pourrait être infinie.
Il est plutôt un certain nombre que vous ne savez pas.
Maintenant, même si je l'ai énoncées tous ces cas d'utilisation,
vous devriez savoir que dans le joli beaucoup chaque circonstance,
vous pouvez échanger tous trois de ces boucles.
Vous pouvez utiliser une boucle où vous autrement utiliser une boucle while.
Vous pouvez utiliser une boucle où vous devriez utiliser une boucle Do While et ainsi de suite.
Il peut être un peu difficile parfois, si généralement il est une bonne pratique
à adhérer à un cas d'utilisation typique.
Utilisez une boucle Do While si vous voulu quelque chose une fois, au moins.
Utilisez une boucle for si vous voulez faire quelque chose d'un nombre spécifique de fois.
Après tout, qui est pourquoi il ya trois différents types de boucles.
>> Ainsi, ils peuvent être utilisés dans le bon contexte.
Mais vous pouvez interchanger eux si vous voulez.
Si vous vous sentez à l'aise avec les boucles while et vous voulez toujours utiliser des boucles while.
Il est quelque chose que vous pouvez le faire, mais il
pourrait être un peu syntaxiquement délicat, où une boucle pour
serait beaucoup plus simple.
>> Mon nom est Doug Lloyd et cela est CS50.