Faceți bucle while și foreach.

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, valorile variabilei i sunt imprimate pe ecran, apoi 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 este rulat 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 o variabilă care va fi verificat în bucla de condiție și modificați valoarea acestei variabile în corpul buclei. De fapt, să aruncăm o privire la un exemplu simplu folosind o buclă while:

#include int main () (int var = 0; / * asigurați-vă că mai întâi declarați variabila * / 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 nici în acest exemplu. Imaginează-ți doar 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ă ruleze în continuare, iar dacă condiția este falsă, atunci bucla este ieșită.

Mai există un tip de bucle - do while. Această buclă este utilă atunci când trebuie să executați codul cel puțin o dată. Să luăm în considerare 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 verificată 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, desigur, dacă condiția este adevărată, while do while execută mai întâi codul în corpul buclei, apoi verifică condiția și dacă este adevărat, atunci continuă să funcționeze... Un exemplu despre cum funcționează bucla do while este prezentat mai jos:

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

Acordați atenție punctului și virgulă de la sfârșitul buclei, ar trebui să utilizați întotdeauna acest punct și virgulă ca în exemplul de mai sus. Foarte des acest punct și virgulă este omis, rezultând o eroare de compilare. Doar 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ă condiția buclei.

Bucle For și while

Există patru tipuri diferite de bucle în C # (for, while, do ... while și foreach) care vă permit să repetați un bloc de cod până când este îndeplinită o anumită condiție. În acest articol, vă vom prezenta buclele for și while.

Pentru buclă

Bucla for din C # oferă un mecanism de iterație în care o anumită condiție este verificată înainte de a executa fiecare iterație. Sintaxa acestei declarații este prezentată mai jos:

pentru (inițializator; condiție; iterator) operator(i)

este o expresie care este evaluată înainte de prima execuție a corpului buclei (de obicei inițializează o variabilă locală ca contor de bucle). Inițializarea este de obicei reprezentată de un operator de atribuire care stabilește valoarea inițială a unei variabile care acționează ca un numărător și controlează bucla;

este o expresie care este verificată înainte de fiecare nouă iterație a buclei (trebuie să returneze true pentru ca următoarea iterație să fie efectuată);

o expresie care este evaluată după fiecare iterație (de obicei incrementând un contor de buclă).

Rețineți că aceste trei părți principale ale instrucțiunii buclei for trebuie să fie separate prin punct și virgulă. Bucla for va continua să se execute atâta timp cât testul de condiție evaluează la un rezultat adevărat. De îndată ce acest test dă un rezultat fals, bucla se va termina, iar execuția programului va continua din instrucțiunea care urmează buclei for.

