Declarația de selecție if în C. Elemente de bază PHP

C++ oferă un set standard de operatori pentru selectarea unei selecții și a ciclurilor.

Cuvintele cheie legate de construcția condițiilor de ramificare pentru cod sunt:

• intrerupator
• pauză
• Mod implicit

Cuvintele cheie legate de construcția ciclurilor sunt:

• in timp ce
• pauză
• continua

Declarații de condiție

Declarația If

Construcția condiției care utilizează instrucțiunea if este formată după cum urmează:

Int x = 56; bool check_x () (dacă (x> 0) returnează adevărat; returnează fals;)

În acest caz, condiția este plasată între paranteze după instrucțiunea if. În această construcție, codul de returnare este adevărat; Va fi executat dacă x este mai mare decât 0. rândul următor returnează fals; Nu se mai aplică codului care va fi executat atunci când condiția este îndeplinită. În constructele de condiție, dacă această condiție este îndeplinită, va fi executată o singură linie de cod dacă codul nu este cuprins între paranteze, adică dacă corpul codului executat cu condiție nu este format. Să luăm în considerare două variante ale codului:

Prima varianta:

Int x = 56; bool check_x () (dacă (x> 0) x = 0; returnează adevărat; returnează fals;)

În acest cod, returnați true; Va fi întotdeauna executat, deoarece doar șirul x = 0 este relevant pentru codul care se execută;

A doua varianta:

Int x = 56; bool check_x () (dacă (x> 0) (x = 0; returnează adevărat;) returnează fals;)

În acest cod, returnați true; Va fi satisfăcută numai dacă condiția x> 0 este îndeplinită.

Afirmația altceva

The altfel enunțul este folosit în conjuncție cu dacă afirmație pentru a forma o secvență de condiții.

Int x = 56; bool check_x () (dacă (x> 0) (x = 0; returnează adevărat;) altfel dacă (x< 0) { x = 0; return false; } else { return false; } }

Instrucțiunea else poate fi utilizată pentru a adăuga o nouă condiție dacă condiția anterioară, instrucțiunea else if, eșuează. Și ca cod final într-o succesiune de condiții, dacă condițiile anterioare nu au fost îndeplinite. Alternativ, este posibil să folosiți acolade pentru corpul codului dacă codul se încadrează într-o singură linie.

Declarațiile comută, majuscule, pauze, implicite

The carcasa comutatorului construct este folosit pentru a selecta ramificarea codului, în condiția căreia alegerea se face prin valori întregi. Aceasta înseamnă că cazul comutatorului poate fi folosit doar pentru valori întregi, enumerari și selecții prin codul simbolului.

Int x = 100; bool check_x () (comutați (x) (cazul 0: returnează adevărat; cazul 50: x = 0: break; case 100: returnează fals; implicit: returnează fals;)

În codul de mai sus, variabila x este verificată pentru a fi egală cu numerele 0, 50, 100. Operatorul implicit selectează codul care este executat dacă nu este îndeplinită nici una dintre condiții. De asemenea, rețineți că în blocul de cod cu cazul 50: adăugată o instrucțiune break, această instrucțiune iese din condiție, în timp ce instrucțiunea return iese din funcție. Dacă nu adăugați o instrucțiune break, execuția codului va continua în cazul 100 :. Datorită acestei particularități a construcției carcasei comutatorului, este posibilă combinarea condițiilor pentru care este necesar să se execute același cod. De exemplu:

Int x = 100; bool check_x () (comutator (x) (cazul 0: cazul 50: cazul 100: returnează adevărat; implicit: returnează fals;))

Astfel, pentru x egal cu 0, 50, 100, funcția returnează adevărat, în timp ce pentru toate celelalte valori, funcția returnează false.

De asemenea cod pentru selectarea cazului în acest construct poate fi înfășurată în blocuri de cod, ceea ce va limita domeniul de aplicare și va folosi declarații de variabile cu același nume.

Int x = 100; int check_x () (switch (x) (caz 0: (int y = 1; return y;) case 50: (int y = 2; return y;) case 100: (int y = 3; return y;) implicit : returneaza x;))

Astfel, prin restrângerea domeniului de aplicare, putem folosi variabile cu aceleași nume în condiții de caz. Dar nu uitați că în afara domeniului de aplicare, delimitată de paranteze, variabila y nu va exista în acest caz.

Operatori de cicluri

Declarația while

Instrucțiunea while repetă codul în corpul său atâta timp cât condiția este îndeplinită. De exemplu:

Int i = 0; in timp ce eu< 10) { i = i + 1; }

În acest cod voi fi 10 după buclă.

Declarația de a face

Instrucțiunea do este utilizată împreună cu instrucțiunea while și permite ca corpul buclei să fie executat cel puțin o dată, înainte ca condiția buclei să fie verificată. De exemplu:

