Structura secvențială

O secvență de instrucțiuni este o înșiruire de pași executați în ordinea scrisă. Când pregătești un ceai, întâi pui apă, apoi o încălzești, apoi pui pliculețul. Dacă schimbi ordinea, nu obții același rezultat. La fel se întâmplă într-un algoritm.

Într-o secvență putem atribui valori unor variabile. Atribuirea „total primește 0” pregătește o variabilă. Apoi „total primește total + 3” citește valoarea veche, adună 3 și o înlocuiește. După încă o instrucțiune „total primește total + 4”, variabila are valoarea 7. Poți scrie urmărirea: la început 0; după primul pas 3; după al doilea 7.

Ordinea contează și când se citesc sau se afișează date. Dacă trebuie să aduni două numere, le citești înainte de calcul și afișezi suma după calcul. Pentru intrările 3 și 4, o secvență corectă este: citește cele două numere; calculează $3+4=7$; afișează 7. O afișare înaintea calculului nu poate arăta suma nouă.

Ca să verifici o secvență, desenează un mic tabel: pe fiecare rând scrii instrucțiunea, iar lângă ea valorile variabilelor după executare. Nu sări peste pașii care par ușori. O variabilă poate fi schimbată de mai multe ori, iar la pasul următor se folosește valoarea ei cea mai recentă. Această urmărire este utilă chiar înainte să scrii un program.

Exemplu rezolvat — portofelul Ioanei. Ioana are 10 lei. Cheltuiește 4 lei pe o înghețată, apoi primește 6 lei de la bunica. Câți lei are la sfârșit? Răspunsul se află executând instrucțiunile în ordinea dată:

1. Pornești cu sold primește 10.
2. Ioana cheltuiește 4 lei: sold primește sold − 4, adică $10-4=6$.
3. Ioana primește 6 lei: sold primește sold + 6, adică $6+6=12$.
4. Comunici valoarea finală: 12 lei.

Dacă ai inversa pașii 2 și 3, soldul ar trece prin alte valori (16, apoi 12) și ar ajunge tot la 12, dar nu orice secvență se poate rearanja așa. Dacă ar fi existat și o instrucțiune „cumpără jucăria de 14 lei”, ordinea ar fi hotărât dacă Ioana avea destui bani în acel moment.

Structura secvențială execută instrucțiunile una după alta, în ordinea scrierii, fără salturi și fără alegeri. Cele mai frecvente instrucțiuni dintr-o secvență sunt: declararea unei variabile, citirea (cin >> a;), atribuirea (s = a + b;) și scrierea (cout << s;). Atribuirea evaluează partea dreaptă folosind starea curentă a variabilelor, apoi modifică variabila din stânga; fiecare instrucțiune vede deci modificările făcute de cele dinaintea ei. O valoare care nu a fost încă atribuită nu poate fi folosită.

Exemplul 1 — totalul în două etape. Variabila total pornește de la 0 și primește pe rând 3 și 4.

#include <iostream>
using namespace std;
int main() {
    int total = 0;
    total = total + 3;
    total = total + 4;
    cout << total;
    return 0;
}

Stările succesive sunt total = 0, total = 3, total = 7; ieșirea este 7.

Exemplul 2 — secunde în ore, minute și secunde. Se citește durata $s=3725$ de secunde. Calculele depind unele de altele, deci ordinea contează: întâi orele, apoi restul de secunde, din el minutele, apoi secundele rămase.

1. $h=3725/3600=1$ (câtul întreg).
2. $r=3725\mathrm{mod}3600=125$ secunde rămase.
3. $m=125/60=2$ minute.
4. $sec=125\mathrm{mod}60=5$ secunde.

#include <iostream>
using namespace std;
int main() {
    int s = 3725;
    int h = s / 3600;
    int r = s % 3600;
    int m = r / 60;
    int sec = r % 60;
    cout << h << ' ' << m << ' ' << sec;
    return 0;
}

Programul afișează 1 2 5: 3725 secunde înseamnă o oră, două minute și cinci secunde. Dacă m ar fi fost calculat înainte de r, instrucțiunea ar fi folosit o variabilă fără valoare și rezultatul ar fi fost nedefinit.

Interschimbarea cu o variabilă ajutătoare. Pentru a schimba valorile lui a și b folosești aux = a; a = b; b = aux;. Cu a = 2 și b = 3 stările sunt: aux = 2, a = 3, b = 2. Dacă ordinea ar fi a = b; b = a;, ambele ar ajunge 3, pentru că a primește valoarea lui b înainte ca vechea ei valoare să fie salvată.

