41

Instrucţiuni de ciclare

Un program încărcat în calculator şi lansat în execuţie devine o maşină de

procesat informaţie. După pornire, ne aşteptăm să funcţioneze continuu, până ce îi
dăm comanda de oprire sau până se opreşte singură, ca urmare a unei situaţii
întâlnite în funcţionare (terminare date de prelucrat sau incident tehnic).
Pentru a asigura un astfel de comportament, programele de calculator conţin
cicluri. Un ciclu are un corp format din instrucţiunile care vor fi executate repetat.
Pentru descrierea ciclurilor, în limbajele actuale se folosesc instrucţiunile
while, do şi for.

Instrucţiunea while

Instrucţiunea while permite realizarea unei structuri repetitive (ciclu)

condiţionate anterior. Corpul ciclului poate fi executat o dată, de mai multe ori sau de
loc.
Exemplu fundamental:

#include <iostream>
using namespace std;

void main()
{
int contor = 1;
while ( contor <= 3 )
{
cout << "Contor = " << contor << endl;
contor = contor + 1;
}
cout << "La revedere." << endl;
}

Instrucţiunea contor = contor + 1 realizează incrementarea variabilei contor.

Dacă încercaţi să parcurgeţi programul pas cu pas pentru a vedea ce realizează, în
acest pas calculaţi expresia din dreapta egalului (contor + 1) folosind valoarea
cunoscută a variabilei contor şi apoi înregistraţi rezultatul tot în variabila contor.
 42

Funcţionarea programului:
1. contor primeşte valoarea 1
2. condiţia contor < =3 este evaluată ca adevărată;
3. deoarece condiţia este adevarată, se execută corpul ciclului:
a. Valoarea curentă a contorului este afişată: Contor = 1;
b. contorul este incrementat, contor devine 2
4. condiţia contor < =3 este evaluată ca adevărată;
5. deoarece condiţia este adevarată, se execută corpul ciclului:
a. Valoarea curentă a contorului este afişată: Contor = 2;
b. contorul este incrementat, contor devine 3
6. condiţia contor < =3 este evaluată ca adevărată;
7. deoarece condiţia este adevarată, se execută corpul ciclului:
a. Valoarea curentă a contorului este afişată: Contor = 3;
b. contorul este incrementat, contor devine 4
8. condiţia contor < =3 este evaluată ca falsă;
9. deoarece condiţia este falsă, se sare peste corpul ciclului;
10. se afişează "La revedere."

Sintaxa instrucţiunii while este:

while ( condiţie )
instrucţiune

Condiţia este de obicei o expresie logică. În C şi în limbajele derivate din

acesta, condiţia poate fi şi o expresie aritmetică, existând convenţia ca o valoare 0 a
acesteia să fie considerată fals şi o valoare diferită de 0, adevărat.

Sintaxa instrucţiunii while

while ( condiţie ) while ( condiţie )

instrucţiune; {
una sau m. m.instrucţiuni
}
 43

Programarea unui ciclu while necesită de obicei atenţie din partea

programatorului în 3 momente:
1. La iniţializarea variabilelor folosite în ciclu;
2. La scrierea condiţiei de oprire a repetării corpului ciclului;
3. La modificarea în corpul ciclului a variabilei (variabilelor) folosite în
testul de reluare a repetării.

Pentru a verifica dacă un ciclu while este corect scris, verificaţi valorile iniţiale
al variabilelor care intervin în ciclu, verificaţi dacă reluarea ciclului este întreruptă
după prelucrarea ultimei valori şi verificaţi ce schimbări de variabile se produc la
fiecare repetare a ciclului.

Controlul ciclului poate fi realizat prin metodele următoare:

1. Printr-o variabilă având rol de contor (numărător) ca în exemplul dat
mai sus,
2. Prin intermediul unei variabile de tip fanion, care primeşte valoare în
interiorul ciclului şi care poate întrerupe imediat reluarea acestuia,
3. Printr-o variabilă care se calculează în ciclu şi ale cărei valori
converg spre o valoare limită, inclusă în expresia logică a
instrucţiunii sau
4. Prin includerea în condiţia testată a apelului unei funcţii care poate
returna 0 (fals) sau 1 (adevărat). De exemplu funcţia eof() sau
good() apelate în cazul prelucrării datelor dintr-un fişier de intrare.

