Cicluri. Operatori de buclă pentru, while, do…while

Etichete: cicluri C. C bucle. Bucla cu postcondiție. Buclă cu precondiție. Mergi cu un scribător. in timp ce. face în timp ce. pentru. pauză. continua

Introducere. Bucle cu precondiție.

La rezolvarea problemelor practice, apare constant nevoia de a repeta o acțiune de un număr dat de ori, sau până la atingerea unei anumite condiții. De exemplu, afișați o listă cu toți utilizatorii, plasați planul cu o textură, efectuați calcule pe fiecare element al matricei de date etc. În C, trei tipuri de bucle sunt utilizate în aceste scopuri: cu condiție prealabilă, postcondițieși ciclul pentru cu un contor (deși acesta este un nume condiționat, deoarece este posibil să nu existe un contor).

Orice buclă constă dintr-un corp și verificarea condiției în care această buclă ar trebui să se încheie. Corpul buclei este setul de instrucțiuni care trebuie repetate. Fiecare repetare a buclei se numește iterație.

Luați în considerare o buclă cu o precondiție.

Int i = 0; in timp ce eu< 10) { printf("%d\n", i); i++; }

Această buclă rulează atâta timp cât condiția specificată după este adevărată cuvânt cheie in timp ce. Corpul buclei este de două linii, una imprimă un număr, a doua îl schimbă. Evident, această buclă va fi executată de 10 ori și va fi afișată
0
1
2
3
si tot asa pana la 9.

Este foarte important ca condiția de ieșire din buclă să fie îndeplinită la un moment dat, altfel va apărea o buclă și programul nu se va finaliza. De exemplu

Int i = 0; in timp ce eu< 10) { printf("%d\n", i); }

Această buclă nu modifică variabila i, care este utilizată pentru a determina starea de oprire, astfel încât bucla nu se va termina.

Int i = 0; în timp ce (i > 0) ( printf("%d\n", i); i++; )

În acest program, bucla se va termina, desigur, dar din cauza unei acțiuni incorecte, va fi executată de mai mult de 10 ori. Deoarece C nu monitorizează depășirea variabilă, va trebui să așteptați până când variabila depășește și devine mai mică decât zero.

Int i; in timp ce eu< 10) { printf("%d\n", i); i++; }

Acest exemplu are un comportament nedefinit. Deoarece variabila i nu este inițializată în avans, aceasta stochează gunoi, o valoare necunoscută în avans. Cu conținuturi diferite ale variabilei i, comportamentul se va schimba.

Dacă corpul buclei while conține o declarație, atunci acoladele pot fi omise.

Int i = 0; in timp ce eu< 10) printf("%d\n", i++);

Aici incrementăm variabila i când apelăm funcția printf. Acest stil de codare ar trebui evitat. Absența bretelelor, mai ales la începutul antrenamentului, poate duce la erori. În plus, codul este mai puțin lizibil, iar parantezele suplimentare nu umfla prea mult listele.

Bucle cu postcondiții.

O buclă postcondiție diferă de o buclă while prin aceea că condiția este verificată după ce bucla s-a terminat, ceea ce înseamnă că bucla va fi repetată cel puțin o dată (spre deosebire de o buclă while, care poate să nu fie executată deloc). Sintaxa buclei

Do (corp buclă) while(condiție);

Exemplul anterior folosind o buclă do ar arăta ca

Int i = 0; face ( printf("%d\n", i); i++; ) while(i< 10);

Să ne uităm la un exemplu de utilizare a unei bucle cu o postcondiție și o precondiție. Să presupunem că trebuie să integrăm o funcție.

Orez. 1 Integrarea numerică a unei funcții∫ a b f x d x

O integrală este o sumă de infinitezimale. Putem reprezenta integrala ca o sumă și pur și simplu înlocuim valorile infinitezimale cu valori mici.

∫ a b f x d x = ∑ i = a b f i h

Formula arată că de fapt am împărțit aria de sub grafic în mai multe dreptunghiuri, unde înălțimea dreptunghiului este valoarea funcției în punct, iar lățimea este pasul nostru. Prin adunarea ariilor tuturor dreptunghiurilor, obținem astfel valoarea integralei cu o anumită eroare.

dreptunghiuri stânga" src="/images/c_loop_rectangles_left.png" alt="Integrarea numerică a unei funcții prin metoda
dreptunghiuri din stânga"> Рис. 2 Численное интегрирование функции методом!}
dreptunghiuri din stânga

Fie funcția necesară x 2 . Vom avea nevoie de următoarele variabile. Mai întâi, un acumulator de sumă pentru a stoca integrala. În al doilea rând, granițele din stânga și din dreapta ale lui a și b, în al treilea rând, pasul h. Avem nevoie și de valoarea curentă a argumentului funcției x.

Pentru a găsi integrala este necesar să mergem de la A inainte de b cu niște pași hși adăugați la sumă aria dreptunghiului cu laturile f(x)Și h.

#include #include int main() ( suma dubla = 0,0; dublu a = 0,0; dublu b = 1,0; dublu h = 0,01; dublu x = a; while (x< b) { sum += x*x * h; x += h; } printf("%.3f", sum); getch(); }

