PRELEGERE IX

PROGRAMAREA CALCULATOARELOR ŞI LIMBAJE DE PROGRAMARE

I. Instrucţiuni
Contextul de condiţii în care se realizează diverse prelucrări se descrie prin instrucţiuni.
Acestea permit înscrierea sau modificarea valorii unei variabile ca rezultat al unei
expresii, alegerea unei alternative dintre două sau mai multe pe baza unei condiţii,
execuţia repetată a unei instrucţiuni sau a unui grup de instrucţiuni cu valori diferite
pentru variabilele cu care se lucrează şi rezolvarea secvenţială a unui grup de instrucţiuni
care sînt tratate ca o instrucţiune de sine stătătoare. Instrucţiunile care formează modulul
unui program se parcurg secvenţial adică, în ordinea scrierii lor. Separarea lor se face prin
simbolul ;.
În limbajul C++ se pot utiliza următoarele categorii de instrucţiuni: vidă, de atribuire,
compusă, de selectare (if, switch), de repetare (for, while, do - while) şi de oprire
(continue, break, return).

1. Instrucţiunea vidă
Instrucţiunea care nu descrie nici o prelucrare poartă denumirea de instrucţiune vidă.
Apariţia ei este marcată de separatorul de instrucţiuni ;. Utilizarea ei este impusă de
situaţia în care sintaxa limbajului prevede o instrucţiune fără ca să fie necesară
executarea unei operaţii.
Blocul de instrucţiuni al primului program din secţiunea Cîteva exemple de
programe C++ este format doar din instrucţiunea vidă.
Programul 9.1.1 determină valorile variabilelor f şi g în situaţia cînd z este diferit
de zero. Dacă z este zero atunci, programul nu execută nici o operaţie, pe ramura
negativă a condiţiei fiind prevăzută instrucţiunea vidă. În asemenea situaţii de obicei se
indică un mesaj, cum ar fi de exemplu “f şi g nu au sens” sau pur şi simplu argumentul
else din instrucţiunea if se omite.
/* Instructiunea vida */
#include <stdio.h>
#include <conio.h>
void main(void)
{ float x, y, z, f, g; clrscr();
printf("\n Introduceti x, y, z :");
scanf("%f %f %f", &x, &y, &z);
if (z != 0) { f = (x*x + y*y)/z;
g = (x*x - y*y)/z; printf("\n f= %f g=%f", f, g); }
else ; ;
getch( ); }
Introduceti x y z : 3.5 25.7 3.
F=224.246674 g=-216.080017
Introduceti x y z : 3. 4. 0.
Programul 9.1.1

1
2 Instrucţiunea expresie
Majoritatea funcţiilor şi instrucţiunilor dintr-un modul de program pregătesc condiţiile în
care se execută instrucţiunile expresie din componenţa acestuia. Astfel, acestea
furnizează datele asupra cărora operează instrucţiunea expresie, tipăresc rezultatele
furnizate de instrucţiunea expresie sau pregătesc condiţiile de reluare în contexte de
rezolvare diferite a instrucţiunei expresie.
Sintaxa generală a instrucţiunii expresie este: expresie; .
Expresia poate fi un apel de funcţie sau o expresie de atribuire validă cu efect lateral.
Programul 9.2.1 cuprinde două instrucţiuni expresie simple prin care se
iniţializează variabilele i şi j, o instrucţiune expresie, cu efect lateral pentru k, prin care se
determină valorile lui bşi c şi două apeluri ale funcţiei printf. Pentru a accentua diferenţa
între instrucţiunea expresie şi expresia de atribuire, lista de ieşire a ultimei funcţii de
scriere cuprinde pe lîngă variabilele a, b, c şi o expresie de atribuire aritmetică prin care
se află valoarea variabilei d.
/* Instructiuni expresie */
#include <stdio.h>
#include <conio.h>
void main(void)
{ int i, j;
long k;
float a = 3.75;
double b, c, d;
clrscr();
i =170; j = 15;
b = c = 3*a*(k = i*i+j*j);
printf("\n i = %d j = %d k = %d", i, j, k);
printf("\n a = %f b = %lf \n c = %lf\
\n d = b/(3*a) = %lf", a, b, c, d = b/(3*a));
getch( ); }
i=170 j=15
k=29125
a=3.75 b=327656.250000
c=327656.250000
d=b/(3*a)=29125.000000
Programul 9.2.1