Exemple:
1. Calculul factorialului unui număr n
Definiţia valorii n! poate fi scrisă astfel:
n! = n * (n-1) * (n-2) * (n-3) * . . . 4 * 3 * 2 * 1
De exemplu:

6! = 6 * 5 * 4 * 3 * 2 * 1 = 720
Numărul n trebuie să fie pozitiv. Prin convenţie 0! = 1.
#include <iostream>
using namespace std;
void main()
 44

{
long n, fact = 1;
cout << "Introduceti n: ";
cin >> n;
if ( n>= 0 )
{
while ( n > 1 )
{
fact = fact * n;
n = n - 1;
}
cout << "n! = " << fact << endl;
}
else
cout << "n trebuie sa fie >= 0." << endl;
}

2. Când un corp cade, viteza sa creşte continuu. Distanţa dintre o cărămidă şi

punctul de unde a fost lăsată să cadă este dată de relaţia:
1
d= g ⋅t2
2
unde t este numărul de secunde trecut de când a fost lăsată să cadă şi g este
acceleraţia gravitaţională (9.81 m/s2).
Scrieţi un program care afişează într-un tabel timpul t şi
distanţa parcursă. Afişarea se va întrerupe când distanţa parcursă
este > 500 m.
...
g = 9.81;
t = 0;
d = 0;
while (d <= 500)
{
cout << t << " " << d << endl;
t = t + 1;
d = (g * t * t ) / 2.;
}

...
Atenţie la scrierea formulei. Dacă scrieţi (1 / 2) * g *t * t s-ar putea să realizaţi
un ciclu infinit deoarece (1 / 2) calculat în mulţimea numerelor întregi este 0!

3. Scrieţi un program care adună numere întregi introduse de la tastatură.

Încheierea seriei de valori se indică prin introducerea unei valori 0.

...
 45

long v, suma;
suma = 0;
cout << "Introduceti o valoare intreaga : ";
cin >> v;
while (v != 0)
{
suma = suma + v;
cout << "Introduceti inca o valoare sau 0 pentru a incheia : ";
cin >> v;
}
cout << "Suma valorilor introduse este : " << suma << endl;
...

Cicluri suprapuse
Uneori realizarea corpului unui ciclu implică scrierea unui bloc de instrucţiuni
care la rândul lui conţine cicluri. Astfel de structuri de cod sunt denumite cu cicluri
suprapuse. Exemplu:
Scrieţi un program care afişează pe ecran un şir de m caractere '*'. Modificaţi
programul astfel încât să afişeze n linii conţinând fiecare m caractere '*'.
#include <iostream>
using namespace std;
void main()
{
int m, j;
cout << "Introduceţi nr. de caractere de pe linie : ";
cin >> m;
j = 0;
while (j < m)
{
cout << "*";
j = j + 1;
}
cout << endl;
}

#include <iostream>
using namespace std;
void main()
{
int m, n, i, j;

cout << "Introduceţi nr. de linii : ";

cin >> n;
cout << "Introduceţi nr. de caractere de pe linie : ";
cin >> m;

i = 0; // initializari pt. ciclul exterior

while (i < n)
{
j = 0; // initializari pentru ciclul interior
while (j < m)
 46

{
cout << "*";
j = j + 1;
}
cout << endl;
i = i + 1;
}
}

Pentru scrierea ciclurilor suprapuse, se poate începe cu scrierea ciclului

interior, care se execută cel mai frecvent. Dacă acesta funcţionează corect, se poate
cuprinde ciclul interior împreună cu iniţializările sale în ciclul exterior.

Instrucţiunea do

Pentru programarea unui ciclu poate fi folosită întotdeauna instrucţiunea while.

Deoarece while începe prin executarea unui test, în cazul în care variabila testată
primeşte valoarea în interiorul ciclului, programatorul trebuie să-i dea la început o
valoare convenabilă pentru a determina intrarea în ciclu. Exacutarea acestuia va
corecta automat valoarea iniţială.
Pentru astfel de cazuri există însă şi o cale mai simplă, respectiv folosirea
instrucţiunii do.

Exemplu fundamental:

char rasp;
double x;