Int i = 15; face (i = i - 5; std :: cout<< i << std::endl; } while (i >0 && i< 13);

În acest cod, variabila I nu se potrivește inițial cu condiția și, în bucla obișnuită, codul de corp al buclei nu a fost executat, dar deoarece este utilizată bucla do-while, testul va fi efectuat după ce corpul buclei este executat. Ca rezultat, rezultatul std :: cout este:

Vă puteți întreba, de ce este 0 în ieșire? Nu se potrivește condiției. Din nou, datorită faptului că verificarea este efectuată după ce codul este executat în corpul buclei. Adică, corpul buclei a fost executat și apoi se efectuează o verificare, rezultatul căruia ciclul își finalizează activitatea.

Declarația de pauză

Ca și în cazul switch, această instrucțiune poate fi folosită în bucle. Acest lucru este necesar pentru a ieși din buclă, înainte ca condiția de ciclu să fie îndeplinită. De exemplu:

Int i = 15; in timp ce eu< 50) { if (i < 0) { break; } i = i - 5; }

În acest exemplu artificial, ar rezulta un ciclu etern deoarece variabila i scade în loc să crească, iar după condiția buclei, ieșirea va fi produsă numai dacă i este mai mare de 50. Dar datorită instrucțiunii break și condiției de testare pentru valoarea negativă a variabilei i Execuția programului va ieși din această buclă de îndată ce i devine mai mic de 0.

Declarația continuă

Acest operator vă permite să anulați iterația unei bucle și să începeți o nouă iterație a buclei înainte de a executa tot codul din corpul buclei. De exemplu:

Int i = 0; in timp ce eu< 5) { if (i == 3) { i = i + 1; continue; } std::cout << i << std::endl; i = i + 1; }

Când executăm acest cod, obținem următoarea ieșire:

Adică, ieșirea numărului 3 va fi omisă.

Declarația pentru

Buclele cu instrucțiunea for vă permit să combinați inițializarea variabilelor, condiția și modificarea acestor variabile.

Adică, următoarea buclă while

