Structuri de control în limbajul de programare

Implementarea structurilor algoritmice fundamentale în limbajul de programare ales.

Instrucțiunea if-else: decizia în cod

Instrucțiunea if este traducerea în C++ a structurii alternative din pseudocod:

• if (conditie) instructiune; — instrucțiunea se execută doar dacă condiția e adevărată;
• if (conditie) instructiune1; else instructiune2; — se execută exact una dintre cele două ramuri.

Reguli care se verifică la teste:

• Condiția stă obligatoriu între paranteze rotunde: if x > 5 este eroare de sintaxă; corect este if (x > 5).
• Dacă pe o ramură vrei mai multe instrucțiuni, le grupezi între acolade { }. Fără acolade, de ramură aparține doar prima instrucțiune — restul se execută mereu, indiferent de condiție. Aceasta e una dintre cele mai frecvente erori de logică: indentarea frumoasă te păcălește vizual, dar compilatorul ține cont doar de acolade.
• Nu se pune punct și virgulă imediat după condiție: if (x > 5); { ... } face ca ramura să fie instrucțiunea vidă, iar blocul de după acolade să se execute întotdeauna.

if-urile imbricate: un if poate sta în interiorul altui if. Regula de aur: else se leagă de cel mai apropiat if care nu are deja un else. Când vrei altă asociere, folosești acolade ca să delimitezi explicit blocurile.

Lanțul if – else if – else tratează mai multe cazuri exclusive (de exemplu: notă sub 5 → corigent; între 5 și 9 → promovat; 10 → excelent), verificându-le în ordine și oprindu-se la primul caz adevărat.

Instrucțiunea switch: alegerea multiplă

Când o variabilă întreagă sau de tip caracter trebuie comparată pe rând cu mai multe valori fixe, lanțul de if-else devine greoi. C++ oferă instrucțiunea switch (case of în Pascal):

switch (x) { case 1: ...; break; case 2: ...; break; default: ...; }

Cum funcționează: valoarea lui x este comparată cu fiecare case; la prima potrivire, execuția sare acolo și continuă de la acel punct. Ramura default se execută când nicio valoare nu se potrivește — este echivalentul lui else.

Detaliul care face diferența la punctaj: break. Fără break la finalul unui case, execuția NU se oprește, ci cade în cazul următor (fenomenul fall-through) și execută și instrucțiunile acestuia. Dacă x este 1 și case 1 nu are break, se execută și instrucțiunile de la case 2. Uitarea lui break este o eroare de logică clasică — programul compilează perfect.

Limitări de reținut:

• switch funcționează doar cu valori întregi sau caractere — nu cu numere reale și nu cu intervale;
• case 1..5 nu există în C++: pentru condiția „x între 1 și 5” folosești if (x >= 1 && x <= 5);
• valorile din case trebuie să fie constante, nu variabile sau expresii cu variabile.

Când ai de ales: valori fixe și puține → switch e mai citeț; condiții cu intervale sau comparații complexe → obligatoriu if-else.

Instrucțiunea while: repetarea cu test inițial

while (conditie) { ... } este bucla cu test inițial: condiția se evaluează înaintea fiecărei iterații, iar corpul se execută doar cât timp condiția rămâne adevărată.

Consecința esențială: dacă la prima evaluare condiția este falsă, corpul nu se execută deloc — zero iterații. Un while (n < 0) cu n citit pozitiv se sare complet.

Anatomia unei bucle while corecte are trei elemente, toate obligatorii:

• inițializarea variabilelor de control, înainte de buclă (i = 1;);
• condiția de continuare (i <= n);
• actualizarea variabilei de control, în corpul buclei (i++;).

Dacă lipsește actualizarea, condiția nu se schimbă niciodată și obții o buclă infinită — programul „îngheață”. La probele practice, aceasta este cauza numărul unu pentru care un program nu afișează nimic.

while este alegerea firească atunci când nu știm dinainte de câte ori repetăm: prelucrarea cifrelor unui număr (while (n != 0) { ... n /= 10; }), citirea unor valori până la întâlnirea unui zero, înjumătățirea repetată a unui număr.

Pentru întrebările de tip „de câte ori se execută corpul buclei?”, metoda sigură rămâne tabelul de urmărire: notezi valorile variabilelor la fiecare iterație și numeri rândurile. Estimarea „din ochi” duce aproape mereu la greșeli de tip ±1 (off-by-one): bucla while (i < n) cu i pornind de la 1 face n-1 pași, nu n.

Instrucțiunea for: repetarea cu contor

Când numărul de repetări este cunoscut, folosim for, care adună la un loc cele trei elemente ale buclei:

for (i = 1; i <= n; i++) { ... }

Între parantezele rotunde stau, despărțite prin punct și virgulă: inițializarea (se execută o singură dată, la început), condiția de continuare (se verifică înaintea fiecărei iterații) și pasul (se execută după fiecare iterație). Ordinea reală de execuție: inițializare → condiție → corp → pas → condiție → corp → pas → ... până când condiția devine falsă.

De reținut:

• for este doar o scriere compactă a unui while echivalent — tot buclă cu test inițial este, deci poate face și zero iterații: for (i = 5; i < 3; i++) nu execută corpul niciodată;
• contorul poate să și scadă: for (i = n; i >= 1; i--) parcurge valorile în ordine descrescătoare;
• pasul poate fi diferit de 1: for (i = 0; i <= 100; i += 5);
• numărul de iterații pentru for (i = a; i <= b; i++) este b - a + 1 — acel +1 se uită sistematic: de la 3 la 10 sunt 8 valori, nu 7.

Capcană de sintaxă cu efect de logică: un punct și virgulă pus direct după paranteze — for (i = 1; i <= n; i++); { ... } — face ca bucla să învârtă instrucțiunea vidă, iar blocul dintre acolade să se execute o singură dată, la final. Programul compilează fără nicio eroare, dar rezultatul e complet diferit.

do-while și structurile imbricate

do { ... } while (conditie); este bucla cu test final (repeat-until în Pascal): corpul se execută mai întâi, apoi se verifică condiția. Garanția ei: corpul rulează cel puțin o dată, orice ar fi.

Atenție la sensul condiției, pentru că aici Pascal și C++ diferă și confuzia costă puncte: do-while continuă cât timp condiția e adevărată, pe când repeat-until se oprește când condiția devine adevărată. La traducerea dintr-un limbaj în celălalt, condiția se neagă: repeat ... until n = 0 devine do { ... } while (n != 0);

Utilizarea tipică: validarea datelor de intrare — ceri utilizatorului un număr până introduce unul acceptabil; citirea trebuie să se întâmple măcar o dată, deci do-while e alegerea naturală.

Structurile imbricate — o buclă în interiorul alteia — apar la afișarea tabelelor, a triunghiurilor de stele sau la parcurgerea matricelor (anul viitor). Regula de execuție: pentru fiecare iterație a buclei exterioare, bucla interioară rulează complet, de la capăt. Două bucle for imbricate, fiecare de la 1 la n, execută corpul interior de n × n ori.

Greșeala tipică la imbricare este refolosirea aceluiași contor (i) în ambele bucle — cele două se sabotează reciproc și rezultatul devine haotic; bucla interioară primește întotdeauna alt contor (j).

În sfârșit, break părăsește imediat bucla curentă (doar pe cea interioară, dacă sunt imbricate), iar continue sare la iterația următoare. Folosite cu măsură, fac unele soluții mai scurte; folosite haotic, fac programul greu de urmărit.

Test — 6 întrebări ca la examen