Miten do while -silmukka toimii. Vaikka silmukkasyntaksi PHP:ssä. do…while -silmukan lausekkeen yleinen muoto

Itse asiassa ohjelman tulos:

0 1 2 3 4 5 6 7 8 9

Tämä ohjelma on hyvin yksinkertainen esimerkki silmukan käytöstä. muuttujalle i annetaan nolla, ja kun i on pienempi kuin 10, muuttujan i arvo tulostetaan näytölle, minkä jälkeen muuttujaan i lisätään yksi ja kaikki toistetaan uudelleen, kunnes ehdosta tulee epätosi. Muista, että muuttujan i arvoa kasvatetaan sen jälkeen, kun silmukan rungossa oleva koodi suoritetaan ensimmäisen kerran.

While-silmukka on hyvin yksinkertainen silmukka, tässä on sen rakenne:

Vaikka (/*ehto*/) ( // silmukan runko - tässä on koodi, joka on toistettava)

Silmukan runko alkaa suorittaa, jos silmukan ehto on tosi. Ehto on Boolen lauseke, kuten x == 1 tai x! = 7 (x ei ole 7). Eli ehto voi olla aivan mikä tahansa - mikä tahansa loogisten lausekkeiden yhdistelmä. Tässä on esimerkki yhdisteehdosta - x == 3 || x > 10 , tämä ehto on tosi, jos x on kolme tai x on suurempi kuin 10. Huomaa, että vaikka sillä on alustusosio tai ohjatun muuttujan muokkausosa, joten ennen tämän silmukan käyttöä sinun on ensin ilmoitettava muuttuja, joka testataan ehtosilmukassa ja silmukan rungossa muuta tämän muuttujan arvoa. Katsotaanpa itse asiassa yksinkertaista esimerkkiä while-silmukan avulla:

#sisältää int main() ( int var = 0; /* muista ilmoittaa muuttuja ensin */ while (var< 10) { /* пока значение muuttuja var alle 10 */ printf("%d\n", var); var++; /* päivittää muuttujan var arvoa (jos et tee tätä, silmukan ehto on aina tosi, jolloin silmukka on loputon) */ ) getchar(); )

Joten tarkastelimme toista esimerkkiä silmukoiden käytöstä, ja kuten näet, tässä esimerkissä ei ole mitään monimutkaista. Kuvittele vain, että silmukka alkaa aina toistaa koodia, joka on silmukan rungossa. Heti kun se on toteutettu viimeinen operaattori silmukan rungossa silmukan kunto tarkistetaan. Jos ehto on edelleen tosi, silmukka jatkaa toimintaansa, ja jos ehto on epätosi, silmukasta poistutaan.

On olemassa toisen tyyppinen silmukka - tee samalla. Tämä silmukka on hyödyllinen, kun sinun täytyy suorittaa koodia sen mukaan vähintään- 1 kerran. Katsotaanpa sen rakennetta:

Tee ( // loop body ) while (/*ehto*/);

Rakenne on hyvin yksinkertainen, kuten näet, ehto on silmukan lopussa, ja vastaavasti ehto tarkistetaan silmukan rungossa olevan koodin suorittamisen jälkeen. Huomaa, että ehto testataan silmukan lopussa, ei alussa, joten silmukan rungossa oleva koodilohko suoritetaan vähintään kerran. Jos ehto on tosi, silmukka hyppää takaisin alkuun ja suorittaa sen uudelleen. Do while -silmukka on melkein sama kuin while-silmukka, paitsi että silmukan runko suoritetaan taatusti ainakin kerran. While-silmukka tarkistaa ensin ehdon ja suorittaa sitten koodilohkon rungossa, jos ehto on tietysti tosi, kun taas do while -silmukka suorittaa ensin koodin silmukan rungossa ja tarkistaa sitten ehdon, ja jos se on totta, niin se jatkaa toimintaansa. Alla on esimerkki do while -silmukasta:

#sisältää int main() ( int i = 0; do ( /* Tulostaa viestin ja poistuu */ printf("Hei! Teen while-silmukan\n"); ) while (i != 0); getchar() ;)

Huomaa puolipiste silmukan lopussa, sinun tulee aina sijoittaa puolipiste kuten yllä olevassa esimerkissä. Hyvin usein tätä puolipistettä ei sisällytetä, mikä johtaa käännösvirheeseen. Vain tämä sykli päättyy puolipisteeseen. Huomaa, että yllä olevassa esimerkissä tämä silmukka suoritetaan kerran, koska viesti tulostetaan ensin ja sitten silmukan kunto tarkistetaan.

Tunnisteet: C-syklit. C silmukat. Silmukka jälkiehdoin. Silmukka ennakkoehdoin. Pyöräile kirjoittajan kanssa. sillä aikaa. tehdä, kun. varten. tauko. jatkaa

Johdanto. Silmukat ennakkoehdoin.

Käytännön ongelmia ratkaistaessa syntyy jatkuvasti tarve toistaa toimenpide. määritetty määrä kertaa tai kunnes jokin ehto on saavutettu. Voit esimerkiksi näyttää luettelon kaikista käyttäjistä, laatoittaa tasolle tekstuurin, suorittaa laskelmia tietotaulukon jokaiselle elementille jne. C:ssä näihin tarkoituksiin käytetään kolmenlaisia ​​silmukoita: kanssa edellytys, jälkiehto ja pyöräillä varten laskurilla (vaikka tämä on ehdollinen nimi, koska laskuria ei välttämättä ole).

Mikä tahansa silmukka koostuu rungosta ja sen ehdon tarkistamisesta, jossa tämä silmukka tulisi päättää. Silmukan runko on joukko ohjeita, jotka on toistettava. Jokaista silmukan toistoa kutsutaan iteraatioksi.

Harkitse silmukkaa, jossa on ennakkoehto.

Int i = 0; sillä aikaa kun minä< 10) { printf("%d\n", i); i++; }

Tämä silmukka toimii niin kauan kuin jälkeen määritetty ehto on tosi avainsana sillä aikaa. Silmukan runko koostuu kahdesta rivistä, joista toinen tulostaa numeron, toinen muuttaa sitä. Ilmeisesti tämä silmukka suoritetaan 10 kertaa ja näytetään
0
1
2
3
ja niin edelleen 9 asti.

On erittäin tärkeää, että silmukasta poistumisen ehto täyttyy jossain vaiheessa, muuten syntyy silmukka ja ohjelma ei valmistu. Esim

Int i = 0; sillä aikaa kun minä< 10) { printf("%d\n", i); }