3. Instrucţiunea compusă
Instrucţiunea compusă este utilizată ori de cîte ori sînt necesare mai multe instrucţiuni în
locul în care sintaxa unei instrucţiuni permite utilizarea uneia singure. Instrucţiunea
compusă poartă denumirea şi de bloc.
Aceasta cuprinde în componenţă o secvenţă de instrucţiuni încadrată între acolade.
Separatorul de instrucţiuni este simbolul ;.
Opţional, secvenţa de instrucţiuni poate să conţină diverse declaraţii de tip şi de definiţii
de funcţii.

2
Secvenţa de instrucţiuni se execută secvenţial, adică în ordinea scrierii lor.
Formatul general al unei instrucţiuni compuse este:
{ [listă_declaraţii şi definiţii;]
instrucţiuni_1;
……………….
instrucţiuni_n;
}
Se recomandă ca acoladele să se alinieze către stînga faţă de grupul de declaraţii
şi de instrucţiuni şi să se scrie dacă este posibil din aceeaşi coloană. Dacă lista
instrucţiunilor componente este scurtă sau textul lor este restrîns atunci, se poate folosi o
singură linie de program.
Liniile de declarare a tipului şi definiţiile de funcţii, deşi preced în sintaxa de
descriere lista instrucţiunilor componente, acestea pot să apară oriunde în structura
instrucţiunii compuse. Domeniul de vizibilitate al identificatorilor vizaţi este limitat la
durata de execuţie a instrucţiunii compuse.
Cu condiţia n>1, instrucţiunea compusă poate să constituie partea de instrucţiuni
a modulului principal de program, corpul unei funcţii sau să intervină în structura
instrucţiunilor de salt şi de repetere.
Instrucţiunea compusă apare în două ipostaze în programul care urmează,
delimitează partea de declaraţii şi de instrucţiuni a modulului principal şi respectiv
fixează în instrucţiunea if declaraţiile şi acţiunile care se execută pe fiecare ramură în
parte.
Dacă a este mai mare sau egal decît b atunci, se calculează x, în caz contrar se
calculează y. Ultima parte a programului rezolvă problema prin intermediul operatorului
condiţional. Desigur, pentru aceeaşi pereche de date de test, rezultatele sînt egale, după
cum se observă în ultimele două linii ale fiecărei execuţii în tabelul dat.
/* Instructiunea compusa */
#include <stdio.h>
#include <conio.h>
void main(void)
{ float a, b;
printf("\n Introduceti a="); scanf("%f", &a);
printf(" Introduceti b="); scanf("%f", &b);
if (a>=b) { float x;
x = 3*a-b*b/5-7;
printf("\n Valoarea lui x este : %f",x); }
else
{ double y;
y = a*a*a/3+5*b+10;
printf("\n Valoarea lui y este : %lf",y); }
/* Rezolvarea cu ajutorul operatorului conditional */
(a>=b)? { float x;
x = 3*a-b*b/5-7;
printf("\n x = %f", 3*a-b*b/5-7); }:
{ float y;
y = a*a*a/3+5*b+10;

3
printf("\n y = %f", a*a*a/3+5*b+10); }
getch( );
}
Introduceti a = 6 Introduceti b = 5
Valoarea lui x este : 6.000000
X = 6.000000
Introduceti a = 3 Introduceti b = 7
Valoarea lui y este : 54.000000
Y = 54.000000
Programul 9.3.1

4 Instrucţiuni de selectare
Alegerea unei alternative dintre două sau mai multe alternative, pe baza unei decizii, se
realizează prin intermediul instrucţiunilor if sau switch.

