Structuri de control C/C++

Instrucțiunile C++ pot fi executate în ordine, alese prin if sau repetate prin while, do...while și for. Alegerea se face după o condiție; repetarea are nevoie de un criteriu clar de oprire. Lecțiile „Structura alternativă” și „Repetarea cu contor” explică modelele algoritmice pe care aceste forme le transcriu în cod.

În Python, if 3 > 2: print("da") afișează „da”. În C++, aceeași alegere folosește if cu paranteze și acolade.

C++ oferă instrucțiuni de decizie (if, if ... else, switch) și de repetare (while, do ... while, for). Acoladele grupează mai multe instrucțiuni într-un bloc; fără ele, structura controlează numai instrucțiunea imediat următoare. while (c) testează condiția înaintea fiecărei execuții a corpului și poate executa zero ori; do ... while (c); testează după corp și execută cel puțin o dată; for (inițializare; condiție; pas) grupează ciclul cu contor. Instrucțiunea break părăsește imediat ciclul sau switch-ul cel mai interior, iar continue trece la următoarea iterație a ciclului. Instrucțiunea switch alege o ramură după valoarea unei expresii de tip întreg sau caracter; fiecare ramură case continuă în cea următoare dacă nu este încheiată cu break, iar default tratează valorile neenumerate.

Exemplul 1 — suma numerelor impare.

#include <iostream>
using namespace std;
int main() {
    int suma = 0;
    for (int i = 1; i <= 3; ++i) {
        if (i % 2 == 1) suma += i;
    }
    cout << suma;
    return 0;
}

La $i=1$ suma devine 1; la $i=2$ condiția este falsă și suma rămâne 1; la $i=3$ suma devine 4. Se afișează 4. Aceeași sumă a numerelor de la 1 la 5 se poate calcula cu oricare dintre cele trei cicluri: for (int i = 1; i <= 5; ++i) s += i;, while cu j inițializat cu 1 și crescut în corp, sau do ... while cu k inițializat cu 1; în toate trei cazurile rezultatul este 15.

Exemplul 2 — break și continue. Se adună numerele impare de la 1 la 10, dar ciclul se oprește când un număr depășește 7:

int t = 0;
for (int i = 1; i <= 10; ++i) {
    if (i % 2 == 0) continue;
    if (i > 7) break;
    t += i;
}
cout << t;

Numerele pare sunt sărite prin continue. Se adună 1, 3, 5, 7 și suma este $16$. Pentru $i=9$ condiția i > 7 este adevărată și break încheie ciclul, deci 9 nu mai este adunat. Se afișează 16.

Pentru $i=1$ ciclul interior face 1 pas, pentru $i=2$ face 2, pentru $i=3$ face 3. Numărul total de execuții ale lui c++ este $1+2+3=6$, deci se afișează 6. Dacă în ciclul interior se adaugă if (j == 2) break; înaintea lui c++, la $i=1$ se face un singur pas, iar la $i=2$ și $i=3$ ciclul se oprește la $j=2$, după câte un pas numărat. Rezultatul devine $1+1+1=3$.

În pseudocod, structurile corespunzătoare sunt cât timp, repetă … până când și pentru; repetă … până când c se scrie în C++ do … while (!(c));.

while. Repetă corpul cât timp condiția e adevărată. Se folosește când nu știi dinainte câte treceri vor fi: cât timp mai sunt cifre, cât timp nu s-a citit 0. Ceva din corp trebuie să schimbe valoarea condiției, altfel bucla nu se mai oprește.

do while. Execută întâi corpul, apoi testează condiția. Este potrivită când prima trecere trebuie făcută oricum, de exemplu când numeri cifrele unui număr și vrei ca 0 să aibă o cifră. Atenție la ; de după while (cond): la do while este obligatoriu.

for. for (init; cond; act) adună într-un singur rând cele trei părți ale unei bucle cu contor: inițializarea (o dată, la început), condiția (înaintea fiecărei treceri) și actualizarea (după fiecare trecere). Este echivalent cu:

init;
while (cond) {
    corp
    act;
}

Contorul nu trebuie să crească neapărat cu 1: i--, i = i + 2 sau i = i * 2 sunt la fel de valide. Un ; pus imediat după for (…) face corpul gol, iar instrucțiunea de dedesubt se execută o singură dată, după buclă.

Bucle imbricate. O buclă în interiorul alteia execută bucla interioară complet pentru fiecare valoare a contorului exterior. Numărul total de treceri este suma numerelor de treceri ale buclei interioare: pentru i de la 1 la $n$ și j de la i la $n$, sunt $n+(n-1)+\dots +1=n(n+1)/2$ treceri.

break și continue sunt utile, dar o buclă cu o condiție clară e de obicei mai ușor de urmărit, iar în pseudocodul de la examen nu există echivalente directe.

Exemple suplimentare

Exemplul 3 — switch cu break. Un calculator simplu alege operația după caracterul op. Pentru op = '*', p = 6 și q = 4, ramura case '*': este aleasă, se afișează $6\cdot 4=24$, iar break oprește continuarea în ramurile următoare. Pentru o zi codificată prin număr, switch (zi) cu ramurile 1, 2, 3 pentru „luni”, „marți”, „miercuri” afișează „miercuri” când zi = 3; o valoare precum 9 intră în default.