Este demn de remarcat faptul că o buclă for este excelentă pentru a re-executa o instrucțiune sau un bloc de instrucțiuni de un număr cunoscut de ori. Să vedem utilizarea practică a buclei for cu următorul exemplu:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 (clasa Program (// Această metodă scoate tabelul de înmulțire // în bxb dimensiuni static void tab (octetul b) (Console.WriteLine ("Tabelul de multiplicare (0) x (0) \ n", b); // Această buclă iterează peste liniile pentru (int i = 1; i

buclă în timp ce

ca pentru, in timp ce este, de asemenea, o buclă de pre-verificare. Sintaxa este aceeași, dar buclele while includ o singură expresie:

în timp ce (condiție) operator(i);

Unde operator este un singur operator sau un bloc de operatori și condiție denotă o condiție specifică de control al buclei și poate fi orice expresie booleană. În această buclă, instrucțiunea este executată atâta timp cât condiția este adevărată. De îndată ce condiția devine falsă, controlul programului este transferat la linia de cod imediat după buclă.

Ca și în bucla for, bucla while testează expresia condiționată specificată chiar la începutul buclei. Aceasta înseamnă că codul din corpul buclei poate să nu fie executat deloc și, de asemenea, elimină necesitatea de a efectua o verificare separată înainte de bucla în sine.

Operator de buclă pentru generalizează construcția binecunoscută a unei bucle precum o progresie aritmetică. Sintaxa sa este:

pentru(inițializatori; condiție; expresie_listă) operator

Operatorul de după paranteza de închidere specifică corpul buclei. În cele mai multe cazuri, corpul buclei este un bloc. Inițializatorii setează valoarea inițială a uneia sau mai multor variabile, adesea numite contoare sau pur și simplu variabile bucle. Condiția stabilește condiția pentru sfârșitul ciclului, expresia corespunzătoare trebuie să primească o valoare în timpul calculului Adevărat sau fals. O listă de expresii separate prin virgulă arată cum se schimbă contoarele de bucle la fiecare pas de execuție. Dacă condiția buclei este adevărată, atunci corpul buclei este executat, atunci valorile contoarelor sunt modificate și condiția este verificată din nou. De îndată ce condiția devine falsă, bucla își încheie activitatea. Într-o situație normală, corpul buclei este executat de un număr finit de ori. Contoarele de buclă sunt adesea declarate direct în inițializator și, în consecință, sunt variabile localizate în buclă.

În cazurile în care este posibilă terminarea prematură a buclei folosind unul dintre operatorii de ramificație, contoarele sunt declarate înaintea buclei, ceea ce permite analizarea valorilor acestora la ieșirea din buclă.

Ca exemplu, luați în considerare problema clasică: este o linie de text un palindrom. Pentru a o rezolva, ciclul pentru se potrivește în cel mai bun mod.

Aici sunt folosite două contoare - unul crescător și celălalt descrescător. Iată textul procedurii corespunzătoare:

/// < rezumat>
/// Definirea palindromurilor. Demonstrarea bucleipentru
///
/// text
/// < se intoarce> Adevărat- dacă textul este un palindrom
public bool Palindrom (string str){
pentru (int i= 0, j= str.Lungimea- 1; i< j; i ++, j--)
dacă (str [i]!= str [j]) return (fals);
întoarcere (Adevărat);
} // Palindrom

5.6.2. While Loops

Ciclu in timp ce(expresie) este un tip universal de buclă care este inclus în toate limbajele de programare. Corpul buclei este executat atâta timp cât expresia rămâne adevărată in timp ce. În C #, acest tip de buclă are două modificări - cu o verificare a condiției la începutul și la sfârșitul buclei. Prima modificare are următoarea sintaxă:

în timp ce (expresie) enunţ

Această modificare corespunde unei bucle cu o precondiție. Corpul unei astfel de bucle nu poate fi niciodată executat. Într-o situație normală, fiecare execuție a corpului buclei este încă un pas către sfârșitul buclei.

O buclă care verifică condiția de terminare la sfârșit corespunde unei bucle cu o postcondiție. Corpul unei astfel de bucle este executat cel puțin o dată. Iată sintaxa pentru această modificare:

do
operator
în timp ce (expresie);

Să dăm un exemplu în care sunt implicate ambele modificări ale ciclului in timp ce. În bucla exterioară, verificarea se efectuează la final, iar în bucla interioară, la început. Bucla exterioară este un exemplu tipic de organizare a programelor educaționale, atunci când o anumită problemă este rezolvată în mod repetat într-un dialog cu utilizatorul. La fiecare pas, utilizatorul introduce date noi, rezolvă problema și analizează datele primite. Stă în puterea lui, dacă să continue sau nu calculele, dar măcar o dată trebuie să rezolve problema. Bucla interioară doin timp ce este folosit pentru a rezolva problema deja cunoscută cu palindromurile. Iată textul procedurii corespunzătoare:

/// < rezumat>
/// Două bucle: cu o verificare la sfârșit și la început.
/// Bucla exterioară este o mostră a unei probleme care poate fi rezolvată în mod repetat.
/// Sfârșitul ciclului este determinat în dialogul cu utilizatorul.
///
Buclă public void (){
// startprocedurirăspuns șir, text;
do{
// începutul buclei exterioare
Consolă. WriteLine("Introduceți un cuvânt");
text= Console.ReadLine ();
int i= 0, j= text.Lungime- 1;
in timp ce eu< j)&& (text [i]== text [j])) (
// interiorciclu
i ++; j--;
}
dacă (text [i]== text [j]) Console.WriteLine (text+ " - aceastapalindrom!");
altfel Console.WriteLine (text+ " - aceastanupalindrom!");
Console.WriteLine ("Hai sa continuăm? (da nu) ");
Răspuns= Console.ReadLine ();
} în timp ce (răspunde== "da");// sfarsitexternciclu
} // Buclă