a) Instrucţiunea if
Ca urmare a evaluării unei condiţii, instrucţiunea if permite selectarea unei variante de
rezolvare dintre două variante.
Dacă una din variante nu conţine nici o operaţie atunci sintaxa instrucţiunii if este:
if (expresie_logică) instrucţiune_1; sau
if (expresie_logică) instrucţiune_1; else ;; altfel
if (expresie_logică) instrucţiune_1; else instrucţiune_2;.
Rezolvarea instrucţiunii if se realizează astfel:
- se evaluează expresi logică. Valoarea ei este 0 sau 1;
- dacă valoare expresiei logice este 1, atunci se execută instrucţiune_1;
- dacă valoare expresiei logice este 0, atunci se transferă controlul execuţiei
programului la linia de program care îi succede lui if în prima situaţie sau se execută
instrucţiune_2 în cea de-a doua situaţie;
se continuă execuţia programului cu următoarea linie de program.
In cazurile în care variantele se descriu prin secvenţe de instrucţiuni atunci acestea
se transformă în instrucţiuni compuse prin utilizarea acoladelor.
Instrucţiunile componente pot fi la rîndul lor alte if-uri, existînd astfel posibilitatea
descrierii unor structuri alternative complexe şi imbricate, conform cerinţelor de
prelucrare ale utilizatorului.
În situaţia unor decizii complexe, cu selectarea unei variante la ultima decizie, se poate
folosi o construcţie sintactică de genul :
if (expresie_logică_1)
if (expresie_logică_2)
………………………
if (expresie_logică_n) instrucţiune_1; else instrucţiune_2;
unde, argumentul else se asociază implicit cu ultima expresie logică. Pentru a schimaba
modul de asociere se pot folosi acoladele. De exemplu, dacă în decizia a doua se
selectează varianta instrucţiune_1 pe ramura pozitivă atunci, structura de mai sus se
schimbă, după cum urmează: if (expresie_logică_1)
{ if (expresie_logică_2) instrucţiune_1; }
………………………

4
 if (expresie_logică_n) else instrucţiune_2;.
Dacă selectarea unei variante dintre două are loc după fiecare decizie atunci, construcţia
sintactică prin care se codifică structurile de decizie imbricate poate fi următoarea:
if (expresie_logică_1) instrucţiune_1_1; else
if (expresie_logică_2) instrucţiune_2_1; else
……………………………………………………………………
if (expresie_logică_n) instrucţiune_n_1; else instrucţiune_n_2;
sau
if (expresie_logică_1); else instrucţiune_1_1;
if (expresie_logică_2); else instrucţiune_2_1
……………………………………………………………………
if (expresie_logică_n) instrucţiune_n_1; else instrucţiune_n_2;
Astfel de situaţii intervin în probleme de clasificare.
Cu programul 9.4.1.1 se calculează, în trei moduri, valoarea maximă dintre trei numere
reale a, b şi c. Numerele se compară, două cîte două şi se reţine de fiecare dată valoarea
cea mai mare, prin intermediul instrucţiunii if, prin intermediul operatorului condiţional
sau printr-o combinaţie a lor. O linie comentariu precizează modul de lucru adoptat iar,
afişarea rezultatului este însoţită de un text lămuritor adecvat.
/* Instructiunea if */
#include <stdio.h>
#include <conio.h>
void main(void)
{ float a, b, c, maxim;
clrscr();
/* Rezolvarea cu instructiunea if */
printf("\n Introduceti a, b, c :");
scanf("%f %f %f", &a, &b, &c);
if (a>b) if (a>c) maxim = a;
else maxim = c;
else if (b>c) maxim = b;
else maxim = c;
printf("\n Valoarea maxima : %f este determinata cu if", maxim);
/* Rezolvarea cu if combinata cu operatorul conditional */
if (a>b)
maxim = (a>c)? a : c;
else maxim = (b>c)? b : c;
printf("\n Valoarea maxima: %f este determinata cu\
if combinata cu operatorul conditional", maxim);
getch( );
}
Introduceti a, ab, c : 2.35 4555.5 17.1
Valoarea maxima : 4555.500000 este determinata cu if
Valoarea maxima : 4555.500000 este determinata cu if
combinata cu operatorul conditional
Programul 9.4.1.1