Programul iese 0.328.

∫ 0 1 x 2 d x = x 3 3 | 0 1 = 1 3 ≈ 0,333

Dacă te uiți la grafic, poți vedea că de fiecare dată găsim valoarea funcției în punctul din stânga. Prin urmare, această metodă de integrare numerică se numește metoda dreptunghiului din stânga. În mod similar, puteți lua valoarea corectă. Atunci va fi metoda dreptunghiurilor drepte.

În timp ce (x< b) { x += h; sum += x*x * h; } dreptunghiuri drepte" src="/images/c_loop_rectangles_right.png" alt="Integrarea numerică a unei funcții prin metoda
dreptunghiuri dreptunghiuri"> Рис. 3 Численное интегрирование функции методом!}
dreptunghiuri dreptunghiuri

Suma în acest caz va fi egală cu 0,338. Metoda dreptunghiului din stânga și din dreapta nu este foarte precisă. De fapt, am aproximat graficul neted al unei funcții care crește monoton cu o histogramă. Dacă vă gândiți puțin, atunci aproximarea poate fi efectuată nu numai prin însumarea dreptunghiurilor, ci și prin însumarea trapezelor.

trapezium" src="/images/c_loop_integral_trapezium.png" alt="Integrarea numerică a unei funcții prin metoda
trapez"> Рис. 4 Численное интегрирование функции методом!}
trapez

Aproximația trapezoidală este de fapt o aproximare pe bucăți prin curbe de ordinul întâi (ax+b). Conectăm puncte pe un grafic folosind segmente de linie. Puteți face totul mai complicat conectând punctele nu cu segmente, ci cu bucăți de parabolă, atunci aceasta va fi metoda lui Simpson. Dacă complicăm lucrurile și mai mult, vom ajunge la interpolarea spline, dar aceasta este o altă conversație, foarte lungă.

Să ne întoarcem la oile noastre. Să luăm în considerare 4 cicluri.

Int i = 0; în timp ce(i++< 3) { printf("%d ", i); } int i = 0; while (++i < 3) { printf("%d ", i); } int i = 0; do { printf("%d ", i); } while(i++ < 3); int i = 0; do { printf("%d ", i); } while(++i < 3);

Dacă rulați aceste exemple, veți vedea că buclele sunt executate de la doi la de patru ori. Acest lucru merită să acordați atenție deoarece schimbarea incorect a contorului de bucle duce adesea la erori.

Se întâmplă adesea să fim nevoiți să ieșim din buclă fără a aștepta ca un steag să fie ridicat sau valoarea unei variabile să se schimbe. În aceste scopuri este utilizat operatorul pauză ceea ce face ca programul să iasă din bucla curentă.

Să decidem sarcină simplă. Utilizatorul introduce numere până când este introdus numărul 0, după care este afișat cel mai mare introdus. Există o captură. Nu se știe câte numere va introduce utilizatorul. Prin urmare, vom crea o buclă infinită și vom ieși din ea folosind operatorul pauză. În interiorul buclei vom primi date de la utilizator și vom selecta numărul maxim.

#include #include int main() ( int num = 0; int max = num; printf("Pentru a ieși, introduceți 0\n"); /*buclă fără sfârșit*/ while (1) ( printf("Vă rugăm, introduceți numărul: "); scanf("%d", &num); /*condiție pentru ieșirea din buclă*/ if (num == 0) ( break; ) if (num > max) ( max = num; ) ) printf ("numărul maxim a fost % d ", max); getch(); )

Permiteți-mi să vă reamintesc că nu există un tip boolean special în C. În schimb, sunt folosite numere. Zero este fals, toate celelalte valori sunt adevărate. Bucla while(1) va rula pentru totdeauna. Singurul punct de ieșire din el este starea

Dacă (număr == 0)

În acest caz, ieșim din buclă cu pauză; Pentru început, setăm ca maxim 0. Utilizatorul introduce un număr, după care verificăm dacă este zero sau nu. Dacă nu este zero, atunci îl comparăm cu maximul actual.

Buclele infinite sunt folosite destul de des, deoarece datele de intrare nu sunt întotdeauna cunoscute în avans sau se pot schimba în timp ce programul rulează.

Când trebuie să sărim corpul buclei, dar continuăm să executăm bucla, folosim operatorul continua. Un exemplu simplu: utilizatorul introduce zece numere. Aflați suma tuturor numerelor pozitive pe care le-a introdus.

#include #include int main() ( int i = 0; int positiveCnt = 0; float sum = 0.0f; float input; printf("Introduceți 10 numere\n"); while (i< 10) { i++; printf("%2d: ", i); scanf("%f", &input); if (input <= 0.0) { continue; } sum += input; positiveCnt++; } printf("Sum of %d positive numbers = %f", positiveCnt, sum); getch(); }

Exemplul pare oarecum exagerat, deși în general reflectă semnificația operatorului continua. În acest exemplu, variabila pozitivCnt este un numărător de numere pozitive, sumă suma, și intrare- variabila temporara pentru introducerea numerelor.