5.6.3. Pentru fiecare buclă

Un nou tip de buclă, care nu este moștenit de la C++, este bucla pentru fiecare, convenabil atunci când lucrați cu matrice, colecții și alte containere de date similare. Sintaxa sa este:

pentru fiecare(identificator de tipîncontainer) operator

Bucla funcționează în deplină conformitate cu numele său - corpul buclei este executat pentru fiecare element din container. Tipul de identificare trebuie să se potrivească cu tipul articolelor stocate în containerul de date. De asemenea, se presupune că elementele containerului (matrice, colecție) sunt ordonate. La fiecare pas al buclei, identificatorul care specifică elementul curent al containerului primește valoarea următorului element în conformitate cu ordinea stabilită pe elementele containerului. Corpul buclei este executat cu acest element curent - se execută de câte ori există elemente în container. Bucla se termină când toate elementele containerului au fost complet enumerate. Dezavantaj serios al ciclurilor pentru fiecareîn C # este că bucla funcționează numai pentru citire, dar nu și pentru scrierea elementelor. Deci trebuie să umpleți containerul cu elemente folosind alți operatori de buclă.

Exemplul de mai jos demonstrează lucrul cu o matrice 3D. Matricea este creată folosind bucle precum pentru, iar la aflarea sumei elementelor sale, a valorilor minime si maxime, se foloseste ciclul pentru fiecare:

/// < rezumat>
/// Demonstrarea bucleipentru fiecare.
/// Calculați suma, elementele maxime și minime
/// o matrice tridimensională plină cu numere aleatorii.
///
public void SumMinMax (){
int [,] arr3d= new int;
Rnd aleatoriu= nou Random ();
pentru (int i= 0; i< 10; eu ++)
pentru (int j= 0; j< 10; j++)
pentru (int k= 0; k< 10; k++)
arr3d= rnd.Next (100);
sumă lungă= 0;
int min= arr3d,max= arr3d;
foreach (int element în arr3d){
sumă+= articol;
dacă (articolul> max) max= articol;
else if (articolul< min) min= articol;
}
Console.WriteLine ("suma= {0}, min= {1}, max= {2}", suma, min, max);
} // SumMinMax

Faceți bucle while și foreach

Bucla do. ... ... in timp ce

Faceți... bucla whileîn C #, aceasta este o versiune post-condițională a lui while. Aceasta înseamnă că starea buclei este verificată după ce corpul buclei este executat. Prin urmare, buclele do ... while sunt utile în situațiile în care un bloc de instrucțiuni trebuie executat cel puțin o dată. Următoarea este forma generală a instrucțiunii buclei do-while:

do (afirmații;) while (condiție);

