Syntaksi do while. Vaikka silmukkasyntaksi PHP:ssä. For-silmukka. For-silmukan lausekkeen yleinen muoto

Joissakin tapauksissa koodi on suoritettava, kunnes se saavuttaa haluttu lopputulos. Tätä varten PHP tarjoaa while-, for- ja foreach-silmukat.

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 suljettu kiharaisiin aaltosulkeisiin, on silmukan ohjeita (runko). Ne toistuvat, kunnes tila palautuu totta. 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 kasvattaa laskurimuuttujaa $i , komentosarja tulee loputon sykli. Onneksi hetken kuluttua PHP aika lopettaa skriptisi suorittamisen.

Voit tehdä sekä silmukan ehdoista että silmukan rungosta niin monimutkaisen kuin haluat. Käytä esimerkiksi sisällä ollessaan, kun php, käytä php samalla iteroida 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ä avainsana 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 ja lisää $count-muuttujaan $lisäyksen arvon, toisin sanoen luvun 2. Mutta jos $count-muuttuja 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. SISÄÄN 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 luku 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 -silmukat harvoin käytössä käytännössä.

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 while-avainsanan jälkeen määritetty ehto on tosi. Silmukan runko koostuu kahdesta rivistä, joista toinen näyttää 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 eikä ohjelma 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. Käyttäytyminen muuttuu i-muuttujan eri sisällöillä.

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, varsinkin 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.

Riisi. 1 Funktion numeerinen integrointi∫ a b f x d x

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.

vasemmat suorakulmiot" src="/images/c_loop_rectangles_left.png" alt="funktion numeerinen integrointi menetelmällä
vasemmat suorakulmiot"> Рис. 2 Численное интегрирование функции методом!}
vasemmat suorakulmiot

Olkoon vaadittu funktio x 2 . Tarvitsemme seuraavat muuttujat. Ensinnäkin summa-akku integraalin tallentamiseksi. 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.

trapezium" src="/images/c_loop_integral_trapezium.png" alt="funktion numeerinen integrointi menetelmällä
puolisuunnikkaan muotoinen"> Рис. 4 Численное интегрирование функции методом!}
puolisuunnikkaan muotoinen

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 äärettömän silmukan 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 asetetaan 0 maksimiksi. 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

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

Tulostetaan esimerkiksi sadan ensimmäisen numeron neliöt.

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

Yksi hienoimmista hetkistä silmukalle on, että se voi toimia paitsi 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 rajojen 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 alla 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"); }

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

Usein tehtäviä ohjelmoitaessa on välttämätöntä, että sama komentosarja suoritetaan useita kertoja. Tätä prosessia kutsutaan sykliseksi. Algoritmi, jossa tietty komentosarja toistetaan useita kertoja uudella syöttödatalla, kutsutaan sykliseksi.

Syklisen prosessin toteuttamiseksi ohjelmointikielet käyttävät silmukoita. C/C++-ohjelmointikielessä on helppokäyttöiset silmukkaoperaattorit.

2. C++:n silmukkaoperaattoreiden tyypit

C++:ssa on kolmenlaisia ​​silmukkaoperaattoreita:

• silmukalle;
• while-silmukka, jossa on ennakkoehto;
• do...while silmukka jälkiehdon kanssa.

Jokaisella silmukkaoperaattorilla on omat sovellusominaisuudet. Mikä tahansa yllä olevista silmukkakäskyistä voidaan korvata toisella.

3. Silmukalle. For-silmukan lausekkeen yleinen muoto

C++:ssa for-silmukalla voi olla hyvin laaja toteutus ja sovellus. For-silmukkaa kutsutaan myös silmukaksi, jossa on parametri.

For silmukan lausekkeen yleinen muoto on:

varten ( alustus ; ilmaisu ; kasvu ) { // ... }

• alustus – osoitustoiminto, jossa asetetaan silmukkamuuttujan alkuarvo. Tämä muuttuja on laskuri, joka ohjaa silmukan toimintaa. For-silmukkaa ohjaavien muuttujien lukumäärä voi olla kaksi tai useampi;
• ilmaisu– ehdollinen lauseke, joka tarkistaa silmukkamuuttujan arvon. Tässä vaiheessa määritetään syklin jatkosuoritus;
• kasvu– määrittää, kuinka silmukkamuuttujan arvo muuttuu jokaisen iteraation jälkeen.

For-silmukka jatkuu arvoon asti ilmaisu on yhtä totta. Heti kun lausekkeen arvosta tulee epätosi, silmukka lopettaa suorituksen ja for-silmukkaa seuraava käsky suoritetaan.

4. Esimerkkejä for loop -operaattorin käytöstä

Esimerkki 1. Etsi kaikkien kokonaislukujen summa välillä 100-300.

// lukujen summa 100 - 300 int summa; int i; summa = 0; for (i = 100; i<=300; i++) sum = sum + i; // sum = 40200

Esimerkki 2. Annettu luonnollinen luku n. Laske summa:

Koodifragmentti, joka ratkaisee tämän ongelman.

// s = 1 + 1/2 + 1/3 + ... + 1/n int n; kelluva s = 0; int i; // syötä arvo n n = 4; for (i = 1; i<=n; i++) s = s + 1.0/i; // s = 2.08333

Tässä esimerkissä todellisen arvon saamiseksi syötetään numeron 1 (kokonaislukutyyppi) sijasta numero 1.0 (reaalityyppi). Divisioonan toiminta

antaa todellisen tuloksen.

Esimerkki 3. Laske summa

Koodifragmentti, joka ratkaisee tämän ongelman.

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

Tässä esimerkissä laskurin arvo i for-silmukassa muuttuu laskevassa järjestyksessä. Tätä arvoa pienennetään yhdellä silmukan jokaisella iteraatiolla. Tällaisia ​​ongelmia ratkaistaessa silmukkalaskurin arvon tulee muuttua viimeisestä ensimmäiseksi. Tässä tapauksessa 50-1.

Laskennassa käytettiin Sqrt()-funktiota Math-kirjastosta.

5. Mitä vaihtoehtoja for-silmukan toteuttamiseen on?

For-silmukalla voi olla useita toteutuksia. For-silmukkaa ohjaavien muuttujien lukumäärä voi olla yksi, kaksi tai useampi.

For-silmukasta saattaa puuttua jokin silmukan otsikkoelementeistä:

• alustus;
• ilmaisu;
• kasvu.

Esimerkki a for loop -operaattori, jolla on 2 ohjausmuuttujaa. Etsi tuotteen merkitykset:

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

Koodifragmentti, joka ratkaisee tämän ongelman.

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

Yllä olevassa koodinpätkässä for-silmukka käyttää kahta muuttujaa, jotka muuttavat arvoaan ( i , j ).

6. Vaikka silmukka. Yleinen muoto

While-silmukkaa kutsutaan esiehtosilmukaksi. While-silmukan yleinen muoto on seuraava:

sillä aikaa ( ilmaisu ) { // operaattoreiden järjestys // ... }

Missä ilmaisu– mikä tahansa kelvollinen lauseke C++:ssa. Lausesarja suoritetaan ehdolliseen asti ilmaisu palauttaa totta. Niin pian kuin ilmaisu tulee yhtä kuin false , while-silmukan suoritus lopetetaan ja ohjaus siirretään seuraavaan while-silmukan jälkeiseen lauseeseen.

7. Esimerkkejä while-silmukkaoperaattorin käytöstä

Esimerkki 1. Annettu todellinen luku a. Etsi pienin n, jossa

Pohdintoja. Alussa summan arvo on pienempi kuin arvo a. Kun jokainen iteraatio kulkee, summan arvo kasvaa vähitellen. Jossain vaiheessa (jossain arvossa n) tästä summasta tulee arvoa suurempi a. Tämä hetki (tarkoittaa n) täytyy korjata. Laskea n, kun silmukka on kätevä.

Koodifragmentti, joka ratkaisee tämän ongelman.

kellua a; int n; kelluva summa; // syötä arvo a a = 2,2; n = 1; summa = 1,0/n; while(sum< a) { n++; sum = sum + 1.0/n; } // n = 5; sum = 2.283334

Esimerkki 2. Luonnollinen luku annetaan. Määritä siinä olevien numeroiden 3 lukumäärä.

Koodifragmentti, joka ratkaisee tämän ongelman.

// numeroiden lukumäärä 3 numerossa int n; // annettu luonnollinen luku int k; // numeroiden lukumäärä 3 numerossa int t, d; // lisämuuttujia // syötä arvo n n = 12343; t = n; // kopioida n k = 0; kun taas (t>0) (d = t % 10; // valitse viimeinen numero jos (d = = 3) k++; t = t/10; // vähentää numerobitin syvyyttä) // k = 2

Tässä esimerkissä alkuperäisen luvun arvo jaetaan 10:llä jokaisessa iteraatiossa. Siten luvun bittisyvyys pienenee. Jokaisessa iteraatiossa C++-kielen %-operaatiolla otetaan 10:llä jaon jäännös, eli luvun viimeinen numero määritetään. Jos tämä numero on 3, laskuria k kasvatetaan yhdellä.

8. Do…while-silmukkaoperaattorin yleinen muoto

Do...while-silmukkaa suositellaan käytettäväksi tapauksissa, joissa iterointi on suoritettava vähintään kerran. Toisin kuin for- ja while-silmukat, do...while-silmukassa ehto tarkistetaan silmukasta poistuttaessa (ei silmukkaan tullessa). Do...while-silmukkaa kutsutaan myös ehtosilmukaksi.

Do…while -silmukan lausekkeen yleinen muoto on:

tehdä ( // operaattoreiden järjestys// ... ) sillä aikaa ( ilmaisu );

Missä ilmaisu– ehdollinen lauseke, joka tarkistaa silmukkamuuttujan arvon. Tässä vaiheessa määritetään syklin jatkosuoritus.

Tämän silmukan kiharat olkaimet ovat valinnaisia.

Sykli toimii seuraavasti. Ensin silmukan runko suoritetaan. Sitten arvo tarkistetaan ilmaisu(ehdollinen lauseke). Jos arvo ilmaisu on tosi (tosi), silmukan runko suoritetaan uudelleen. Kerran arvo ilmaisu muuttuu false , silmukan suoritus pysähtyy

9. Esimerkkejä do…while-silmukkaoperaattorin käytöstä

Esimerkki. Etsi summan arvo käyttämällä do...while -silmukkaa:

S = 1 + 3 + … + 99

Koodifragmentti, joka ratkaisee tämän ongelman.

// s = 1 + 3 + ... + 99 int t; int s; s = 0; t = 1; do (s = s + t; t = t + 2; ) while (t<=99); // s = 2500

10. Sisäkkäiset silmukat. Esimerkkejä käytöstä

Sisäkkäisiä silmukoita voidaan käyttää esimerkiksi työskenneltäessä kaksiulotteisten (moniulotteisten) taulukoiden kanssa (nollaus taulukossa, laskettaessa summia, tuloja jne.).

Esimerkki 1. Laske tuote

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

Koodifragmentti, joka ratkaisee tämän ongelman.

// D = 1 * (1+2) * (1+2+3) * ... * (1+2+...+9) kellua d; // tulos on tuote int i, j; // silmukkalaskurit int s; // lisämuuttuja d = 1; for (i = 1; i<=9; i++) { s = 0; for (j = 1; j<=i; j++) s = s + j; d = d * s; } // d = 2.571912E+09

Tässä esimerkissä for-silmukassa laskurin kanssa i for-silmukan ajaminen laskurin kanssa j .

Esimerkki 2. Annettu kaksiulotteinen kokonaislukujono, jonka koko on 6x9. Kirjoita arvo 5 kaikille taulukon elementeille.

int M; // kaksiulotteinen kokonaislukutaulukko int i, j; for (i=0; i<6; i++) for (j=0; j<9; j++) M[i][j] = 5;

11. Mikä on loputon silmukka?

Ääretön silmukka on silmukka, joka ei lopu koskaan.

Ohjelmoiessaan syklisiä prosesseja ohjelmoija saattaa vahingossa kirjoittaa koodia silmukalle, joka ei lopu koskaan.

Lisäksi joskus haluat silmukan sisältävän erityisen lopetuskoodin käyttämällä break-lausetta.

Esimerkki 1.Ääretön silmukka lausekkeella:

varten (; ;) ( // operaattoreiden järjestys C++. Kytkimen valintalauseke

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.

Kunnon tarkistamista ja kehon suorittamista jatketaan, kunnes kunto palautuu 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; }

#sisältää käyttäen nimiavaruutta std ; int main() kaksinkertainen maksu = 0 ; int exit = 1 ; // ohjausmuuttuja kun (poistu == 1 ) cout<< ; cin >> maksu ; cout<< ; cin >> exit ; // muuttaa ohjausmuuttujaa cout<< ; cout<< "Tilillesi on lisätty"<< payment << "$Kiitos! Hyvästi!"; cout<< "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~\ n\n"; paluu 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; }

#sisältää käyttäen nimiavaruutta std ; int main() setlocale(LC_ALL, "rus"); kaksinkertainen maksu = 0 ; int exit = 0 ; cout<< "Syötä summa tilisi täydentämiseksi:"; cin >> maksu ; cout<< "Maksa ja poistu - paina 0. Muuta summa - paina 1: "; cin >> exit ;