Iată un alt exemplu. Este necesar ca utilizatorul să introducă un număr întreg mai mare decât zero și mai mic de 100. Până la introducerea numărului necesar, programul va continua să interogheze.

Do (printf("Vă rugăm, introduceți numărul: "); scanf("%d", &n); dacă (n< 0 || n>100) ( printf("număr greșit, încercați din nou\n"); continua; ) else ( break; ) ) while (1);

pentru buclă

Una dintre cele mai frecvent utilizate este bucla de contor. pentru. Sintaxa sa

Pentru (<инициализация>; <условие продолжения>; <изменение счётчика>){ <тело цикла> }

De exemplu, să tipărim pătratele primei sute de numere.

Int i; pentru (i = 1; i< 101; i++) { printf("%d ", i*i); }

Unul dintre lucrurile grozave despre bucla for este că poate funcționa cu mai mult decât numere întregi.

Float num; pentru (num = 5,3f; num > 0f; num -= 0,2) ( printf("%.2f ", num); )

Această buclă va imprima numere de la 5,3 la 0,1. În bucla for poate lipsi unele „blocuri” de cod, cum ar fi lipsa inițializării, testarea (apoi bucla devine infinită) sau schimbarea contorului. Iată un exemplu cu o integrală implementată folosind un contor pentru

#include #include int main() ( suma dubla = 0,0; dublu a = 0,0; dublu b = 1,0; dublu h = 0,01; dublu x; for (x = a; x< b; x += h) { sum += x*x * h; } printf("%.3f", sum); getch(); }

Să ne uităm la o bucată de cod

x dublu ; pentru (x = a; x< b; x += h) { sum += x*x * h; }

Se poate schimba astfel

Dublu x = a; pentru(;x< b; x+=h) { sum += x*x*h; }

Mai mult, folosind operatorul pauză, puteți elimina condiția și puteți scrie

x dublu; pentru (x = a;; x += h)( dacă (x>b)( rupere; ) suma += x*x*h; )

Dublu x = a; pentru (;;)( dacă (x > b)( pauză; ) suma += x*x*h; x += h; )

În plus, folosind operatorul ",", puteți muta unele dintre acțiuni

x dublu ; pentru (x = a; x< b; x += h, sum += x*x*h) ;

NOTĂ: Deși este posibil să faceți acest lucru, vă rugăm să nu faceți acest lucru! Acest lucru afectează lizibilitatea codului și duce la erori subtile.

Să decidem ceva problema practica mai complicat. Să avem o funcție f(x). Să găsim maximul derivatei sale pe segment. Cum se găsește numeric derivata unei funcții? Evident, prin definiție). Derivata unei functii intr-un punct este tangenta unghiului tangentei.

F x ′ = d x d y

Să luăm un punct de pe curba cu coordonatele (x; f(x)), deplasăm cu un pas h înainte, obținem punctul (x+h, f(x+h)), atunci derivata va fi

D x d y = f (x + h) - f x (x + h - x) = tan α

Adică, raportul dintre o creștere mică a unei funcții și o creștere mică a unui argument. Un cititor atent se poate întreba de ce mergem înainte într-o funcție și nu înapoi. Ei bine, să ne întoarcem

D x d y = f x - f (x - h) h = tan β

Luând media acestor două valori, obținem

F (x + h) - f (x - h) 2h

În general, acum sarcina devine banală: mergem de la punct A până la punctul bși găsim valoarea minima derivată, precum și punctul în care derivatul capătă această valoare. Pentru a rezolva, vom avea nevoie, ca și în problema cu integrala, de variabile pentru limitele zonei de căutare AȘi b, valoarea actuala X si pas h. În plus, este necesară valoarea maximă maxVal si coordoneaza maxX această valoare maximă. Pentru a funcționa, luați funcția x sin x

#include #include #include int main() ( double a = 0; double b = 3,0; double h = 0,001; double h2 = h * 2,0; double maxVal = a*sin(a); double maxX = a; double curVal; double x; // Parcurgem întreaga regiune de la a la b // și căutăm maximul primei derivate // Folosiți funcția x*sin(x) pentru (x = a; x< b; x += h) { curVal = ((x+h)*sin(x+h)-(x-h)*sin(x-h))/h2; if (curVal >maxVal) ( maxVal = curVal; maxX = x; ) ) printf("valoare max = %.3f la %.3f", maxVal, maxX); getch(); )

La ieșire, programul produce valoarea maximă = 1,391 la 1,077

Soluția numerică dă aceleași rezultate (în cadrul erorii) ca și programul nostru.

Bucle imbricate

Să ne uităm la un exemplu în care buclele sunt imbricate una în alta. Să afișăm tabla înmulțirii.

#include #include #include int main() ( int i, j; // Pentru fiecare i pentru (i = 1; i< 11; i++) { // Выводим строку из произведения i на j for (j = 1; j < 11; j++) { printf("%4d", i*j); } // После чего переходим на linie nouă printf("\n"); ) getch(); )

În acest exemplu, în prima buclă prin variabilă i a doua buclă imbricată peste variabilă j. Secvența acțiunilor este următoarea: mai întâi intrăm în ciclu prin i, dupa aceea pentru curent i Numerele sunt afișate de 10 ori la rând. După aceasta, trebuie să mergeți la o nouă linie. Acum să scoatem numai elementele de sub diagonala principală