Tämä silmukka ei muuta muuttujaa i, jota käytetään pysäytysehdon määrittämiseen, joten silmukka ei pääty.

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

Tässä ohjelmassa silmukka tietysti päättyy, mutta virheellisen toimenpiteen vuoksi se suoritetaan paljon enemmän kuin 10 kertaa. Koska C ei valvo muuttujan ylivuotoa, sinun on odotettava, kunnes muuttuja ylivuotuu ja muuttuu pienemmäksi kuin nolla.

Int i; sillä aikaa kun minä< 10) { printf("%d\n", i); i++; }

Tällä esimerkillä on määrittelemätön toiminta. Koska muuttujaa i ei alustata etukäteen, se tallentaa roskaa, tuntematonta arvoa etukäteen. Muuttujan i eri sisällöillä käyttäytyminen muuttuu.

Jos while-silmukan runko sisältää yhden lauseen, kiharat aaltosulut voidaan jättää pois.

Int i = 0; sillä aikaa kun minä< 10) printf("%d\n", i++);

Tässä suurennamme muuttujaa i, kun kutsumme printf-funktiota. Tätä koodaustyyliä tulee välttää. Poissaolo aaltosulkeet, etenkin harjoituksen alussa, voi johtaa virheisiin. Lisäksi koodi on vähemmän luettavissa, eivätkä ylimääräiset sulut turvota listauksia paljon.

Silmukat jälkiehdoilla.

Jälkiehtosilmukka eroaa while-silmukasta siinä, että ehto tarkistetaan silmukan suorittamisen jälkeen, mikä tarkoittaa, että silmukka toistetaan vähintään kerran (toisin kuin while-silmukka, jota ei välttämättä suoriteta ollenkaan). Silmukan syntaksi

Do (silmukan runko) while(ehto);

Edellinen esimerkki, jossa käytettiin do-silmukkaa, näyttäisi tältä

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

Katsotaanpa esimerkkiä silmukan käytöstä jälkiehdon ja ennakkoehdon kanssa. Oletetaan, että meidän on integroitava funktio.