5
b) Instrucţiunea switch
Instrucţiunea switch permite alegerea unei variante dintre mai multe variante pe baza
unui selector de tip întreg sau enumerare pentru care, altfel, ar trebui să se utilizeze un
şir nedeterminat de instrucţiuni if. Echivalent, această instrucţiune permite înlocuirea unei
construcţii cu if-uri în cascadă. Sintaxa generală a instrucţiunii switch este:
switch (expresie)
{ case constantă_1 : { instrucţiune_1_1;
………………….
instrucţiune_1_n1;
[break;]
}
……………………………………………….
case constantă_k : { instrucţiune_k_1;
…………….
instrucţiune_k_nk;
[break;]
}
[default : {
instrucţiune_m_1;
…………….
instrucţiune_m_nm;
[break;]
} }
Argumentele case şi default definesc variante posibile în prelucrările care urmează să le
facă utilizatorul. Instrucţiunea break; este opţională şi are ca efect terminarea forţată, în
acel punct, a instrucţiunii switch. Ultima variantă este, de asemenea, opţională şi se
execută în situaţia cînd valoarea selectorului nu se găseşte printre constantele specificate
în structura instrucţiunii switch. Poziţia ei este arbitrară în lista de selectori case.
Constantele situate după cuvîntul rezervat case fac parte din domeniul de valori al
selectorului. Ordinea lor este arbitrară, dar fiecare nu poate să apară decît o singură dată
în prefixul unei variante chiar în cazul variantelor identice.
Structura unei alternative este determinată de expresii, instrucţiuni vide, compuse,
de selectare de tip if şi de repetare. Acoladele care le încadrează pot fi omise.
Instrucţiunea switch se execută în mai multe etape, după cum urmează:
- se evaluează expresia situată după cuvîntul rezervat switch. Valoarea ei
defineşte selectorul;
- dacă valoarea selectorului coincide cu o constantă care prefixează una din
variante, atunci se execută varianta respectivă . Dacă instrucţiunea break absentează,
atunci se continuă execuţia programului cu lista de instrucţiuni a următoarei etichete case
pînă la întîlnirea unei instrucţiuni break sau terminarea blocului instrucţiunii switch;
- dacă valoarea selectorului diferă de constantele care etichetează variantele şi
există argumentul default în sintaxa lui switch, atunci se execută varianta plasată după
default şi apoi controlul execuţiei programului se transferă la instrucţiunea care îi succede
lui switch;

6
 - dacă valoarea selectorului diferă de constantele care prefixează variantele şi nu
există argumentul default în sintaxa lui switch, atunci se continuă execuţia programului
cu instrucţiunea care îi urmează lui switch. În această situaţie, instrucţiunea switch este
inefectivă.
Pentru variante egale, se specifică etichetele şi doar la ultima etichetă se precizează
componenţa variantei. De exemplu, în programul 9.4.2.1 variantele egale sînt prefixate
cu 2, 3 şi 4. Textul de răspuns este în funcţie de valoarea lui x.
/* Instructiunea switch */
#include <stdio.h>
#include <conio.h>
void main(void)
{ int x;
clrscr();
printf("\n Introduceti x = ");
scanf("%d", &x);
switch (x)
{ case 0 : printf("\n x este zero");
break;
case 1 : printf("\n x este unu");
break;
case 2 :
case 3 :
case 4 : printf("\n x este putin");
break;
default : printf("\n x este mult");
}
getch(); }
Introduceti x = 2 Introduceti x = 4 Introduceti x = 45
x este putin x este putin x este mult
Programul 9.4.2.1
Utilizarea instrucţiunii switch este des întîlnită în probleme de clasificare. O astfel de
problemă se rezolvă în programul 9.4.2.2, care determină pentru fiecare cifră zecimală
numărul de apariţii într-un număr oarecare n. După ultima cifră se tastează Ctrl+Z. Cele
10 componente ale tabloului unidimensional cifra se iniţializează cu zero prin
intermediul primului for. La întîlnirea unei cifre se incrementează componenta situată pe
poziţia dată de cifra respectivă prin cifra[n-'0']++; . Deoarece ‘0’ semnifică valoarea
codului ASCII în zecimal al lui zero, operaţia n -‘0’ este validă şi are ca rezultat chiar
cifra corespunzătoare caracterului n. Apariţiile pe clase de cifre sînt tipărite, în ordine, cu
ajutorul celui de al doilea for.
/* Instructiunea switch - problema clasificarii */
#include <stdio.h>
#include <conio.h>
void main(void)
{ int i, n, cifra[10];
clrscr();
for (i=0;i<10;++i)

7
 cifra[i]=0;
printf("\n Introduceti un numar n = ");
while((n=getchar())!=EOF)
switch (n)
{ case '0' :
case '1' :
case '2' :
case '3' :
case '4' :
case '5' :
case '6' :
case '7' :
case '8' :
case '9' : cifra[n-'0']++;
break;
}
for (i=0; i<10; i++)
printf("\n Cifra %d apare in numar de %d ori", i, cifra[i]);
getchar( ); }
Introduceti un numar n = 155690
Cifra 0 apare in numar de 1 ori Cifra 5 apare in numar de 2 ori
Cifra 1 apare in numar de 1 ori Cifra 6 apare in numar de 1 ori
Cifra 2 apare in numar de 0 ori Cifra 7 apare in numar de 0 ori
Cifra 3 apare in numar de 0 ori Cifra 8 apare in numar de 0 ori
Cifra 4 apare in numar de 0 ori Cifra 9 apare in numar de 1 ori
Programul 9.4.2.2
Alte exemple tipice referitoare la utilizarea instrucţiunii switch vor fi prezentate
după trecerea în revistă a instrucţiunii do – while şi a conceptului de funcţie. Acestea se
referă, mai ales, la alegerea unei opţiuni dintr-un meniu oarecare. În programul 3.7.2 sînt
descrise două meniuri, primul prezintă trei opţiuni pentru scrierea unei matrici, iar al
doilea două opţiuni cu privire la reluarea sau oprirea programului.

5 Instrucţiuni de repetare
Reluarea execuţiei unui grup de operaţii, de un numar finit de ori, cu valori diferite pentru
variabilele cu care se lucrează este, de fapt, structura de bază în componenţa diverşilor
algoritmi, calculatorul fiind instrumentul ideal pentru acest tip de lucrare. Am văzut în
primul capitol că trebuie să se prevadă obligatoriu o condiţie de ieşire din repetare pentru
siguranţa opririi procesului de iterare. Aceasta poate să preceadă sau să succeadă grupul
de operaţii în cazul structurilor repetitive cu un număr cunoscut de paşi (ciclurilor). Nu
are importanţă poziţia condiţiei de ieşire în situaţia structurilor repetitive cu un număr
variabil (necunoscut) de paşi. Structurile repetitive cu un număr variabil de paşi,
prevăzute cu o condiţie internă, se pot transforma, fie în structuri repetitive cu
precondiţie, fie cu postcondiţie.
În structura repetitivă cu un număr cunoscut (fix) de paşi, condiţia de ieşire este o
expresia relaţională, care exprimă verificarea atingerii limitei superioare de către
variabila care contorizează numărul de paşi executaţi în procesul de repetare, iar în

8
celelalte situaţii condiţia de ieşire este o expresie logică. Ambele tipuri de expresii sînt
cu rezultat întreg (0 sau 1).
Pentru simbolizarea procesării unei structuri repetitive se utililizează instrucţiunile
for, while sau do – while. Instrucţiunea for se recomandă în situaţia unei structuri
repetitive cu un număr cunoscut de paşi, deoarece permite, pe de o parte evidenţierea
imediată a elementelor care caracterizează contorul, a modului în care acestea se
modifică precum şi a blocului de instrucţiuni, iar pe de alta este mult mai succintă. Modul
particular de utilizare a ultimilor două instrucţiuni îl constituie problemele de meniu,
astfel nefiind necesară o relansare a programului pentru studierea diverselor variante de
aflare, de citire sau de scriere a unor informaţii. Structura repetitivă cu un număr variabil
de paşi poate relua afişarea opţiunilor din meniu şi efectuarea operaţiilor dorite pînă la
selectarea opţiunii de încheiere.
Bineînţeles, că nu există o demarcaţie netă în utilizarea instrucţiunilor de repetare.
Aceasta rămîne la latitudinea programatorului. În următoarele trei secţiuni problema
produsului a două matrice se tratează, fie numai cu acelaşi tip de instrucţiune de repetare,
fie combinînd, aleatoriu, cele trei instrucţiuni de repetare. Soluţiile date nu sînt unice.
Modalităţi diverse de scriere a unor programe sînt precizate la fiecare secţiune în parte, în
funcţie de specificul instrucţiunii de repetare avută în vedere.

a) Instrucţiunea for
Instrucţiunea for controlează execuţia repetată de un număr nedeterminat (fix, variabil,
finit sau infinit) de ori a unei instrucţiuni sau a unui bloc de instrucţiuni. În cele mai
multe cazuri, numărul de repetări se contorizează prin intermediul unei variabile de
control cu tipul întreg.
După cum se observă limbajul C extinde aria de reprezentare a instrucţiunei for. De
exemplu, în limbajul Pascal, şi nu numai, instrucţiunea for se utilizează doar în
codificarea structurilor de ciclare în care contorul variază crescător cu raţia 1 sau
descrescător cu raţia –1. Altfel, trebuie să se recurgă la instrucţiunile repeat şi while. Prin
ridicarea acestor restricţii, instrucţiunea for devine, aici, un mijloc eficace în programarea
oricărui tip de structură repetitivă. În plus în limbajul C++, instrucţiunea for permite, cu
ajutorul operatorului virgulă, realizarea unor iniţializări diferite de cele necesare pentru
controlul corect al procesului de repetare.
Formatul general al instrucţiunii for acceptat de limbajul C este următorul:
for (iniţializare_contor; condiţie_ieşire; actualizare_contor)
{ instrucţiune_1;
……………….
instrucţiune_n;
}
Dacă n = 1, atunci acoladele se pot omite. Cele trei argumente din prima linia pot
absenta, dar nu şi separatorii punct şi virgulă (;).
Părţile de iniţializare şi de actualizare sînt formate din expresii de atribuire
separate, opţional, de operatorul de secvenţiere. Orice instrucţiune validă poate să
intervină în blocul asociat structurii for.
Nu se semnalează mesaj de avertisment atunci cînd prima linie din structura for
se termină cu ;. Pur şi simplu, aceasta devine inefectivă, iar blocul de instrucţiuni
corespunzător este scos de sub acţiunea instrucţiunii for.

