[Powered by Google Translate] TOMMY MacWilliam: Parlem de bucles, un dels comuns
construccions de programació que veurem al llarg CS50.
Utilitzarem els bucles quan es vol fer una
tasca més d'una vegada.
Per exemple, podríem voler imprimir "Hola" 100 vegades o impressió
totes les lletres de l'alfabet.
En ambdós casos, tenim una cosa que volem fer
diverses vegades, imprimir alguna cosa.
No obstant això, el que imprimeix cada vegada que pot variar.
Així que podem fer alguna cosa una mica diferent en cada
iteració, o executar a través, del bucle.
Anem a veure tres tipus de bucles en C, mentre que
bucles, els bucles for, while i fer.
Tot i que aquests tres tipus de bucles té una sintaxi diferent,
les idees darrere d'ells són els mateixos.
Definirem algun bloc de codi entre claus,
anomenat el cos del bucle, que volem ser executat
cert nombre de vegades.
En canviar els valors de les variables usades en el cos, es
pot fer que el nostre llaç de fer alguna cosa diferent cada vegada que s'executi.
Amb un bucle que escrivim, també haurà de decidir quan és el
bucle s'aturarà.
Si no fem això, llavors el nostre equip seguirà fidel
per executar aquest bucle fins que matem al programa.
En Scratch, podríem utilitzar la repetició de n vegades
bloquejar per crear un bucle.
Totes les peces dins d'un bloc que va dir repetició 10
s'executi 10 vegades.
I després, ens agradaria passar a les peces després d'aquest bucle.
Així que la nostra condició de detenció va ser simplement, aquest bloc ha estat
executar 10 vegades.
Així que anem a recrear això en C. Per tal de garantir a les ratllades
que les peces dins del bloc de repetició s'executen
exactament 10 vegades, Scratch necessita per realitzar un seguiment de cada
execució del bloc de repetició.
Per portar el compte de les vegades que el nostre cos del bucle estat
executat, crearem una variable anomenada i.
Anem a començar ia zero, ja que el nostre bucle
no ha estat executat encara.
Acceptar
Ara utilitzarem la paraula clau, mentre que per a començar el nostre bucle.
Ara haurem d'esbrinar quan el nostre bucle s'aturarà, però
deixem això per ara i després tornar-hi.
Està bé.
Dins del nostre circuit, anem a imprimir un missatge, com
"Hi". Podem utilitzar la funció printf per això.
Està bé.
Així que ara anem a registrar que una iteració del cos del cicle ha
estat executat.
Podem fer-ho mitjançant l'addició d'1 a, o incrementar, el nostre comptador
variable, i.
Per això, podem dir que és igual a i + 1, o més
simplement, i plus plus.
Gran.
Així que ara podem veure que cada vegada que el nostre bucle s'executa, el nostre
variable comptador s'incrementa en un.
Així que sabem exactament quantes iteracions ens hem quedat fins ara.
Després d'una iteració del bucle, el nostre valor
de i serà 1.
Després de dues iteracions, seré 2.
I després de 10 iteracions, seré 10.
Així que, si volem executar aquest bucle exactament 10 vegades, i després
això és quan volem aturar.
Així que volem executar aquest bucle while i és menor que 10, i
això és exactament el que anem a escriure, mentre que i
és inferior a 10.
Aquesta condició s'assembla a les condicions que hem utilitzat en cas d'
blocs cosa.
Després que el cos del nostre bucle ha estat executat, el programa de
torni a saltar a la condició de bucles.
Si la condició és veritable, llavors el cos de la
bucle s'executa de nou.
Si la condició ja no és així, llavors el nostre llaç no serà
córrer més i passarà a la següent línia de codi
sota del nostre bucle.
Està bé.
Així que donem una ullada a un segon tipus de
bucle, el bucle for.
Al costat de la paraula clau, mentre que, entre parèntesi, teníem una cosa,
la condició que sigui necessari per ser veritat per a la
cos del bucle s'executarà.
Això vol dir que vam haver crear la nostra variable de comptador extern
del bucle i s'acorda d'incrementar en algun moment
a l'interior del bucle.
La capçalera del nostre bucle for, d'altra banda, té tres
parts, cadascuna de les quals es separen amb un punt i coma.
En el nostre primer terç, podem declarar qualsevol comptador o auxiliar
variables per utilitzar el nostre bucle.
A la pràctica, això pot ser molt útil.
Realment no necessito aquesta variable, i, després del nostre temps
bucle s'executa, així que realment no hauria de tenir de declarar
fora del bucle.
El segon terç serà la condició que s'ha de complir
perquè el cos s'executa de nou, igual
en el nostre bucle while.
En el nostre últim terç, es pot executar una instrucció que serà
executat després de cada iteració del bucle, de manera que no tenen
per construir en el cos del bucle.
Així que anem a escriure un bucle for que un compte enrere de 5 a 1.
Anem a començar amb la paraula clau per.
Podem crear una variable de comptador en primer lloc, que anem a
s'estableix en 5 aquesta vegada ja que estem comptant,
seguit d'un punt i coma.
El següent és la nostra condició, que tornarem.
En tercer lloc, ens agradaria disminuir la nostra variable comptador després
cada iteració del bucle.
Així que en lloc de dir i plus plus, direm que em minus minus.
Està bé.
Així que volem que el cos del bucle s'executi mentre jo encara
major que 0.
En el cos del bucle, anem a imprimir el valor de i.
Per això, utilitzarem la funció printf, amb el% d
marcador de posició.
Recordeu que la variable que serà reemplaçada per la
valor de i.
Finalment, anem a afegir una declaració després del nostre bucle for.
Quan s'executa aquest bucle, vaig a començar als 5,
així que 5 s'imprimirà.
Quan arriba a 0, la condició de continuïtat, i és
més gran que 0, ja no tindrà.
Així que el nostre bucle s'aturarà l'execució, i anem a veure el
declaració després del bucle.
Així que anem a executar aquest codi.
En primer lloc, anem a elaborar un
countdown.c amb fer de compte enrere.
Ara, podem executar aquest codi amb. / Compte enrere.
En ambdós bucles while i for loops, la nostra continuació
se li ha d'examinar abans que el cos
del bucle s'executa.
Això vol dir que, si la nostra condició no és inicialment
cert, llavors el cos del nostre bucle mai s'executarà.
Així que de vegades és útil per verificar l'estat després de la
cos del bucle en lloc d'abans d'ell.
Així que anem a escriure un bucle per sol · licitar a l'usuari un nombre
fins que un nombre positiu es subministra.
Si l'usuari introdueix un nombre negatiu, anem a demanar-los
per un altre número.
Així que anem a voler aquest missatge per estar dins de la
cos fora del bucle.
No obstant això, quan el bucle s'executa per primera vegada, l'usuari
no ens ha donat el nombre encara.
Així que no té sentit per comprovar si és positiu.
En el seu lloc, anem a voler comprovar el nombre que segueix al cos de
el bucle s'executa.
Podem fer això amb un bucle Do While.
En primer lloc, crearem una variable, n, que contindrà
l'usuari d'entrada.
Ara utilitzarem la paraula clau do, seguit de claus que
començarà el cos del nostre bucle.
En el cos, es pot sol · licitar a l'usuari un número amb el
GetInt funció.
Ara, anem a voler el cos d'aquest bucle s'execute altra vegada si
l'usuari va escriure un nombre negatiu, de manera que anem a dir mentre que n
és menor que 0.
Observeu el punt i coma aquí després de la sentència while.
Així que anem a executar aquest codi.
En primer lloc, farem amb això compilar positiu.
Ara podem executar el programa amb. / Positiu.
Si donem a aquest programa un nombre negatiu, com negatiu
4, llavors ens demanarà de nou per un nombre des de la
condició de la nostra do while era cert.
Quan li donem un nombre positiu, igual que 8, llavors el
condició de la nostra do while ja no és cert.
Així que el bucle no s'executa de nou.
I això és tot pels tres tipus de bucles que usarem en C.
El meu nom és Tommy, i això és CS50.