Integraali on infinitesimaalien summa. Voimme esittää integraalin summana ja yksinkertaisesti korvata äärettömät pienet arvot pienillä arvoilla.

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

Kaava osoittaa, että olemme itse asiassa jakaneet kaavion alla olevan alueen useisiin suorakulmioihin, joissa suorakulmion korkeus on funktion arvo pisteessä ja leveys on askeleemme. Laskemalla yhteen kaikkien suorakulmioiden pinta-alat, saamme siten integraalin arvon, jossa on virhe.

Olkoon vaadittu funktio x 2 . Tarvitsemme seuraavat muuttujat. Ensinnäkin summa-akku integraalin tallentamiseen. Toiseksi a:n ja b:n vasen ja oikea raja, kolmanneksi askel h. Tarvitsemme myös funktion argumentin x nykyisen arvon.

Integraalin löytämiseksi on lähdettävä mistä a ennen b joillain askeleilla h, ja lisää summaan suorakulmion pinta-ala sivuilla f(x) Ja h.

#sisältää #sisältää int main() ( double summa = 0.0; double a = 0.0; double b = 1.0; double h = 0.01; double x = a; while (x< b) { sum += x*x * h; x += h; } printf("%.3f", sum); getch(); }

Ohjelma tulostaa 0,328.

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

Jos katsot kuvaajaa, voit nähdä, että joka kerta, kun löydämme funktion arvon vasemmasta pisteestä. Siksi tätä numeerisen integroinnin menetelmää kutsutaan vasemman suorakulmion menetelmäksi. Vastaavasti voit ottaa oikean arvon. Sitten se on oikea suorakaidemenetelmä.

While(x< b) { x += h; sum += x*x * h; } oikeat suorakulmiot" src="/images/c_loop_rectangles_right.png" alt="funktion numeerinen integrointi menetelmällä
oikeat suorakaiteet"> Рис. 3 Численное интегрирование функции методом!}
oikeat suorakaiteet

Summa tässä tapauksessa on 0,338. Vasen ja oikea suorakaidemenetelmä ei ole kovin tarkka. Olemme itse asiassa approksimoineet monotonisesti kasvavan funktion sileän kaavion histogrammilla. Jos ajattelet hieman, likiarvo voidaan suorittaa paitsi suorakulmioiden, myös puolisuunnikkaan summaamisen avulla.

Puolisuunnikkaan approksimaatio on itse asiassa paloittainen approksimaatio ensimmäisen asteen käyrillä (ax+b). Yhdistämme kaavion pisteet viivaosien avulla. Voit tehdä siitä monimutkaisemman yhdistämällä pisteitä ei segmenteillä, vaan paraabelin paloilla, niin tämä on Simpsonin menetelmä. Jos monimutkaistamme asioita entisestään, tulemme spliiniinterpolaatioon, mutta se on toinen, hyvin pitkä keskustelu.

Palataan lampaidemme luo. Tarkastellaan 4 sykliä.

Int i = 0; while (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);

Jos suoritat nämä esimerkit, näet, että silmukat suoritetaan kahdesta toiseen neljä kertaa. Tähän kannattaa kiinnittää huomiota, koska silmukkalaskurin väärä vaihtaminen johtaa usein virheisiin.

Usein käy niin, että joudumme poistumaan silmukasta odottamatta lipun nostoa tai muuttujan arvon muuttumista. Näihin tarkoituksiin käytetään operaattoria tauko mikä saa ohjelman poistumaan nykyisestä silmukasta.

Päätetään yksinkertainen tehtävä. Käyttäjä syöttää numeroita, kunnes numero 0 syötetään, minkä jälkeen suurin syötetty näytetään. Siinä on saalis. Ei tiedetä, kuinka monta numeroa käyttäjä syöttää. Siksi luomme loputon sykli, ja poistumme siitä käyttämällä operaattoria tauko. Silmukan sisällä saamme tietoja käyttäjältä ja valitsemme enimmäismäärän.

#sisältää #sisältää int main() ( int num = 0; int max = num; printf("Lopeta kirjoittamalla 0\n"); /*lopettamaton silmukka*/ while (1) ( printf("Anna numero: "); scanf("%d", &num);/*silmukasta poistumisen ehto d ", max); getch(); )