Exemplul 4 — alegerea ciclului și pasul. for se potrivește când se știe numărul de pași, while când se repetă pașii cât timp o condiție este adevărată, iar do ... while când pasul trebuie făcut măcar o dată. Pasul nu trebuie să fie 1: ciclul for (int i = 10; i > 0; i -= 3) afișează 10 7 4 1, adică valorile $10,7,4,1$; următoarea valoare ar fi $-2$, care nu respectă condiția $i>0$. Un for care numără în sens invers scade variabila, nu o crește.

Exemplul 5 — while față de do ... while când condiția este falsă de la început. Fie int k = 5;. Ciclul while (k < 3) { k++; } testează întâi condiția $5<3$, care este falsă, deci corpul nu se execută și k rămâne 5. Ciclul do { k++; } while (k < 3); execută corpul o dată, înainte de test: k devine 6, apoi testul $6<3$ este fals și ciclul se oprește. Diferența apare doar când condiția este falsă de la început; în rest, cele două forme dau același rezultat.

Exemplul 6 — cicluri imbricate și numărarea pașilor. Ciclul interior se repetă complet la fiecare pas al celui exterior.

int c = 0;
for (int i = 1; i <= 3; ++i)
    for (int j = 1; j <= i; ++j)
        c++;
cout << c;

Exemple rezolvate

Exemplul 1: while, până la citirea lui 0. Se citesc numere naturale până la primul 0, care nu face parte din șir. Afișează suma lor. Pentru 4 7 0 se afișează 11; pentru 0, suma este 0.

#include <iostream>
using namespace std;

int main() {
    int x, s = 0;
    cin >> x;
    while (x != 0) {
        s = s + x;
        cin >> x;          // citesc urmatorul numar
    }
    cout << s << "\n";
    return 0;
}

Pentru intrarea 4 7 0, programul afișează:

11

Exemplul 2: do while, până la primul număr par. Se citesc numere naturale până la primul număr par, inclusiv. Afișează câte numere s-au citit. Pentru 3 5 8 1 se citesc 3, 5 și 8, deci răspunsul este 3; numărul 1 rămâne necitit.

#include <iostream>
using namespace std;

int main() {
    int x, nr = 0;
    do {
        cin >> x;
        nr++;
    } while (x % 2 == 1);
    cout << nr << "\n";
    return 0;
}

Pentru intrarea 3 5 8 1, programul afișează:

3

do while este firească aici, pentru că trebuie citit cel puțin un număr înainte de a putea testa ceva.

Exemplul 3: for, termenii șirului lui Fibonacci. Afișează termenii șirului lui Fibonacci (1, 1, 2, 3, 5, …, fiecare termen fiind suma celor doi dinaintea lui) care nu depășesc 100.

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 1;
    cout << a << " ";
    for (; b <= 100; ) {       // for fara initializare si fara actualizare
        cout << b << " ";
        int c = a + b;
        a = b;
        b = c;
    }
    cout << "\n";
    return 0;
}

Programul afișează:

1 1 2 3 5 8 13 21 34 55 89

Un for cu inițializarea și actualizarea goale este, de fapt, un while (b <= 100); aici while ar fi mai clar. În Python, la clasa a IX-a pe programa nouă, aceeași buclă se scrie cu while:

a, b = 1, 1
termeni = [a]
while b <= 100:
    termeni.append(b)
    a, b = b, a + b
print(*termeni)

1 1 2 3 5 8 13 21 34 55 89

Exemplul 4: de câte ori se execută o buclă imbricată. Ce afișează secvența de mai jos pentru $n=10$?

#include <iostream>
using namespace std;

int main() {
    int n = 10, cnt = 0;
    for (int i = 1; i <= n; i++)
        for (int j = i; j <= n; j++)
            cnt++;
    cout << cnt << "\n";
    return 0;
}

1. Pentru i = 1, j ia valorile 1…10: 10 treceri; pentru i = 2, 9 treceri; …; pentru i = 10, o trecere.
2. Total: $10+9+\dots +1=10\cdot 11/2=55$.

55

Exemplul 5: nivel de examen, un contor care se dublează. De câte ori se execută corpul buclei for (i = 1; i <= 100; i = i * 2) și ce valoare are i după buclă? Scrie o secvență echivalentă cu while.

1. i ia valorile 1, 2, 4, 8, 16, 32, 64; următoarea valoare, 128, nu mai respectă condiția.
2. Corpul se execută de 7 ori, iar după buclă i = 128.
3. Echivalentul cu while: i = 1; while (i <= 100) { corp; i = i * 2; }.

#include <iostream>
using namespace std;

int main() {
    int i, nr = 0;
    for (i = 1; i <= 100; i = i * 2)
        nr++;
    cout << nr << " " << i << "\n";
    int k = 1, nr2 = 0;               // varianta cu while
    while (k <= 100) {
        nr2++;
        k = k * 2;
    }
    cout << nr2 << " " << k << "\n";
    return 0;
}