Dacă există o singură declarație, acoladele sunt opționale în această notație. Cu toate acestea, ele sunt adesea folosite pentru a face constructul do-while mai lizibil și pentru a nu fi confundat cu construcția buclei while. Bucla do-while rulează atâta timp cât expresia condiționată este adevărată. Un exemplu de utilizare a unei bucle do-while este următorul program care calculează factorialul unui număr:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 (clasa Program (static void Main (șir argumente)) (try (// Calculați factorialul int i, rezultat = 1, num = 1; Console.WriteLine ("Introduceți un număr:"); i = int.Parse (Console .ReadLine ()); Console.Write ("\ n \ nFactorial (0) =", i); do (rezultat * = num; num ++;) while (num

Foreach buclă

Foreach buclă servește pentru accesul ciclic la elementele unei colecții, care este un grup de obiecte. C # definește mai multe tipuri de colecții, fiecare dintre acestea fiind o matrice. Următoarea este forma generală a instrucțiunii buclei foreach:

operator foreach (tip loop_variable_name în colecție);

Aici tip cycle_variable_name denotă tipul și numele unei variabile de control al buclei care primește valoarea următorului articol din colecție la fiecare pas al buclei foreach. O colecție denotă o colecție interogată ciclic, care este în continuare o matrice. Prin urmare, tipul variabilei buclei trebuie să se potrivească cu tipul elementului de matrice. În plus, tipul poate fi notat cu cuvântul cheie var. În acest caz, compilatorul determină tipul variabilei buclei pe baza tipului elementului de matrice. Acest lucru poate fi util pentru a rezolva anumite tipuri de interogări. Dar, de regulă, tipul este specificat în mod explicit.

Declarația foreach buclă funcționează după cum urmează. Când începe bucla, primul element al matricei este selectat și atribuit variabilei buclei. La fiecare pas ulterior al iterației, următorul element al matricei este selectat și stocat în variabila buclă. Bucla se termină când sunt selectate toate elementele matricei.

Bucla foreach vă permite să parcurgeți fiecare articol din colecție (un obiect care reprezintă o listă de alte obiecte). Formal, pentru ca ceva să fie considerat o colecție, trebuie să accepte interfața IEnumerable. Exemplele de colecții includ matrice C #, clase de colecții din spațiul de nume System.Collection și clase de colecții personalizate.

Gigabyte va oferi kituri bazate pe placa Z390 Aorus Xtreme WaterForce și Core i9-9900K overclockat. Gigabyte va lansa în curând kituri de pe placa de bază Z390 Aorus Xtreme WaterForce și procesorul Intel Core i9-9900K overclockat la 5,1 GHz (8 nuclee / 16 fire, 3,6 / 5 GHz). Aceste truse sunt în primul rând

Samsung Galaxy A90 a fost testat pentru prima dată în benchmark Geekbench. Pe 10 aprilie, Samsung va face următoarea sa prezentare, unde va prezenta cu siguranță o serie de smartphone-uri de gamă medie. Printre acestea ar trebui să fie Samsung Galaxy A90, care tocmai a fost testat

Site-ul web Slahsleaks, care încarcă adesea fotografii exclusive cu dispozitive mobile noi și accesorii pentru acestea, a publicat o fotografie live a panoului frontal al smartphone-ului Nokia 8.1 Plus. Smartphone-ul a primit rame foarte înguste în jurul perimetrului, o ramă ceva mai lată sub afișaj,

O echipă internațională de oameni de știință a demonstrat o nouă modalitate de a converti lumina emisă de un laser convențional în ceea ce este cunoscut sub numele de lumină cuantică. O caracteristică a unei astfel de lumini este proprietățile cuantice identice ale fotonilor săi, care sunt evidențiate de

Majoritatea aparatelor moderne, pornind de la cele mai simple ceasuri electronice, folosesc componente speciale numite generatoare de ceas, care, atunci când li se aplică un semnal adecvat, încep să producă oscilații cu o frecvență strict specificată. Mai mult

Astronomii au descoperit 83 de noi găuri negre supermasive, a căror vârstă este aproape egală cu vârsta părții din univers disponibilă pentru studiu. Identificarea acestor găuri negre și determinarea parametrilor acestora au fost efectuate prin analiza luminozității și spectrului de emisie a acestora. ei

Google a anunțat o nouă funcție pentru trimiterea de e-mailuri către Gmail. Acum expedierea lor poate fi programată la un moment convenabil. Pentru a planifica o scrisoare, trebuie să faceți clic pe săgeata de lângă butonul „Trimite” și să selectați ora și data dorite de trimitere, scrie Chronicle.info cu un link către

IFixit a studiat designul noii generații de iPad mini, pe care Apple l-a dezvăluit oficial luna trecută. Dispozitivul, ne amintim, este echipat cu un display Retina cu diagonala de 7,9 inchi. Rezoluția este de 2048 × 1536 pixeli,

Televizoarele și ecranele Vizio vor primi suport AirPlay. Producătorul american de electronice de larg consum Vizio a anunțat anterior suport pentru AirPlay 2 și aplicația Home. Acum a devenit cunoscut faptul că specialiștii companiei lucrează la aplicația SmartCast compatibilă cu AirPlay.

BIOSTAR, cel mai mare producător mondial de plăci de bază, plăci grafice și dispozitive de stocare, a dezvăluit placa de bază A68MHE pentru mainstream. BIOSTAR A68MHE este alimentat de chipset AMD A68H, care acceptă procesoare AMD FM2 + Athlon ™ / A-series și RAM