Haluan muistuttaa, että C:ssä ei ole erityistä Boolen tyyppiä. Sen sijaan käytetään numeroita. Nolla on epätosi, kaikki muut arvot ovat tosia. While(1)-silmukka kestää ikuisesti. Ainoa lähtökohta siitä on kunto

Jos (luku == 0)

Tässä tapauksessa poistumme silmukasta painikkeella tauko; Aluksi asetamme maksimiarvon 0. Käyttäjä syöttää numeron, jonka jälkeen tarkistamme, onko se nolla vai ei. Jos se ei ole nolla, vertaamme sitä nykyiseen maksimiin.

Infinite-silmukoita käytetään melko usein, koska syötetietoa ei aina tiedetä etukäteen tai se voi muuttua ohjelman ollessa käynnissä.

Kun meidän on ohitettava silmukan runko, mutta jatkettava silmukan suorittamista, käytämme operaattoria jatkaa. Yksinkertainen esimerkki: käyttäjä syöttää kymmenen numeroa. Etsi kaikkien hänen kirjoittamiensa positiivisten lukujen summa.

#sisältää #sisältää int main() ( int i = 0; int positiivinenCnt = 0; float summa = 0.0f; float input; printf("Anna 10 numeroa\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(); }

Esimerkki vaikuttaa hieman kaukaa haetulta, vaikka yleisesti ottaen se heijastaa operaattorin merkitystä jatkaa. Tässä esimerkissä muuttuja positiivinenCnt on positiivisten lukujen laskuri, summa määrä ja syöttö- väliaikainen muuttuja numeroiden syöttämiseen.

Tässä on toinen esimerkki. Käyttäjän on syötettävä kokonaisluku, joka on suurempi kuin nolla ja pienempi kuin 100. Ohjelma jatkaa kyselyä, kunnes tarvittava numero on syötetty.

Do ( printf("Anna numero: "); scanf("%d", &n); if (n< 0 || n>100) ( printf("huono numero, yritä uudelleen\n"); jatka; ) else ( break; ) ) while (1);

silmukalle

Yksi yleisimmin käytetyistä on laskurisilmukka. varten. Sen syntaksi

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

Tulostetaan esimerkiksi sadan ensimmäisen numeron neliöt.

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

Yksi for-silmukan hienoista asioista on, että se voi toimia muunkin kuin kokonaislukujen kanssa.

Float numero; for (num = 5.3f; num > 0f; num -= 0.2) ( printf("%.2f ", num); )

Tämä silmukka tulostaa numeroita välillä 5,3 - 0,1. For-silmukasta saattaa puuttua joitain koodin "lohkoja", esimerkiksi alustus, testaus (sitten silmukasta tulee ääretön) tai laskurin vaihtaminen. Tässä on esimerkki integraalista, joka on toteutettu laskurin avulla varten

#sisältää #sisältää int main() ( double summa = 0,0; double a = 0,0; double b = 1,0; double h = 0,01; double x; for (x = a; x< b; x += h) { sum += x*x * h; } printf("%.3f", sum); getch(); }

Katsotaanpa koodinpätkää

Double x ; for (x = a; x< b; x += h) { sum += x*x * h; }

Sen voi muuttaa näin

Double x = a; for(; x< b; x+=h) { sum += x*x*h; }

Lisäksi käyttämällä operaattoria tauko, voit poistaa ehdon ja kirjoittaa

Double x; for (x = a;; x += h)( if (x>b)( break; ) summa += x*x*h; )

Double x = a; for (;;)( jos (x > b)( break; ) summa += x*x*h; x += h; )

Lisäksi voit siirtää joitain toimintoja käyttämällä operaattoria ",".

Double x ; for (x = a; x< b; x += h, sum += x*x*h) ;

HUOMAA: Vaikka tämä on mahdollista, älä tee tätä! Tämä heikentää koodin luettavuutta ja johtaa hienovaraisiin virheisiin.

Ratkaistaan ​​joku vaikeampi käytännön ongelma. Olkoon funktio f(x). Etsitään sen derivaatan maksimi segmentiltä. Kuinka löytää funktion derivaatta numeerisesti? Ilmeisesti määritelmän mukaan). Funktion derivaatta pisteessä on tangentin kulman tangentti.