Programul afișează același rezultat pentru ambele variante:

7 128
7 128

Într-o urmărire de cod, notează valorile variabilelor la intrarea și la ieșirea din fiecare iterație. Verifică atent condiția i <= 3: sunt trei iterații, nu patru. În cazul ramurilor fără acolade, numai instrucțiunea imediat următoare aparține structurii. Când există bucle imbricate, break părăsește doar bucla interioară în care apare. La switch, urmărește unde apare primul break: de la ramura aleasă se execută toate instrucțiunile până la el. Un punct și virgulă pus imediat după antetul unei structuri o golește: în for (int i = 0; i < 3; i++); { n++; } ciclul are corpul vid, iar n++ se execută o singură dată, deci n ajunge 1, pe când fără ; blocul s-ar executa de trei ori. Același lucru se întâmplă la if (x > 3); și la while (c);.

Exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

int x = 2;
switch (x) {
    case 1: cout << "A";
    case 2: cout << "B";
    case 3: cout << "C"; break;
    default: cout << "D";
}

• a) B
• b) BC
• c) BCD
• d) ABC

Răspunsul corect este b). Valoarea lui x este 2, deci execuția intră la case 2 și afișează B. Ramura nu se încheie cu break, așa că execuția continuă cu case 3 și afișează C; abia aici break părăsește switch-ul. Ramura default nu se mai execută. Varianta a) presupune un break după case 2, iar varianta d) începe de la case 1.

Al doilea exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

int c = 0;
for (int i = 1; i <= 3; i++)
    for (int j = 1; j <= 3; j++) {
        if (j == 2) break;
        c++;
    }
cout << c;

• a) 1
• b) 3
• c) 6
• d) 9

Răspunsul corect este b). Pentru fiecare valoare a lui $i$, ciclul interior face $j=1$, incrementează c, apoi la $j=2$ break îl încheie. Ciclul exterior continuă, deci sunt trei incrementări: $c=3$. Varianta a) presupune că break oprește și ciclul exterior. Varianta d) ignoră break, iar varianta c) numără și pasul $j=2$.

Unde apare la examen

La Bacalaureatul la informatică, matematică-informatică, programa de examen cuprinde structurile de bază (liniară, alternativă și repetitivă), la algoritmi, și structurile de control (instrucțiunea compusă, structuri alternative și repetitive), la elementele limbajului (anexa 2 la OMECTS 4800/2010). La sesiunea din iunie–iulie 2026, ultima cerință a primului exercițiu din Subiectul al II-lea a fost rescrierea unui algoritm cu altă structură repetitivă, de tip pentru…execută, punctată cu 6 puncte. Formatul descris este cel din 2026; potrivit proiectului de ordin pentru Bacalaureatul 2027, programa rămâne aceeași.

Pe programa școlară veche, structurile repetitive în C/C++ sau Pascal sunt la clasa a X-a (OMECI 5099/2009); pe programa nouă de clasa a IX-a, aceleași structuri se scriu în pseudocod și în Python (OMEC 6930/2025, anexa 42).

Greșeli frecvente

• Greșit: switch execută numai ramura al cărei case se potrivește, chiar fără break.
  Corect: fără break execuția continuă prin ramurile următoare.
• Greșit: break dintr-un ciclu imbricat oprește toate ciclurile.
  Corect: oprește numai ciclul interior în care apare.
• Greșit: un for (int i = 1; i <= 3; ++i) face patru iterații.
  Corect: face trei, pentru valorile 1, 2 și 3.
• Greșit: o buclă while execută obligatoriu corpul.
  Corect: poate să nu-l execute deloc.
• Greșit: do...while testează înaintea primei execuții.
  Corect: testează după corp.
• Greșit: break iese din toate buclele imbricate.
  Corect: iese din bucla cea mai apropiată.
• Greșit: condiția buclei se schimbă singură.
  Corect: dacă uiți cin >> x; din corpul buclei din exemplul 1, x rămâne mereu primul număr, iar bucla nu se mai oprește.
• Greșit: ; după for sau while nu schimbă nimic.
  Corect: for (i = 1; i <= n; i++); are corpul gol, iar instrucțiunea de dedesubt se execută o singură dată; la while (cond);, dacă condiția e adevărată, programul rămâne blocat.
• Greșit: până când x = 0 din pseudocod devine while (x == 0).
  Corect: devine while (x != 0), pentru că repetă … până când c se transcrie cu negația condiției.
• Greșit: for (i = 1; i < n; i++) se execută de $n$ ori.
  Corect: se execută de $n-1$ ori; < în loc de <= este o greșeală frecventă.
• Greșit: contorul poate fi modificat și în corpul unui for fără urmări.
  Corect: dacă schimbi i și în corp, numărul de treceri nu mai este cel la care te aștepți.
• Greșit: după for (i = 1; i <= n; i++), i este $n$.
  Corect: este $n+1$ (exemplul 5).

Înainte și după

Întrebări frecvente