9
 Etapele care se parcurg în rezolvarea instucţiunii for sînt următoarele:
- se execută atribuirile din partea de iniţializare. Valorile obţinute trebuie să fie
compatibile din punct de vedere al atribuirii cu cele ale contorului sau ale altor parametri;
- se evaluează condiţia de ieşire. Dacă rezultatul ei este 1, atunci se execută
blocul de instrucţiuni într-un context precizat de valorile variabilelor cu care se lucrează
şi de atribuirile din partea de actualizare. Dacă rezultatul este 0, atunci se trece controlul
execuţiei programului la linia de program care îi succede instrucţiunii for;
- se continuă cu etapa a doua.
În concluzie, partea de iniţializare se rezolvă o singură dată la începutul
procesului de repetare, iar condiţia de ieşire şi atriburile din partea de actualizare îşi
modifică valorile la fiecare pas de repetare. Astfel, o serie de iniţializări impuse de
algoritmul de rezolvare al unei probleme pot fi făcute în partea de iniţializare prin
introducerea operatorului de secvenţiere (virgula).
Condiţia de ieşire poate fi una legată de variabila de control (de numărătorul de
paşi, de contor), situaţie în care aceasta poate avea, în plus, fără să i se modifice valoarea,
rolul de a fixa o serie de date care intervin în prelucrările vizate în blocul de instrucţiuni
sau poate fi o expresie logică, care asigură încheierea procesului de repetare. În primul
caz după terminarea normală a instrucţiunii for valoarea contorului se consideră a fi
nedefinită.
Absenţa condiţiei de ieşire presupune verificarea implicită a acesteia şi intrarea
instrucţiunii for într-o “buclă”, adică într-un ciclu cu un număr infinit de iteraţii. De
exemplu, mesajul “Absenţă condiţie de ieşire” va fi tipărit la nesfîrşit printr-o instrucţiune
for cu următoarea structură:
for ( i = 0; ; ++i)
printf(“\n Absenta conditie de iesire”);.
De asemenea, acelaşi efect se obţine cu următoarea sintaxă pentru instrucţiunea de
repetare for:
for ( ; ; )
printf(“\n Absenta conditie de iesire”);.
Observaţie. Ieşirea “forţată” din blocul lui for se realizează prin instrucţiunile
goto şi break, iar oprirea unui pas de iterare, cu derularea completă a procesului de
repetare, se obţine prin instrucţiunea continue. O intrare “din afară” în instrucţiunea for se
poate realiza cu goto prin linia de început a structurii for sau prin intermediul unei
instrucţiuni componente. În ultima situaţie, rezultatele pot fi afectate atunci cînd linia lui
for conţine o serie de iniţializări referitoare la acestea.
Precizările care au însoţit programele anterioare ce conţineau instrucţiunea for
erau sumare şi de suprafaţă. De aceea, în continuare se adaugă alte exemple în care
interpretările vor fi legate în mod special de modul de funcţionare al instrucţiunii for.
Programul următor calculează suma pătratelor şi produsul elementelor unui tablou
unidimensional de numere reale şi diferite de zero. Dimensiunea tabloului se introduce de
la tastatură şi trebuie să fie cel mult 30.
În prima linie din structura for se prevăd următoarele:
- valoarea cu care se iniţializează i este 0, adică se marchează primul pas în
procesul de iteraţie şi se fixează poziţia primului element din şirul x care se prelucrează la
acest moment;
- iniţializările s = 0 şi p = 1 prin utilizarea operatorului de secvenţiere;