F x ′ = d x d y

Otetaan käyrältä piste koordinaateilla (x; f(x)), siirrytään yksi askel h eteenpäin, saadaan piste (x+h, f(x+h)), niin derivaatta on

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

Toisin sanoen funktion pienen lisäyksen suhde argumentin pieneen lisäykseen. Huomaavainen lukija voi kysyä, miksi liikumme funktiossa eteenpäin emmekä taaksepäin. No mennään takaisin

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

Ottamalla näiden kahden arvon keskiarvon, saamme

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

Yleisesti ottaen tehtävästä tulee nyt triviaali: lähdemme pisteestä a asiaan b ja löydämme minimiarvo derivaatta sekä piste, jossa johdannainen saa tämän arvon. Ratkaisua varten tarvitsemme, kuten integraalin ongelmassa, muuttujia hakualueen rajoille a Ja b, nykyarvo x ja askel h. Lisäksi vaaditaan enimmäisarvo maxVal ja koordinoida maxX tämä maksimiarvo. Toimi ottamalla funktio x sin x

#sisältää #sisältää #sisältää 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; // Käymme läpi koko alueen a:sta b:hen // ja etsimme ensimmäisen derivaatan maksimiarvoa // Käytä funktiota x*sin(x) kohtaan (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("max arvo = %.3f at %.3f", maxVal, maxX); getch(); )

Lähdössä ohjelma tuottaa maksimiarvon = 1,391 kohdassa 1,077

Numeerinen ratkaisu antaa samat (virheen sisällä) tulokset kuin ohjelmamme.

Sisäkkäiset silmukat

Katsotaanpa esimerkkiä, jossa silmukat ovat sisäkkäin toistensa sisällä. Näytetään kertotaulukko.

#sisältää #sisältää #sisältää int main() ( int i, j; // Jokaiselle i:lle for (i = 1; i< 11; i++) { // Выводим строку из произведения i на j for (j = 1; j < 11; j++) { printf("%4d", i*j); } // После чего переходим на uusi rivi printf("\n"); ) getch(); )

Tässä esimerkissä ensimmäisessä silmukassa muuttujan läpi i sisäkkäinen toinen silmukka muuttujan päälle j. Toimintojen järjestys on seuraava: ensin siirrytään sykliin mennessä i, sen jälkeen nykyiselle i Numerot tulostetaan 10 kertaa peräkkäin. Tämän jälkeen sinun on siirryttävä uudelle riville. Tulostetaan nyt vain päädiagonaalin alapuolella olevat elementit

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

Kuten näette, operaattori tauko voit poistua vain nykyisestä silmukasta. Tämä esimerkki voitaisiin kirjoittaa uudelleen seuraavasti

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

SISÄÄN tässä tapauksessa Käytämme sisäkkäisen silmukan ensimmäistä silmukkalaskuria.

Ru-Cyrl 18-opetusohjelma Sypachev S.S. 14.4.1989 [sähköposti suojattu] Stepan Sypachev opiskelijat

Eikö vieläkään ole selvää? – kirjoita kysymyksiä postilaatikkoon

Tämä artikkeli kattaa kaksi muuta sykliä: sillä aikaa Ja tehdä, kun. Ne ovat hyvin samankaltaisia ​​keskenään. Niiden syntaksi on:

Kuva 1 - kun syntaksi
Kuva 2 - tee syntaksin aikana

Ainoa ero on siinä, kun silmukka alkaa sillä aikaa, kunto tarkistetaan välittömästi. Jos se palauttaa epätosi ( väärä), silmukan runkoa ei suoriteta edes kerran. Ja käytettäessä tehdä, kun, silmukan rungon operaattori(t) suoritetaan välittömästi, ja sitten suluissa oleva ehto tarkistetaan () avainsanan jälkeen sillä aikaa. Ja samoin palatessaan väärä, silmukka päättyy, muussa tapauksessa seuraava vaihe (iterointi) suoritetaan. Eli silmukan runko tehdä, kun suoritetaan vähintään kerran missä tahansa skenaariossa.

Puhutaanpa niistä erikseen. Aloitetaan sillä aikaa. Kuten edellä mainittiin, jotta silmukan runko voidaan suorittaa, on välttämätöntä, että suluissa olevia ehtoja tarkistettaessa () , totta palautettiin.