Exemplul 3 — ordinea contează. Secvența s = 5; t = 1; s = s - t; t = s + t; dă s = 4 și t = 5. Dacă cele două atribuiri finale ar fi scrise invers, t = s + t; s = s - t;, ar rezulta t = 6 și s = -1. Instrucțiunile sunt aceleași, dar valorile finale diferă, pentru că a doua atribuire folosește valoarea lui s modificată de prima. Pentru a verifica o secvență, completezi un tabel cu un rând pe instrucțiune și o coloană pe variabilă.

O secvență nu alege și nu repetă; pentru acestea se folosesc structurile alternativă și repetitivă, în care instrucțiunile de mai sus apar ca blocuri.

Exemplul 4 — cifrele unui număr de trei cifre. Pentru $n=472$ se calculează pe rând c1 = n / 100 (4), c2 = n / 10 % 10 (47 % 10 = 7) și c3 = n % 10 (2). Numărul cu cifrele inversate este c3 * 100 + c2 * 10 + c1, adică $2\cdot 100+7\cdot 10+4=274$. Tabelul stărilor, după fiecare instrucțiune: c1 = 4; c1 = 4, c2 = 7; c1 = 4, c2 = 7, c3 = 2; inv = 274. Instrucțiunile pentru c1, c2 și c3 sunt independente una de alta, deci ordinea lor poate fi schimbată; calculul lui inv trebuie însă scris după ele, pentru că folosește valorile lor.

Exemplul 5 — media a două numere întregi. Pentru citirile $a=7$ și $b=8$, instrucțiunea m = (a + b) / 2; cu m de tip int dă 7, pentru că suma 15 se împarte întreg la 2. Cu double m = (a + b) / 2.0; rezultatul este 7,5. Parantezele sunt necesare: a + b / 2 ar da $7+4=11$, deoarece împărțirea se face înaintea adunării. Alegerea tipului și a parantezelor face parte din urmărirea secvenței, nu un detaliu de scriere. La fel, suma a două valori mari, de pildă 2 000 000 000 + 2 000 000 000, depășește domeniul tipului int, iar rezultatul nu mai este cel scris pe hârtie.

La pseudocod, urmărește instrucțiunile în ordinea efectivă. Atribuirea se scrie cu săgeată: $a\leftarrow a+b$. Fiecare instrucțiune folosește valorile existente în acel moment, nu cele inițiale. O interschimbare fără variabilă ajutătoare folosește trei atribuiri aritmetice și este un subiect clasic de examen: dacă $a=2$ și $b=3$, instrucțiunile $a\leftarrow a+b$, $b\leftarrow a-b$, $a\leftarrow a-b$ dau pe rând $a=5$, $b=2$, $a=3$.

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

int a = 2, b = 3;
a = a + b;
b = a - b;
a = a - b;
cout << a << ' ' << b;

• a) 5 2
• b) 2 3
• c) 3 2
• d) 3 5

Răspunsul corect este c). După a = a + b avem $a=5$, $b=3$. După b = a - b avem $b=5-3=2$, iar $a$ rămâne 5. După a = a - b avem $a=5-2=3$. Se afișează 3 2: valorile s-au interschimbat. Varianta a) este starea de după a doua instrucțiune, iar varianta b) ar însemna că secvența nu a schimbat nimic. Interschimbarea aritmetică nu funcționează la tipurile al căror rezultat depășește domeniul, de pildă dacă $a+b$ nu încape în int; interschimbarea cu variabilă ajutătoare nu are această limită. Dacă instrucțiunile conțin și citiri, valorile citite se notează în tabel la momentul în care sunt citite, nu la început.

Al doilea exemplu: permutare circulară. Fie a = 1, b = 2, c = 3. După aux = a; a = b; b = c; c = aux; urmărirea dă aux = 1; a = 2; b = 3; c = 1. Se afișează 2 3 1. Dacă aux = a ar fi scris după a = b, în aux ar ajunge valoarea 2, iar valoarea inițială 1 s-ar pierde.

Alt exemplu: urmărire cu restul. Ce se afișează pentru secvența int x = 17, y = 5; x = x % y; y = y + x; x = y - x; cout << x << ' ' << y;? Pe rând: x = 17 % 5 = 2; y = 5 + 2 = 7; x = 7 - 2 = 5. Se afișează 5 7. A treia instrucțiune folosește noul y (7) și noul x (2), nu valorile inițiale.

Greșeli frecvente

• Greșit: atribuirea schimbă variabila din dreapta.
  Corect: partea dreaptă se evaluează, apoi se actualizează variabila din stânga.
• Greșit: toate instrucțiunile folosesc valorile inițiale ale variabilelor.
  Corect: fiecare instrucțiune vede modificările făcute anterior.
• Greșit: ieșirea poate fi calculată după afișare fără schimbarea rezultatului.
  Corect: afișarea arată starea din momentul executării ei.

Înainte și după