Int i = 0; in timp ce eu< 10) {

Va fi echivalent cu următoarea buclă for:

Pentru (int i = 0; i< 10; i++) { // ToDo Something }

Avantajul acestei bucle for va fi că variabila I va fi în domeniul local al buclei for.

Buclele For pot fi inițializate cu mai multe variabile de același tip. De exemplu:

Pentru (int i = 0, * p = i< 9; i += 2) { std::cout << i << ":" << *p << " "; }

De asemenea, condiția poate fi declararea, inițializarea unei variabile. De exemplu:

Char cstr = „Bună ziua”; pentru (int n = 0; char c = cstr [n]; ++ n) (std :: cout<< c; }

Având în vedere standardul C++ 11, variabila automată poate fi utilizată ca tip de variabilă, ceea ce vă permite să scoateți tipul variabilei de la inițializator:

Std :: vector v = (3, 1, 4, 1, 5, 9); pentru (auto iter = v.begin (); iter! = v.end (); ++ iter) (std :: cout<< *iter << " "; }

De asemenea, un punct interesant este că inițializatorul, condiția și blocul modificării pot fi expresia:

Int n = 0; pentru (std :: cout<< "Loop start\n"; std::cout << "Loop test\n"; std::cout << "Iteration " << ++n << "\n") { if(n >1) pauză; )

Începând cu standardul C++ 11, pentru bucle, iterația a fost adăugată pentru containerele care acceptă iterația. De exemplu, containerul vector din biblioteca standard:

Std :: vector v = (0, 1, 2, 3, 4, 5); pentru (const int & i: v) std :: cout<< i << " ";

În acest cod, construcția buclei este următoarea:

Pentru (Preluat din container la fiecare iterație a obiectului: container) (// Corpul ciclului)

De asemenea, buclele bazate pe intervale acceptă declarația auto. De exemplu:

Std :: vector v = (0, 1, 2, 3, 4, 5); for (auto & i: v) std :: cout<< i << " ";

Unele surse spun că declarația de selecție if else este o declarație separată. Dar nu este, if else este doar o notație a declarației de selecție if. Declarația if else permite programatorului să definească o acțiune atunci când o condiție este adevărată și o acțiune alternativă când o condiție este falsă. În timp ce dacă i se permite să definească o acțiune într-o condiție adevărată.

Sintaxa pentru scrierea instrucțiunii select dacă else este:

Dacă (/ * condiția verificată * /) (/ * corpul operatorului de selecție 1 * /;) else (/ * corpul operatorului de selecție 2 * /;)

Se citește astfel: „Dacă condiția verificată este adevărată, atunci selectați corpul declarației 1, în caz contrar (adică condiția verificată este falsă) selectați corpul declarației 2". Observați cum este scrisă declarația if else. Alt cuvânt este mutat în mod deliberat la dreapta pentru a face codul programului ușor de înțeles și ușor de citit.

Să ne uităm la problema de la subiectul anterior folosind if else. Permiteți-mi să vă reamintesc starea problemei: „Vi se dau două numere, trebuie să le comparați”.

// if_else.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include folosind namespace std; int main (int argc, char * argv) (int a, b; cout<< "Vvedite pervoe chislo: "; cin >> a; cout<< "Vvedite vtoroe chislo: "; cin >> b; dacă (a> = b) // dacă a este mai mare sau egal cu b, atunci (cout<< a << " >= " << b << endl; } else // иначе { cout << a << " <= " << b << endl; } system("pause"); return 0; }

În acest cod, ne intereseazărândurile 14-20... Aceste rânduri se citesc astfel: dacă A (primul număr) mai mare sau egal b (al doilea număr), apoi executați instrucțiunea de ieșire înlinia 16

Cout<< a << " >= " << b << endl;

în caz contrar, executați instrucțiunea de ieșire în linia 19

Cout<< a << " <= " << b << endl;

În acest if, folosim operații de relație> = și<= . Условие перехода не совсем правильно, так как условие будет ложно только в том случае, если первое число будет меньше второго, во всех остальных случаях условие истинно. Значит, linia 19 ar trebui scris asa

cout<< a << " < " << b << endl; // в кавычках записать не меньше или равно, а просто меньше.

Și așa a funcționat programul (vezi Figura 1).

Vvedite pervoe chislo: 15 Vvedite vtoroe chislo: -4 15> = -4 Apăsați orice tastă pentru a continua. ... ...

Figura 1 - Operatorul de alegere dacă altfel

Permiteți-mi să vă arăt un alt exemplu de utilizare a instrucțiunilor de selecție if else (așa-numitele instrucțiuni imbricate if else pentru selecție multiplă).

Sarcina:
Creați un algoritm care găsește valoarea lui y, dacă y = x, pentru x<0; у=0, при 0<=х<30; у=х 2 , при х>=30;

// inif_else.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include folosind namespace std; int main (int argc, char * argv) (int x, y; cout<< "Vvedite x: "; cin >> x; dacă (x< 0) { y = x; // выполняется, если х меньше нуля } else { if ((x >= 0) && (x< 30)) { y = 0; // выполняется, если х больше либо равно нуля и меньше 30 } else { if (x >= 30) (y = x * x; // executat dacă x este mai mare sau egal cu 30))) cout<< "y=" << y << endl; system("pause"); return 0; }

În această problemă, sunt posibile trei cazuri:
primul caz: x< 0 ;
Al doilea caz: x se află în intervalul de la 0 (inclusiv 0) la 30;
Al treilea caz: x este mai mare sau egal cu 30.

Observați inovația!! V 17 linie notație astfel: dacă ((x> = 0) && (x< 30)) , am folosit simboluri && - asta. Operație booleană ȘI&& este necesar pentru a combina mai multe condiții simple într-un singur compus. În cazul nostru, este necesar să verificăm adevărul a două condiții: prima - x> = 0, a doua - x< 30 . Все проверяемое условие будет истинно, если истинны два простых условия. В математике правильной записью считается такая запись: 0 <= x < 30 , а в С++ правильной записью считается вот такая запись: (x >= 0) && (x< 30) или такая 0 <= x && x < 30 . Кстати круглые скобочки () && () не обязательны, так как условия простые, но для уверенности, я прописываю, всегда, данные скобочки и вам советую.

Analiza unui caz particular:

Să presupunem că utilizatorul a introdus numărul 31. Începând de la linia 12, se verifica conditiile. Se citește astfel: „Dacă x (31 în cazul nostru)< 0, то выполнить оператор в linia 14". Dar din moment ce 31> 0 condiția este falsă, trecem la cuvântul else (altfel) linia 15... Apoi, verificăm dacă numărul 31 se află în intervalul specificat. Se citește astfel: dacă x> = 0 și x<30apoi executați instrucțiunea de pe linia 19 ... Dar, deoarece numărul 31 nu este inclus în intervalul specificat, condiția este falsă. Detaliat linia 17: programul va verifica mai întâi prima condiție simplă x> = 0 - este adevărată, iar dacă prima este adevărată, atunci programul va continua să verifice a doua condiție simplă x< 30 – оно ложно. Следовательно всё составное условие ложно, ведь в составном условии у нас используется логическая операция && , а это значит, что все составное условие истинно только в том случае, когда истинны оба простых условия. Переходим к else (иначе), здесь у нас последний if , (linia 22). Se efectuează verificarea x> = 30. Se citește astfel: Dacă x> = 30 atunci executați operatorul de pe linia 24 ... În cele din urmă, condiția este adevărată, deci afirmația în linia 24... ȘI linia 28 tipărește valoarea rezultată. Ei bine, toată lumea a examinat programul în cel mai mic detaliu. Rezultatul programului, dacă utilizatorul a introdus numărul 31 (vezi Figura 2)

În acest articol, voi vorbi despre bucle for și while, operatori pauzăși continuași, de asemenea, despre cuvânt altfel, care, atunci când este folosit cu o buclă, poate face codul programului puțin mai ușor de înțeles.

buclă în timp ce

While este una dintre cele mai versatile bucle din Python și, prin urmare, este destul de lentă. Execută corpul buclei atâta timp cât condiția buclei este adevărată.

>>> i = 5 >>> în timp ce i< 15 : ... print (i ) ... i = i + 2 ... 5 7 9 11 13

Pentru buclă

Bucla for este deja puțin mai complexă, puțin mai puțin versatilă, dar rulează mult mai rapid decât bucla while. Această buclă iterează peste orice obiect iterabil (cum ar fi un șir sau o listă) și execută corpul buclei în timpul fiecărei treceri.

>>> pentru i în „hello world”: ... print (i * 2, end = "") ... hheelllloo wwoorrlldd

Declarația continuă

Instrucțiunea continue începe următoarea trecere a buclei, ocolind restul corpului buclei (for sau while)

>>> pentru i în „hello world”: ... if i == "o": ... continua ... print (i * 2, end = "") ... hheellll wwrrlldd

Declarație de pauză

Declarația break încheie bucla mai devreme.

>>> pentru i în „hello world”: ... if i == "o": ... break ... print (i * 2, end = "") ... hheellll

Cuvântul magic altceva

Cuvântul else, folosit într-o buclă for sau while, verifică dacă bucla a fost ieșită cu o instrucțiune break sau într-un mod „natural”. Blocul de instrucțiuni din else va fi executat numai dacă bucla a fost ieșită fără ajutorul break-ului.

>>> pentru i în „hello world”: ... if i == „a”: ... break ... else: ... print ( „Nu există litere a în șir”) ... Nu există litera a în șir

Buclele sunt unul dintre cele mai importante instrumente de programare. Sunt utile în cazurile în care trebuie să faci ceva de un anumit număr de ori.

Dacă există o astfel de sarcină, de exemplu, 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. Asa de cicluri pe care trebuie să le cunoști perfect 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 cazuri specifice.

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 pentru bucla while este următoarea:

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

Cometariu! Scrieți corect condiția de ieșire, altfel s-ar putea dovedi buclă nesfârșită și apoi scriptul se va bloca... O astfel de buclă se poate întâmpla dacă, de exemplu, scriem adevărat în condiția de ieșire.

De exemplu, să afișăm linia „Salut tuturor!” 10 ori.

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

Variabila i poate începe de la 0 sau de la 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ă astfel: Î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 va fi executată, deoarece 30 nu este mai mic de 10.

Am intrat în buclă, am afișat linia „Salut 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 buclă, altfel ieșim din ea. Ș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 din nou într-o buclă infinită.

Cu bucla while rezolvată, acum să trecem la bucla do-while.

Sintaxa pentru bucla 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, dacă condiția este falsă, nu va fi executată deloc.

Cometariu! Ca și în cazul buclei while, nu uitați să creșteți contorul i.

Să trecem la practică. De exemplu, să numără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ă increment, are valoarea 2. Iar 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 trecem. pe.

Pentru buclă

După cum am scris mai sus, bucla for este destul de comună, așa că trebuie să o cunoașteți foarte bine.

Sintaxa pentru buclă 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 într-un browser și vedem că rezultatul este 500500.

Cometariu! Dacă există o singură instrucțiune în buclă, atunci acoladele sunt opționale.

Pentru demonstrație vom afișa pe ecran de 5 ori, niște rânduri, de exemplu „Bună ziua!”.

Pentru (var i = 1; i

Cometariu! După executarea buclei în variabila i, rămâne ultima valoare.

Acum să rezolvăm problema puțin mai dificil, de exemplu, trebuie să afișăm șirul „Bună ziua” de 100 de ori. Și pentru ca toate acestea să nu apară într-un rând, apoi după fiecare a 10-a iterație, vom merge la o nouă linie. Și la final vom afișa 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

Foreach buclă folosit în mod obișnuit pentru a itera obiecte și matrice. Prin urmare, voi vorbi despre asta în articolul care descrie lucrul cu matrice.

Declarație de pauză este conceput pentru a ieși forțat din buclă.

Declarația continuă 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 +"

"); // suma = 64

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

Pentru practică, î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... De asemenea, întâlnit întrerupeți și continuați declarațiile.