10
 - condiţia de ieşire i<n, care îşi poate modifica valoarea la oricare pas de
repetare. Dacă valoarea obţinută este 1, atunci se trece la următorul pas de iterare. În caz
contrar, instrucţiunea for îşi încetează activitatea;
- ultima expresie este una de incrementare. Valoarea lui i creşte cu raţia 1 după
fiecare pas de repetare.
Blocul de instrucţiuni gestionat deinstrucţiunea for cuprinde citirea în clar a unui element
din tabloul x şi atribuirile prin care se află suma s şi produsul p. Efectiv, acest bloc va fi
reluat de n ori.
Datele de test şi rezultatele corespunzătoare se pot urmări în tabelul care succede
programul 9.5.1.1.
/* Instructiunea for */
#include <stdio.h>
#include <conio.h>
void main(void)
{ int i, n;
float s, p, x[30];
clrscr();
printf("\n Introduceti numarul elem. din sir : "); scanf("%d", &n);
printf("\n Introduceti numerele din sir :\n ");
for (i = 0, s = 0, p = 1; i < n; ++i)
{ printf(" x[%d]= ", i); scanf("%f", &x[i]);
s += x[i] * x[i]; p *= x[i];
}
printf("\n \n s= %f p= %f", s, p); }
Introduceti numarul elem. din sir : 7
Introduceti numerele din sir :
x[0]= 7.5 x[3]= 5.
x[1]= -13. x[4]= 2
x[2]= 114.7 x[5]= 33.3
x[6]= 4.1
s = 14536.83886 p = -152683491.000000
Programul 9.5.1.1
Numai în limbajul C++ linia lui for poate fi înlocuită cu una de genul:
for (nume_tip diverse_iniţializari; condiţie_ieşire; actualizare_contor), unde
partea de iniţializări va cuprinde şi pe cele privitoare la contorul cu care se controlează
blocul lui for. De asemenea, declaraţii de tip combinate cu diverse iniţializări pot fi
incluse atît în modulul main(), cît şi în blocurile instrucţiunilor de repetare şi, în
particular, în blocul instrucţiunii for. De exemplu în programul 3.5.1.2, i1 se declară cu
iniţializare în mod obişnuit, linia de declarare a lui i2 cuprinde atribuirea unei expresii
de tip corespunzător, iar i3 se declară în linia instrucţiunii for.
void main(void)
{ int i1 = 3;
int i2 = 7*i1 – 15;
for (int i3 = 0; i3 < 5; ++i3) i1 += i3;
printf(" i1 = %d ", i1);
/* i3 a fost definit in for-ul anterior */

11
 for ( i3 = 0; i3 < 5; ++i3)
i1 *= i3;
printf(" i1 = %d ", i1); }
Programul 9.5.1.2
Atunci cînd se doreşte optimizarea procesului de execuţie a structurii for se recomandă
memorarea variabilei de control într-un registru de memorie. În următoarea secvenţă de
instrucţiuni se include specificatorul register în linia de declaraţie a lui i:
void main(void)
{ register int i;
for (i = 0; i < 10; ++i)
printf(" i = %d ", i); }
Programul 9.5.1.3
În situaţia cînd blocul instrucţiunii for conţine alte for-uri este obligatoriu ca
identificatorii variabililor de control să fie diferiţi.
Tratarea tablourilor uni şi multidimensionale în operaţii de intrare/ieşire sau în
diverse prelucrări se face, de obicei, prin for-uri imbricate, care permit o codificare mult
mai compactă decît while sau do - while. Un exemplu, în acest sens, este prezentat în
programul 9.5.1.4.
În aflarea produsului a două matrice se parcurg următoarele etape:
- citirea matricei a;
- citirea matricei b;
- calcularea produsului c = a . b;
- afişarea matricei c. Fiecare etapă se codifică cu ajutorul a două sau trei
instrucţiuni for imbricate, în care se folosesc contorii i, j şi k. Pasul de variaţie al
contorilor este 1. Acoladele pentru delimitarea blocului unei instrucţiuni for se
recomandă numai în situaţiile strict necesare.
/* Instructiunea for - produsul a doua matrice */
#include <stdio.h>
#include <conio.h>
#define M 2
#define N 2
#define P 3
void main(void)
{ int i, j, k;
float a[M][N],b[N][P],c[M][P];
printf("\n Introduceti matricea a : \n");
for (i = 0; i < M; ++i)
for (j = 0; j < N; ++j)
{ printf("a( %d,%d)=", i, j); scanf("%f", &a[i][j]); }
printf("\n\n Introduceti matricea b : \n");
for (i = 0; i < N; ++i)
for (j = 0; j < P; ++j)
{ printf("b( %d,%d)=", i, j); scanf("%f", &b[i][j]); }
/* Se calculeaza matricea c */
printf("\n\n ");
for (i = 0; i < M; ++i)

12
 for (j = 0; j < P; ++j)
{ c[i][j] = 0;
for (k = 0; k < N; ++k) c[i][j] += a[i][k] * b[k][j]; }
printf("\n\n Matricea c : ");
for (i = 0; i < M; ++i)
for (j = 0;j < P; ++j) printf("\nc( %d,%d)=%6.2f", i, j, c[i][j]);
getch(); }
Introduceti matricea a : Introduceti matricea b:
a(0,0) = 3. b(0,0) = 1.4
a(0,1) = 4.5 b(0,1) = 17.5
a(1,0) = 7.2 b(0,2) = -2
a(1,1) =7.2 b(1,0) = 4.125
b(1,1) = .3
b(1,2) = 4.
Matricea c :
c(0,0) = 22.76 c(1,0) = 29.70
c(0,1) = 53.85 c(1,1) = 2.16
c(0,2) =12.00 c(1,2) = 28.80
Programul 3.5.1.4
O variantă parametrizată şi mai scurtă se obţine prin introducerea dimensiunilor
matricilor factor de la tastatura calculatorului, prin citirea în mod alternativ a acestora,
poziţie cu poziţie şi prin scrierea unui element din matricea c imediat ce a fost calculat.
/* Instructiunea for - produsul a doua matrice */
#include <stdio.h>
#include <conio.h>
#define M 10
#define N 20
#define P 30
void main(void)
{ int i, j, k;
float a[M][N],b[N][P],c[M][P];
clrscr();
printf("\n Introduceti dimensiunile (m, n si p) : ");
scanf("%d%d%d ", &m, &n, &p);
printf("\n Introduceti matricele a si b : ");
for (i = 0; i < M; ++i)
for (j = 0; j < N; ++j)
{ printf("a( %d,%d) si b( %d,%d ) : ", i, j, i, j);
scanf("%f%f ", &a[i][j], &b[i][j]); }
/* Se calculeaza si se scrie in clar matricea c */
printf("\n\n ");
for (i = 0; i < M; ++i)
for (j = 0; j < P; ++j)
{ c[i][j] = 0;
for (k = 0; k < N; ++k) c[i][j] += a[i][k] * b[k][j];
printf("\nc( %d,%d)=%6.2f", i, j, c[i][j]); }

13
 getch(); }
Programul 9.5.1.5
Desigur, pentru rezolvarea acestei probleme se pot scrie şi alte programe, astfel:
citirea elementelor matricilor a şi b să se facă în clar şi pe linii de ecran distincte,
iniţializarea cu zero a elementelor lui c să preceadă aflarea acesteia sau să se schimbe
forma de afişarea a rezultatului.
Nu putem încheia instrucţiunea for, fără să accentuăm faptul că aceasta este una
dintre cele mai des utilizate din lista instrucţunile de repetare de către creatorii de
software în scrierea unor programe scurte, modularizate, structurate, cu enunţuri
compacte şi imbricate.

14