Pentru (i = 1; i< 11; i++) { for (j = 1; j < 11; j++) { if (j >i) ( break; ) printf("%4d", i*j); ) printf("\n"); )

După cum puteți vedea, operatorul pauză vă permite să părăsiți numai bucla curentă. Acest exemplu ar putea fi rescris după cum urmează

Pentru (i = 1; i< 11; i++) { for (j = 1; j <= i; j++) { printf("%4d", i*j); } printf("\n"); }

În acest caz, folosim primul numărător de bucle din bucla imbricată.

Ru-Cyrl 18-tutorial Sypachev S.S. 14-04-1989 [email protected] Stepan Sypachev elevi

Încă nu este clar? – scrieți întrebări în căsuța poștală

Buclele sunt folosite pentru a repeta bucăți de cod din nou și din nou. Capacitatea de a repeta anumite fragmente de cod este una dintre sarcinile principale și în același timp importante pe care trebuie să le rezolve un programator. Majoritatea programelor sau site-urilor web folosesc bucle, de exemplu, pentru a afișa informații de știri sau anunțuri. Adică, în astfel de sarcini este necesar să se efectueze în mod constant operațiuni de citire și scriere și, pentru a nu duplica același cod, buclele vin în ajutor. Buclele sunt destul de simplu de declarat în cod, dar realizează sarcini complexe doar cu o simplă repetare.

Pentru a începe să învățați despre bucle, asigurați-vă că aveți o bună înțelegere a conceptului în limbajul de programare C. Pentru că acest lucru va fi vital în utilizarea ciclurilor, pentru că în cicluri, la fel ca în cicluri, există expresii condiționate. Există trei tipuri de bucle în limbajul C: for, while, do while. Fiecare dintre ele are propriile aplicații specifice. Toate sunt descrise mai jos.

Cea mai des folosită buclă este bucla for, structura sa este prezentată mai jos:

Pentru (/*inițializarea unei variabile; condiție; modificarea valorii unei variabile*/) ( // corpul buclei (aici este codul care va fi repetat) )

Inițializarea variabilei vă permite fie să declarați o variabilă și să îi atribuiți o valoare, fie să atribuiți o valoare unei variabile existente. În al doilea rând, valoarea acestei variabile spune programului dacă condiția buclei este adevărată sau falsă. Și atâta timp cât condiția buclei este adevărată, bucla ar trebui să continue să se repete. Variabila de control trebuie modificată cumva, altfel bucla va fi nesfârșită, de exemplu, o puteți actualiza astfel: i++ , i = i + 2 sau chiar i = random(5) . Vă rugăm să rețineți că fiecare secțiune din antetul buclei este separată de un punct și virgulă, ceea ce este foarte important. De asemenea, rețineți că fiecare dintre secțiuni poate fi goală, deși punctul și virgulă ar trebui să fie în continuare acolo. Dacă condiția nu este goală, atunci se evaluează la adevărat și bucla va fi executată până când ceva face condiția de buclă falsă. Să ne uităm la un exemplu simplu de utilizare a unei bucle for.

#include int main() ( int i; /* Bucla va rula până la i< 10, при этом после каждой итерации переменная i будет инкрементироваться(увеличиваться на 1)*/ for (i = 0; i < 10; i++) { /* Имейте ввиду что условие проверяется перед каждым повторением, то есть работа цикла остановится когда переменная i будет равна 10*/ printf("%d\n", i); } getchar(); }

De fapt, rezultatul programului:

0 1 2 3 4 5 6 7 8 9

Acest program este un exemplu foarte simplu de utilizare a unei bucle. variabilei i i se atribuie zero, iar în timp ce i este mai mică de 10, valoarea variabilei i este imprimată pe ecran, după care se adaugă una variabilei i și totul se repetă din nou până când condiția devine falsă. Rețineți că valoarea variabilei i este incrementată după ce codul din corpul buclei rulează pentru prima dată.

Bucla while este o buclă foarte simplă, iată structura sa:

While (/*condiție*/) ( // corpul buclei - aici este codul care trebuie repetat)

Corpul buclei începe să se execute dacă condiția buclei este adevărată. Condiția este o expresie booleană, cum ar fi x == 1 sau x! = 7 (x nu este egal cu 7). Adică, condiția poate fi absolut orice - orice combinație de expresii logice. Iată un exemplu de condiție compusă - x == 3 || x > 10 , această condiție va fi adevărată dacă x este egal cu trei sau x este mai mare decât 10. Rețineți că while are o secțiune de inițializare sau o secțiune de modificare a variabilei controlate, deci înainte de a utiliza această buclă, trebuie mai întâi să declarați variabila care va fi testat în bucla de condiție și în corpul buclei modificați valoarea acestei variabile. De fapt, să ne uităm la un exemplu simplu folosind o buclă while:

#include int main() ( int var = 0; /* asigurați-vă că declarați prima variabilă */ while (var< 10) { /* пока значение переменной var меньше 10 */ printf("%d\n", var); var++; /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет - бесконечным) */ } getchar(); }

Așa că ne-am uitat la un alt exemplu de utilizare a buclelor și, după cum puteți vedea, nu este nimic complicat în acest exemplu. Doar imaginați-vă că bucla începe întotdeauna să repete codul care se află în corpul buclei. De îndată ce ultima instrucțiune din corpul buclei este executată, condiția buclei este verificată. Dacă condiția este încă adevărată, atunci bucla continuă să funcționeze, iar dacă condiția este falsă, atunci bucla este ieșită.

Există un alt tip de buclă - do while. Această buclă este utilă atunci când trebuie să executați codul de cel puțin - 1 dată. Să ne uităm la structura sa:

Do ( // corpul buclei ) while (/*condiție*/);

Structura este foarte simplă, după cum puteți vedea, condiția este la sfârșitul buclei și, în consecință, condiția va fi verificată după ce codul din corpul buclei este executat. Rețineți că condiția este testată la sfârșitul buclei, nu la început, astfel încât blocul de cod din corpul buclei va fi executat cel puțin o dată. Dacă condiția este adevărată, bucla sare înapoi la început și o execută din nou. O buclă do while este aproape la fel cu o buclă while, cu excepția faptului că corpul buclei este garantat a fi executat cel puțin o dată. Bucla while verifică mai întâi condiția și apoi execută blocul de cod din corp, dacă condiția este adevărată, desigur, în timp ce bucla do while execută mai întâi codul din corpul buclei și apoi verifică condiția și dacă este adevărat, apoi continuă să ruleze. Un exemplu de buclă do while este prezentat mai jos:

#include int main() ( int i = 0; do ( /* Imprimă un mesaj și iese */ printf("Bună! Fac o buclă while\n"); ) while (i != 0); getchar() ;)

Observați punctul și virgulă de la sfârșitul buclei, ar trebui să plasați întotdeauna punctul și virgulă ca în exemplul de mai sus. Foarte des, acest punct și virgulă nu este inclus, rezultând o eroare de compilare. Numai acest ciclu se termină cu punct și virgulă; restul ciclurilor nu au nimic la sfârșit, cu excepția parantezei de închidere. Rețineți că în exemplul de mai sus, această buclă va fi executată o dată deoarece mesajul este imprimat mai întâi și apoi este verificată starea buclei.

Pentru a începe să utilizați bucle, trebuie să știți ce sunt, ce pot face și de ce sunt necesare în scripturi. O buclă este un bloc de cod care vă permite să repetați anumite acțiuni (instrucțiuni) de un anumit număr de ori. Fiecare execuție individuală (una sau mai multe repetări) a unei secvențe de instrucțiuni într-o buclă se numește iterație.

Fiecare ciclu este format din două părți principale. Primul determină când execuția buclei trebuie oprită. Al doilea este fragmentul propriu-zis de cod de program care efectuează acțiunile necesare, care poate consta dintr-o singură instrucțiune sau mai multe instrucțiuni cuprinse între acolade.

Cod program Bucla se execută până când expresia condițională a buclei returnează TRUE. Pentru a evita o buclă infinită care se va învârti pentru totdeauna, codul din corpul buclei trebuie să facă ca expresia condiționată să returneze FALSE la un moment dat. Când se întâmplă acest lucru, bucla se va opri din rulare și execuția va continua din linia de cod imediat după buclă.

buclă while

Bucla while este cel mai simplu tip de buclă din PHP. Sintaxa sa este:

Mai jos este un exemplu de buclă while al cărei corp este executat de 10 ori:

\n"; $num++; ) ?>

Înainte de a începe bucla, valoarea variabilei $num este setată la 1 (valoarea poate fi oricare). Aceasta se numește inițializarea unei variabile contor. De fiecare dată când corpul buclei este executat, valoarea variabilei $num este mărită cu unu folosind incrementul $num++. Valoarea expresiei ($num<= 10) проверяется каждый раз перед итерацией цикла. После десяти итераций условное выражение вернет значение FALSE (так как значение переменной $num уже будет не меньше или равно 10) и работа цикла прекратится. В том случае, если условное выражение while будет равно FALSE с самого начала, тело цикла ни разу не будут выполнено.

Cele mai multe bucle au variabile de contor similare cu $num . Cel mai adesea, variabilele numite i, j și k acționează ca contoare de buclă, deși pentru a face codul programului mai ușor de înțeles, ar trebui să dați contoarelor nume mai descriptive.

face bucla while

O buclă do while este foarte asemănătoare cu o buclă while, cu excepția faptului că expresia condiționată este testată la sfârșitul iterației mai degrabă decât la început. Sintaxa pentru această buclă este:

Există două diferențe între o buclă do while și o buclă while obișnuită. În primul rând, o buclă do while necesită atât cuvântul cheie do (pentru a marca începutul buclei), cât și cuvântul cheie while (pentru a marca sfârșitul buclei și pentru a specifica o condiție). În al doilea rând, spre deosebire de o buclă while, o buclă do while se termină cu punct și virgulă. Acest tip de buclă este util atunci când corpul buclei trebuie executat cel puțin o dată, indiferent de valoarea expresiei condiționate.

Să încercăm să efectuăm aceleași acțiuni ca în exemplul anterior:

\n"; $num++; ) în timp ce ($num<= 10); ?>

Adesea, la programarea sarcinilor, este necesar ca aceeași secvență de comenzi să fie executată de mai multe ori. Acest proces se numește ciclic. Un algoritm în care secvență specifică comenzile repetate de mai multe ori cu date de intrare noi se numesc ciclice.

Pentru a implementa un proces ciclic, limbajele de programare folosesc bucle. Limbajul de programare C/C++ are operatori de buclă ușor de utilizat.

2. Tipuri de operatori de buclă în C++

Există 3 tipuri de operatori de buclă în C++:

pentru buclă;
buclă while cu condiție prealabilă;
do...while bucla cu postcondition.

Fiecare dintre operatorii de buclă are propriile caracteristici de aplicație. Oricare dintre instrucțiunile buclei de mai sus poate fi înlocuită cu alta.

3. Pentru buclă. Forma generală a instrucțiunii buclei for

În C++, bucla for poate avea o implementare și o aplicație foarte largă. O buclă for se mai numește și buclă cu un parametru.

Forma generală a instrucțiunii buclei for este:

pentru ( initializare ; expresie ; creştere ) { // ... }

initializare – o operație de atribuire care stabilește valoarea initiala variabilă buclă. Această variabilă este un numărător care controlează funcționarea buclei. Numărul de variabile care controlează pentru buclă, poate două sau mai multe;
expresie– o expresie condiționată care verifică valoarea unei variabile de buclă. În această etapă, se determină execuția ulterioară a ciclului;
creştere– determină modul în care valoarea variabilei buclei se va schimba după fiecare iterație.

Bucla for rulează până la valoarea expresie este egal cu adevărat. De îndată ce valoarea expresiei devine falsă, bucla oprește execuția și instrucțiunea care urmează buclei for este executată.

4. Exemple de utilizare a operatorului de buclă for

Exemplul 1. Aflați suma tuturor numerelor întregi de la 100 la 300.

// suma numerelor de la 100 la 300 int suma; int i; suma = 0; pentru (i = 100; i<=300; i++) sum = sum + i; // sum = 40200

Exemplul 2. Dat un număr natural n. Calculați suma:

Un fragment de cod care rezolvă această problemă.

// s = 1 + 1/2 + 1/3 + ... + 1/n int n; float s = 0; int i; // introduceți valoarea n n = 4; pentru (i = 1; i<=n; i++) s = s + 1.0/i; // s = 2.08333

În acest exemplu, pentru a obține o valoare reală, în loc de numărul 1 (tip întreg), se introduce numărul 1.0 (tip real). Operarea diviziei

dă un rezultat real.

Exemplul 3. Calculați Suma

Un fragment de cod care rezolvă această problemă.

plutitor s; int i; s = 0; pentru (i=50; i>=1; i--) s = i + Math::Sqrt(s); s = Math::Sqrt(s); // s = 1,7579

În acest exemplu, valoarea contorului iîn bucla for se modifică în ordine descrescătoare. Această valoare este scăzută cu 1 la fiecare iterație a buclei. La rezolvarea unor astfel de probleme, valoarea contorului buclei trebuie să se schimbe de la ultima la prima valoare. În acest caz, de la 50 la 1.

Calculele au folosit funcția Sqrt() din biblioteca Math.

5. Ce opțiuni există pentru implementarea unei bucle for?

Bucla for poate avea mai multe implementări. Numărul de variabile care controlează bucla for poate fi una, două sau mai multe.

O buclă for poate să lipsească oricare dintre elementele antetului buclei:

inițializare;
expresie;
creştere.

Exemplu un operator de buclă for care are 2 variabile de control. Găsiți semnificațiile produsului:

D = (1 + cos(9)) (2 + cos(8)) … (9 + cos(1))

Un fragment de cod care rezolvă această problemă.

// D = (1 + cos(9))*(2 + cos(8))* ... *(9 + cos(1)) int i, j; plutitor d; d = 1; pentru (i = 1, j = 9; i<=9; i++, j--) d = d * (i + Math::Cos(j));

În fragmentul de cod de mai sus, bucla for folosește două variabile care își schimbă valoarea ( i , j ).

6. bucla while. Forma generală

Bucla while se numește buclă de precondiție. Forma generală a buclei while este următoarea:

in timp ce ( expresie ) { // succesiune de operatori // ... }

Unde expresie– orice expresie validă în C++. Secvența de instrucțiuni este executată până la condițional expresie returnează adevărat. De îndată ce expresie devine egal cu false, execuția buclei while este încheiată și controlul este transferat la următoarea instrucțiune după bucla while.

7. Exemple de utilizare a operatorului de buclă while

Exemplul 1. Dat un număr real A. Găsiți cel mai mic n, la care

Considerații. La început valoarea sumei este mai mică decât valoarea A. Pe măsură ce trece fiecare iterație, valoarea sumei crește treptat. La un moment dat (la o anumită valoare n) această sumă va deveni mai mare decât valoarea A. Acest moment (adică n) trebuie reparat. A calcula n, o buclă while este convenabilă.

Un fragment de cod care rezolvă această problemă.

plutire a; int n; sumă plutitoare; // introduceți valoarea a a = 2,2; n = 1; suma = 1,0/n; în timp ce (suma< a) { n++; sum = sum + 1.0/n; } // n = 5; sum = 2.283334

Exemplul 2. Se dă un număr natural. Determinați numărul de cifre 3 din el.

Un fragment de cod care rezolvă această problemă.

// numărul de cifre 3 în număr int n; // dat număr natural int k; // numărul de cifre 3 în număr int t, d; // variabile suplimentare // introduceți valoarea n n = 12343; t = n; // face o copie a n k = 0; în timp ce (t>0) ( d = t % 10; // selectează ultima cifră dacă (d == 3) k++; t = t / 10; // reduce adâncimea de biți a numărului) // k = 2

În acest exemplu, valoarea numărului inițial va fi împărțită la 10 la fiecare iterație. Astfel, adâncimea de biți a numărului va scădea. La fiecare iterație, folosind operația % a limbajului C++, se ia restul împărțirii cu 10, adică se determină ultima cifră a numărului. Dacă această cifră este 3, atunci contorul k este incrementat cu 1.

8. Forma generală a operatorului bucla do…while

Se recomandă utilizarea buclei do...while în cazurile în care iterația trebuie făcută cel puțin o dată. Spre deosebire de buclele for și while, într-o buclă do...while condiția este verificată la ieșirea din buclă (nu la intrarea în buclă). Bucla do...while se mai numește și buclă postcondiție.

Forma generală a instrucțiunii do…while loop este:

do( // succesiune de operatori// ... ) in timp ce ( expresie );

Unde expresie– o expresie condiționată care verifică valoarea unei variabile de buclă. În această etapă, este determinată execuția ulterioară a ciclului.

Acoladele din această buclă sunt opționale.

Ciclul funcționează după cum urmează. În primul rând, corpul buclei este executat. Apoi valoarea este verificată expresie(expresie condiționată). Dacă valoarea expresie este adevărat (adevărat), corpul buclei este executat din nou. Odată ce valoarea expresie devine fals, execuția buclei se oprește

9. Exemple de utilizare a operatorului bucla do…while

Exemplu. Folosind o buclă do…while, găsiți valoarea sumei:

S = 1 + 3 + … + 99

Un fragment de cod care rezolvă această problemă.

// s = 1 + 3 + ... + 99 int t; int s; s = 0; t = 1; face ( s = s + t; t = t + 2; ) în timp ce (t<=99); // s = 2500

10. Bucle imbricate. Exemple de utilizare

Buclele imbricate pot fi utilizate, de exemplu, atunci când lucrați cu matrice bidimensionale (multidimensionale) (reducerea la zero a unei matrice, calcularea sumelor, a produselor etc.).

Exemplul 1. Calculați produsul

D = 1 · (1 + 2) · (1 + 2 + 3) · … · (1 + 2 + … + 9)

Un fragment de cod care rezolvă această problemă.

// D = 1 * (1+2) * (1+2+3) * ... * (1+2+...+9) plutitor d; // rezultatul este produsul int i, j; // contoare de bucle int s; // variabilă suplimentară d = 1; pentru (i = 1; i<=9; i++) { s = 0; for (j = 1; j<=i; j++) s = s + j; d = d * s; } // d = 2.571912E+09

În acest exemplu, într-o buclă for cu un contor i rulează o buclă for cu un contor j .

Exemplul 2. Având în vedere o matrice bidimensională de numere întregi de dimensiunea 6x9. Scrieți valoarea 5 la toate elementele matricei.

int M; // matrice bidimensională de numere întregi int i, j; pentru (i=0; i<6; i++) for (j=0; j<9; j++) M[i][j] = 5;

11. Ce este o buclă fără sfârșit?

O buclă infinită este o buclă care nu se termină niciodată.

Când programează procese ciclice, programatorul poate scrie în mod greșit cod de buclă care nu se termină niciodată.

În plus, uneori doriți ca buclele să conțină cod special de terminare folosind o instrucțiune break.

Exemplul 1. Buclă infinită cu declarația for:

pentru (; ;) ( // succesiune de operatori C++. Declarație de selecție a comutatorului

Unul dintre cele mai importante instrumente în programare este buclele. Sunt utile în cazurile în care trebuie să faceți ceva de un anumit număr de ori.

Dacă există o astfel de sarcină, de exemplu, să afișați linia „bună ziua tuturor” de 1000 de ori. Apoi, fără a folosi o buclă, în primul rând va dura mult timp și în al doilea rând, nu va arăta foarte frumos. De aceea trebuie să cunoști perfect ciclurile pentru că sunt folosite foarte, foarte des.

Există patru bucle în programare, acestea sunt while, do-while, for și foreach. Fiecare dintre ele are propria sintaxă și fiecare este folosit în anumite cazuri.

Cele mai frecvent utilizate bucle sunt for și foreach, urmate de while, iar bucla do-while este foarte rară.

Și vom începe cu bucla while.

Sintaxa buclei while este următoarea:

Mai întâi, declarăm variabila i, care este un contor, iar în interiorul buclei incrementăm acest contor. În paranteze scriem condiția de intrare/ieșire din buclă.

Cometariu! Scrieți corect condiția de ieșire, altfel se poate întâmpla o buclă infinită și apoi scriptul se va îngheța. Un astfel de ciclu se poate întâmpla dacă, de exemplu, scriem pur și simplu adevărat în condiția de ieșire.

De exemplu, să tipărim șirul „Salut tuturor!” 10 ori.

Var i = 0; în timp ce(i "); i++; )

Variabila i poate începe de la 0 sau 1 sau de la orice alt număr.

Condiția de ieșire este în același timp și condiția de intrare. Bucla funcționează după cum urmează: În primul rând, verifică dacă variabila i este mai mică de 10, iar dacă condiția este adevărată, atunci intrăm în buclă, în caz contrar, nu. În acest caz, dacă variabila i este egală cu 30, de exemplu, atunci bucla nu se va executa, deoarece 30 nu este mai mic de 10.

Am intrat în ciclu, am tipărit linia „Bună ziua tuturor”, am incrementat contorul și din nou mergem la condiția, unde verificăm din nou dacă valoarea variabilei i este mai mică de 10, apoi intrăm în ciclu, altfel ieșim din el. Și asta se întâmplă până în momentul în care condiția de intrare devine falsă, adică valoarea variabilei i va fi 10. 10 nu este mai mic de 10, așa că nu mai intrăm în buclă, ci mergem mai departe.

Cometariu! Nu uitați să creșteți contorul (i++), altfel veți ajunge cu o buclă infinită.

Ne-am ocupat de bucla while, acum să trecem la bucla do-while.

Sintaxa buclei do-while este următoarea:

Diferența dintre o buclă while și o buclă do-while este că o buclă do-while poate fi executată cel puțin o dată, indiferent de condiție, în timp ce o buclă while nu va fi executată deloc dacă condiția este falsă.

Cometariu! La fel ca bucla while, nu uitați să creșteți contorul i.

Să trecem la practică. De exemplu, să calculăm produsul numerelor de la 1 la 10.

Var i = 1; var productie = 1; do( producție *= i; i++; )în timp ce(i

Rezultatul va fi numărul 3628800. La primul pas, am intrat imediat în buclă, în ciuda stării sale, unde a fost efectuată operația producție *= i (aceasta este aceeași cu producția = producție * 1). Apoi creștem contorul. După incrementare, are valoarea 2. Și la sfârșit verificăm condiția, dacă valoarea contorului este mai mică sau egală cu 10, atunci trecem la următoarea iterație a buclei, altfel ieșim din buclă și mergem mai departe .

pentru buclă

După cum am scris mai sus, bucla for apare destul de des, așa că trebuie să o știți foarte bine.

sintaxa buclei for Următorul:

Pentru o mai bună înțelegere, să rezolvăm o problemă simplă. Să presupunem că trebuie să calculăm suma numerelor de la 1 la 1000 folosind o buclă for.

Var summa = 0; pentru(var i = 1; i

Salvăm documentul, îl deschidem în browser și vedem că rezultatul este 500500.

Cometariu! Dacă există o singură declarație într-o buclă, atunci acoladele nu sunt necesare.

Pentru a demonstra, să afișăm un șir pe ecran de 5 ori, de exemplu „Bună ziua!”

Pentru(var i = 1; i

Cometariu! După ce bucla este executată, ultima valoare rămâne în variabila i.

Acum să rezolvăm problema puțin mai complicată, de exemplu trebuie să tipărim șirul „Bună ziua” de 100 de ori. Și pentru ca toate acestea să nu apară pe un rând, apoi după fiecare a 10-a iterație, trecem la o nouă linie. Iar la final vom tipări valoarea variabilei i.

Pentru(var i = 1; i<= 100; i++){ document.write("привет!"); if(i % 10 == 0) document.write("
"); ) document.write("

Variabila i = " + i + "

"); // i = 101

bucla foreach De obicei, folosit pentru a itera obiecte și matrice. Prin urmare, voi vorbi despre asta în articolul care descrie lucrul cu matrice.

declarație de pauză este destinat să iasă forțat din buclă.

Continuați operatorul vă permite să întrerupeți iterația curentă a buclei și să treceți la următoarea.

Pentru o mai bună înțelegere, vom rezolva și o problemă simplă. Să presupunem că vrem să calculăm suma numerelor impare de la 1 la 20. Și când ajungem la a 15-a iterație, vom ieși din buclă.

Var summa = 0; pentru(var i = 1; i<= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
"); ) document.write("

summa= " + suma + "

"); //summa = 64

Salvăm documentul, îl deschidem în browser și ne uităm la rezultat.

Pentru a exersa, încercați să schimbați scriptul scris astfel încât să calculeze suma numerelor pare.

Aceasta încheie acest articol. Acum știi sintaxa while, do-while, bucle pentru și cum să lucrați cu ele. Ne-am întâlnit și noi întrerupe și continuă declarații.