Ehto tarkistetaan ja kehoa suoritetaan, kunnes ehto palaa väärä. Tästä käy ilmi, että syklin keskeyttämiseksi sen kehossa täytyy tapahtua jotain, joka vaikuttaa tilan todentamiseen.

Tämä voi olla käyttäjän näppäimistöltä syöttämän muuttujan arvo, joka on silmukan testitilassa. Tai se voi olla kontrollimuuttujan lisäys tai lasku, joka myös liittyy testitilaan.

Tarkastellaan esimerkkiä ohjausmuuttujan arvon muuttamisesta silmukan rungossa. Ongelmailmoitus: käyttäjä haluaa täydentää korttitiliään päätteen kautta. Hän syöttää summan näppäimistöltä. Anna ohjelmalle mahdollisuus muuttaa väärin syötettyä summaa.

Esimerkki - while-silmukka C++

#sisältää käyttäen nimiavaruutta std; int main() ( setlocale(LC_ALL, "rus"); tuplamaksu = 0; int exit = 1; // ohjausmuuttuja while (exit == 1) ( cout<< "Введите сумму для пополнения счета: "; cin >> maksu; cout<< "Оплатить и выйти - нажмите 0. Изменить сумму - нажмите 1: "; cin >> poistua; // muuta ohjausmuuttujaa ) cout<< "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; cout << "Ваш счет пополнен на " << payment << "$ Спасибо! До свидания!"; cout << "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; return 0; }

Ohjausmuuttuja poistu ilmoitetaan ja alustetaan yhdeksi ennen silmukkaa sillä aikaa– rivi 9. Siksi silmukkaan tullessasi kunto tarkistetaan kun (poistu == 1) palaa totta(voit lukea lisää tästä) ja ohjelma jatkaa silmukan rungon suorittamista. Tämä ehto kirjoitetaan usein näin: kun (poistu). Tällä ehdolla ohjelma toimii kuten edellinenkin. Tämä selittyy sillä, että mikä tahansa muuttujan arvo poistu nollasta poikkeavat arvot kääntäjä tulkitsee seuraavasti totta. Silmukan runkoa suoritetaan, kunnes käyttäjä muuttaa tämän muuttujan arvon 0:ksi. Sitten kun (poistu) tulee olemaan samanarvoisia kun (0). Eli testiehto on väärä. Tämä merkintä on yleisempi, koska se on lyhyempi, vaikkakaan ei niin selkeä kuin esimerkissä. Siihen pitää vain tottua.

Riveillä 16–17 käyttäjältä kysytään kysymys ja häntä pyydetään tekemään valinta: cout<< “Оплатить и выйти – нажмите 0. Изменить сумму – нажмите 1: “; Eli jos hän teki virheen syöttäessään täydennysmäärää, hänellä on mahdollisuus korjata se painamalla 1.

Heti kun käyttäjä syöttää oikean summan ja painaa 0 (joka vastaa "Maksa ja poistu"), silmukka poistuu ja ohjelma jatkaa toimintaansa. Tämän seurauksena ruudulle ilmestyy viesti tilin täydennyssummasta - rivit 20 - 22.

Tulos:

Sama ongelma voidaan ratkaista käyttämällä silmukkaa tehdä, kun. Tässä tapauksessa aluksi muuttujan arvo poistu voi olla mitä tahansa. Joka tapauksessa silmukka suorittaa kehon ja tarjoaa valinnan. Katsotaan:

#sisältää käyttäen nimiavaruutta std; int main() ( setlocale(LC_ALL, "rus"); tuplamaksu = 0; int exit = 0; do ( cout<< "Введите сумму для пополнения счета: "; cin >> maksu; cout<< "Оплатить и выйти - нажмите 0. Изменить сумму - нажмите 1: "; cin >> poistua; ) while (poistu == 1); cout<< "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; cout << "Ваш счет пополнен на " << payment << "$ Спасибо! До свидания!"; cout << "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n"; return 0; }

tehdä while- ja foreach-silmukoita

tee silmukka . . sillä aikaa

do...when loop C#:ssa tämä on while-versio, jossa on jälkikunnon tarkistus. Tämä tarkoittaa, että silmukan ehto tarkistetaan silmukan rungon suorittamisen jälkeen. Siksi do...while -silmukat ovat hyödyllisiä tilanteissa, joissa lausekkeiden lohko on suoritettava vähintään kerran. Seuraava on do-while-silmukkalausekkeen yleinen muoto:

do (operaattorit; ) while (ehto);

Jos operaattoria on vain yksi, kiharat aaltosulut tässä merkintämuodossa ovat valinnaisia. Niitä käytetään kuitenkin usein tekemään do-while-konstruktista luettavampaa, eikä niitä pidä sekoittaa while-silmukkakonstruktioon. Do-while-silmukka toimii niin kauan kuin ehdollinen lauseke on tosi. Esimerkki do-while-silmukan käytöstä on seuraava ohjelma, joka laskee luvun kertoimen:

Järjestelmän käyttö; käyttäen System.Collections.Generic; käyttäen System.Linq; käyttäen System.Text; nimiavaruus ConsoleApplication1 ( luokka Ohjelma ( staattinen void Main(merkkijono args) ( kokeile ( // Laske luvun tekijä int i, tulos = 1, num = 1; Console.WriteLine("Anna numero:"); i = int .Parse(Console .ReadLine());

foreach silmukka

foreach silmukka palvelee syklistä pääsyä kokoelman elementteihin, joka on objektiryhmä. C# määrittelee useita kokoelmia, joista jokainen on taulukko. Seuraava on foreach-silmukan lausekkeen yleinen muoto:

foreach (kirjoita silmukan_muuttujan_nimi kokoelmaan) -lause;

Tässä kirjoita silmukan_muuttujan_nimi tarkoittaa silmukan ohjausmuuttujan tyyppiä ja nimeä, joka vastaanottaa kokoelman seuraavan elementin arvon foreach-silmukan jokaisessa vaiheessa. Ja kokoelma tarkoittaa syklisesti kysyttyä kokoelmaa, joka jäljempänä edustaa taulukkoa. Siksi silmukkamuuttujan tyypin on vastattava taulukkoelementin tyyppiä. Lisäksi tyyppi voidaan merkitä avainsanalla var. Tässä tapauksessa kääntäjä määrittää silmukkamuuttujan tyypin taulukkoelementin tyypin perusteella. Tästä voi olla hyötyä tietyntyyppisten kyselyiden kanssa työskentelyssä. Mutta yleensä tyyppi on määritelty nimenomaisesti.

Foreach-silmukan lauseke toimii seuraavasti. Kun silmukka alkaa, taulukon ensimmäinen elementti valitaan ja liitetään silmukkamuuttujaan. Jokaisessa myöhemmässä iteraatiovaiheessa valitaan seuraava taulukon elementti ja tallennetaan silmukkamuuttujaan. Silmukka päättyy, kun kaikki taulukon elementit on valittu.

Foreach-silmukan avulla voit iteroida kokoelman jokaisen elementin (objekti, joka edustaa luetteloa muista objekteista) läpi. Teknisesti, jotta jotain voidaan pitää kokoelmana, sen on tuettava IEnumerable-liitäntää. Esimerkkejä kokoelmista ovat C#-taulukot, System.Collection-nimiavaruuden kokoelmaluokat ja mukautetut kokoelmaluokat.

Joissakin tapauksissa on välttämätöntä suorittaa koodia, kunnes haluttu tulos saavutetaan. Tätä tarkoitusta varten PHP tarjoaa kun silmukoita, for ja foreach .

Vaikka silmukkasyntaksi PHP:ssä

Syntaksi syklisillä aikaa:

Esimerkki while-silmukan käytöstä PHP:ssä:

Yllä olevassa php while -silmukan esimerkissä laskurimuuttuja $i alustetaan ensin nollaan.

While-silmukan ehto on $i< 10 . Это означает, что мы проверяем, меньше ли переменная, чем 10.

Kaikki, mikä on sidottu kiharaisiin aaltosulkeisiin, on silmukan ohjeita (runko). Ne toistetaan niin kauan kuin ehto palauttaa tosi. Yllä olevassa esimerkissä $i tulostetaan näytölle ja sitten laskurimuuttujaa kasvatetaan yhdellä. Tämä on tärkeää, jotta silmukan ehto lopulta epäonnistuu. Jos silmukan ehto täyttyy aina, esimerkiksi koska olet unohtanut inkrementoida laskurimuuttujaa $i , komentosarja syöttää loputtoman silmukan. Onneksi PHP lopettaa skriptin suorittamisen hetken kuluttua.

Voit tehdä sekä silmukan ehdoista että silmukan rungosta niin monimutkaisen kuin haluat. Käytä esimerkiksi sisällä ollessasi, kun taas php, käytä php while iteroidaksesi taulukon läpi ( array ) tai määritä useampi kuin yksi laskurimuuttuja:

$min) ( echo "count1: $count1; count2: $count2
"; $ laskuri1 += 2; // Pikalause lausekkeelle $laskuri1 = $laskuri1 + 2; $laskuri2 -= 3; // Pikalause lausekkeelle $count2 = $count2-3; ) ?>

Esimerkki määrittelee kaksi muuttujaa: $ laskuri 1 ja $ laskuri 2 . Yhtä muuttujaa kasvatetaan 2:lla ja toista vähennetään 3:lla. While-silmukka toimii niin kauan kuin molemmat ehdot täyttyvät $ count 1< $ max и $ count 2 >$min

Tauko- ja jatka-avainsanojen vaikutus silmukassa

Käyttämällä komentoa tauko Voi keskeyttää while-silmukan suoritus PHP. Oletetaan, että etsimme tiettyä käyttäjää. Sitten voit käydä läpi kaikki käyttäjät jonkin aikaa. Jos löydämme haluttu käyttäjä, lopeta sitten silmukka käyttämällä avainsanaa tauko.

Yksinkertainen esimerkki break-avainsanan käytöstä:

while ($count< $max) { if ($count == 10) { echo "Останавливаемся на числе 10"; break; } echo "$count,"; $counter += $increment; // увеличивает $count на значение $increment } ?>

Tämä koodi toistuu numeroiden läpi nousevassa järjestyksessä 0:sta $max = 30:een lisäämällä $incrementin arvon muuttujaan $count, toisin sanoen luvun 2. Mutta jos muuttuja $count on yhtä suuri kuin 10, seuraava tapahtua: poistumalla while-silmukasta php.

Avainsana jatkuu ei lopeta silmukkaa php:ssä on täysin , mutta ohittaa vain muun silmukan rungon. Alla oleva esimerkki osoittaa tämän:

while ($count< $max) { $counter += $increment; // увеличивает $payer на $increment if ($count >= 10 && $ count<= 15) { echo "Число между 10 и 15
"; jatkaa; )
echo "$count
"; } ?>

Tämä silmukka alkaa 0:sta ja kasvattaa laskuria aina $max:iin asti. $laskurimuuttujaa kasvatetaan aina $lisäysmuuttujan arvolla. Eli se ottaa arvot 0, 2, 4 jne.

Jos $count-muuttujan arvo on välillä 10-15, teksti ja lausunto tulostetaan näytölle jatkaa ohittaa muut lausekkeet silmukan rungossa. Tämän seurauksena näemme, että numeroita 10, 12 ja 14 ei tulosteta.

do-while -silmukka PHP:ssä

Pieni muutos sillä aikaa on do - while -silmukka. Tässä tapauksessa silmukan kunto tarkistetaan vasta sen jälkeen, kun sen runko on suoritettu. Tämä tarkoittaa, että silmukan runko suoritetaan vähintään kerran.

Do-while -silmukkasyntaksi:

Oletetaan, että haluamme luoda satunnainen numero, jonka on oltava joko välillä 0 ja 10 tai välillä 20 ja 30. Funktion rand ( $ min, $ max), voi satunnaisesti luo numero väliin $min Ja $ max:

10 && $ satunnainen< 20) { $random = rand (0, 30); }
echo "Satunnaislukumme: $random"; ?>

Käyttämällä php loopia tehdä— sillä aikaa, voit saada lausekkeen arvon alustamatta $random-muuttujaa. Silmukan runko suoritetaan ennen ehdon testaamista. Sitten yllä oleva esimerkki näyttäisi tältä:

10 && $ satunnainen< 20);
echo "Satunnaislukumme: $random"; ?>

Aloittelijalle do-while-silmukka voi olla hieman hämmentävä. Jos et täysin ymmärrä sen tarkoitusta, se ei ole ongelma. Do-while -silmukoita käytetään harvoin käytännössä.