do
{
cout << “Introduceti x (grade) : “;
cin >> x;
cout << “sin(x) = “ << sin(3.14159 * x / 180.) << endl;
cout << “Mai continuati? (d/n) “;
cin >> rasp;
}
while ( rasp == 'd');

Secvenţa de program calculează valoarea funcţiei sinus pentru un şir de valori

introduse de la tastatură. După fiecare valoare se cere confirmarea operatorului
privind continuarea calculului. Dacă răspunsul acestuia este 'd', ciclul se reia şi se
poate introduce o nouă valoare pentru x.
 47

Evident în acest caz programul trebuie să realizeze cel puţin un calcul (altfel
nu ar avea rost să lanseze în execuţie programul). Variabila care determină reluarea
sau oprirea ciclului nu are o valoare definită la prima intrare în ciclu, dar în interiorul
acestuia este iniţializată.
Dacă s-ar folosi tot while, secvenţa de cod scrisă ar trebui corectată astfel:

char rasp;
double x;

rasp = 'd';
while ( rasp == 'd')
{
cout << “Introduceti x (grade) : “;
cin >> x;
cout << “sin(x) = “ << sin(3.14159 * x / 180.) << endl;
cout << “Mai continuati? (d/n) “;
cin >> rasp;
}

Observaţie: Pentru a se putea răspunde la întrebarea "Mai continuaţi? " cu 'd'

sau 'D', în astfel de situaţii se converteşte caracterul citit în majusculă şi se compară
sistematic cu 'D'. Programul scris, în forma sa finală este următorul:

#include <iostream>
#include <math.h>
#include <ctype.h>
using namespace std;
void main()
{
char rasp;
double x;

do
{
cout << "Introduceti x (grade) : ";
cin >> x;
cout << "sin(x) = " << sin(3.14159 * x / 180.) << endl;
cout << "Mai continuati? (d/n) ";
cin >> rasp;
}
while ( toupper(rasp) == 'D');
}

Directiva #include <math.h> este necesară pentru a putea folosi funcţia

matematică sin(x) iar directiva #include <ctype.h> a fost adăugată pentru a putea
folosi funcţia toupper().
 48

Instrucţiunea for

Instrucţiunea for este preferată ori de câte ori trebuie să realizăm un ciclu care
foloseşte un contor. Ea poate fi însă folosită însă în toate cazurile în care trebuie să
realizăm un ciclu, şi reprezintă o modalitate compactă şi elegantă de scriere a
acestora.

Exemplu:

Scriere cu for Scriere cu while

for (contor = 0; contor < 10; contor++) contor = 0;

{ while (contor < 10)
cout << “Contor = “ << contor << endl; {
} cout << “Contor = “ << contor << endl;
contor++;
}

În exemplul dat, scrierea cu for este mai compactă. Toate cele trei elemente
care intervin în definirea unui ciclu care foloseşte un contor:
1. iniţializarea contorului (contor = 0),
2. verificarea condiţiei de reluare (contor < 10) şi
3. incrementarea contorului înaintea unei noi reluări (contor++),
sunt plasate în acelaşi loc, fiind mai uşor de controlat şi de verificat. Astfel frecventa
eroare cauzată de omiterea incrementării valorii contorului la sfârşitul ciclului nu mai
poate apărea.
Dacă înaintea unui ciclu trebuie realizate mai multe iniţializări, acestea pot
scrise în for una după alta, despărţite prin virgule:

long sum;

for (int i = 0, sum = 0; i <10; i++ )

{
sum = sum + a[i];
}
cout << "Suma elementelor sirului a este : " << sum << endl;
 49

Oricare dintre cele trei părţi ale instrucţiunii for pot lipsi. Lipsa condiţiei de
reluare este echivalentă cu a scrie o condiţie care este întotdeauna adevărată.
Ieşirea dintr-un astfel de ciclu se poate face folosind instrucţiunea break.
Exemplu:
for ( ; ; )
{
cout << "Introduceti x (grade) : ";
cin >> x;
cout << "sin(x) = " << sin(3.14159 * x / 180.) << endl;
cout << "Mai continuati? (d/n) ";
cin >> rasp;
if (toupper(rasp) != 'D')
break;
}
Executarea instrucţiunii break provoacă o ieşire imediată din ciclul for. Ea
poate fi folosită şi pentru a ieşi din ciclurile while sau do.