LUCRAREA NR.

INSTRUCŢIUNI

4.1. Instrucţiuni etichetate (instrucţiunea goto)

Instrucţiunile etichetate posedă etichete ca prefixe şi au forma:

etichetă: instrucţiune

Eticheta formată dintr-un identificator defineşte identificatorul ca destinaţie pentru o instrucţiune

de salt, singura utilizare a sa fiind ca destinaţie a unei instrucţiuni goto. Etichetele nu pot fi redeclarate.
Etichetele sunt locale în corpul funcţiei în care sunt definite. Instrucţiunea goto are următorul format:

goto etichetă

La întâlnirea instrucţiunii goto, se realizează un salt la instrucţiunea prefixată de eticheta aflată după
instrucţiunea goto.

Exemplu: Următorul program utilizează instrucţiunea goto pentru a afişa numerele de la 1 la 100:
#include <stdio.h>
void main(void)
{
int nr=1;
eticheta: printf(”%d”, nr++);
if (nr<=100)
goto eticheta;
}

4.2. Instrucţiuni compuse

O instrucţiune compusă este o posibilă listă de declaraţii şi/sau instrucţiuni închise între
acolade. Exemplu:
{ a = b + 2; b++; }
O instrucţiune compusă se numeşte bloc. Un bloc ne permite să tratăm mai multe instrucţiuni ca
pe una singură. Corpul unei funcţii este o instrucţiune compusă.
Domeniul de vizibilitate al unui identificator declarat într-un bloc se întinde din punctul
declaraţiei până la sfârşitul blocului. Identificatorii utilizaţi într-un bloc pot fi ascunşi prin declaraţii de
acelaşi nume în blocurile interioare blocului iniţial.
Exemplu:
# include <stdio.h>
int x = 34; /* x este global */
void main(void) {
int *p = &x; /*p preia adresa variabilei globale*/
int x1, x2;
printf("x = %d\n", x);
{ int x; /*x este local si il ascunde pe cel global */
x = 1; /* atribuirea se face la cel local */
x1 = x;
printf("x = %d\n", x1);}
{ int x; /* se ascunde prima variabila locala */
x = 2; /* se atribuie valoarea 2 acestui x */
x2 = x;
printf("x = %d\n",x2); }
printf("x = %d %d %d \n",x,x1,x2); }

1
4.3. Instrucţiuni de selecţie

4.3.1. Instrucţiunea if

O instrucţiune if cu care în C se implementează o structură de control de selecţie sau o structură

alternativă, are următorul format general:
if (conditie) instructiune1;
else instructiune2;

unde conditie este orice expresie care prin evaluare conduce la o valoare întreagă. Dacă valoarea
expresiei este diferită de zero (condiţie adevărată), atunci se execută instructiune1; altfel, dacă valoarea
expresiei este zero (condiţie falsă), se execută instructiune2. În ambele cazuri, după executarea lui
instructiune1 sau instructiune2, controlul este transferat la instrucţiunea ce urmează după if. Aici, prin
instructiune1 sau instructiune2 se înţelege o instrucţiune simplă, o instrucţiune compusă (un bloc) sau
o instrucţiune vidă.

Exemplu: Următorul program citeşte două numere şi afişează pe cel mai mare dintre ele.
# include <stdio.h>
void main (void) {
int x, y;
printf("Introduceti doua numere intregi: \n");
scanf ("%d %d", &x, &y);
if (x > y)
printf ("Cel mai mare este : %d\n",x);
else
printf("Cel mai mare este : %d\n", y);
}

4.3.2. Instrucţiuni de selecţie multiplă: if - else if

Într-o instrucţiune if se poate include, pe o ramură, o altă instrucţiune if. În acest fel se creează
posibilitatea de a codifica structuri de selecţie multiplă, folosindu-se perechi else if. O asemenea
construcţie este de forma:
if (conditie1)
instructiune1;
else if (conditie2)
instructiune2;
else if (conditie3)
instructiune3;
. . . . . . . . . . . . . . . .
else if (conditieN)
instructiuneN;
else
instructiuneN+1;
În acest caz, condiţiile sunt testate în ordine. Dacă una din ele este adevărată, atunci este
executată instrucţiunea corespunzătoare, după care controlul este transferat la instrucţiunea următoare
din program. Codul pentru fiecare alternativă poate fi format dintr-o instrucţiune simplă (inclusiv
instrucţiunea vidă) sau dintr-un bloc delimitat prin { şi }. Dacă nici una dintre expresii nu este
adevărată, atunci se execută secvenţa corespunzătoare ultimei alternative introdusă prin else. Această
ultimă alternativă nu este obligatorie, structura putându-se încheia după secvenţa notată cu
instructiuneN.

2
Exemplu: Considerăm un program care realizează conversiile inch-cm şi cm-inch. Presupunem că
indicăm unitatea intrării cu i pentru inch şi c pentru centimetru:

# include <stdio.h>
# include <conio.h>
void main(void) {
const float fact = 2.54;
float x,in,cm;
char ch = 0;
printf ("\nIntroduceti numarul: \n");
scanf("%f",&x);
printf("\nIntroduceti unitatea: \n");
ch = getche(); /* se introduce un caracter de la
tastatura care se afiseaza pe ecran */
if (ch == 'i') {
in = x;
cm = x * fact;}
else if(ch == 'c') {
in = x/fact;
cm = x; }
else in = cm = 0;
printf("\n%5.2f in = %5.2f cm \n",in,cm); }

4.3.3. Instrucţiunea switch

Într-o instrucţiune de selecţie switch, se compară, pe rând, o valoare cu constantele dintr-o

mulţime şi în momentul găsirii unei coincidenţe se execută instrucţiunea sau blocul de instrucţiuni
asociate acelei constante. Forma generală a instrucţiunii switch este:
switch (variabila) {
case constanta1 :
secventa_instructiuni_1
break;
case constanta2 :
secventa_instructiuni_2
break;
case constanta3 :
secventa_instructiuni_3
break;
. . . . . . . . . . . . . . . . . . .
case constantaN :
secventa_instructiuni_N
break;
default :
secventa_instructiuni_N+1
}

Instrucţiunea switch realizează transferul controlului la una din secvenţele de instrucţiuni dacă
valoarea variabila ce trebuie să aibă tipul întreg coincide cu una din constantele de dupa case. Secvenţa
de instrucţiuni se execută pâna se întâlneşte break, după care se trece la instrucţiunea imediat
următoare după switch. Dacă nu se găseşte nici o coincidenţă, se execută secvenţa de instrucţiuni de
după default, iar dacă default lipseşte, deoarece prezenţa acesteia este opţională, se trece la
instrucţiunea următoare.

Exemplu: Decizia din exemplul anterior poate fi realizată şi astfel:

# include <stdio.h>
# include <conio.h>

3
 void main(void) {
const float fact = 2.54;
float x, in, cm;
char ch = 0;
printf ("\nIntroduceti numarul: \n");
scanf("%f", &x);
printf("\nIntroduceti unitatea: \n");
ch = getche();
switch(ch) {
case 'i': in = x;
cm = x * fact;
break;
case 'c': in = x/fact;
cm = x;
break;
default: in = cm = 0;
break; }
printf("\n%5.2f in = %5.2f cm \n",in,cm);
}
Observaţie: Constantele case trebuie sa fie distincte.
Pentru a ieşi din instrucţiunea switch se foloseşte instrucţiunea break.
Exemplu:

# include <stdio.h>
void main (void) {
int t;
for (t = 0; t < 10; t++)
switch (t) {
case 1 :
printf ("Now");
break;
case 2 :
printf (" is ");
break;
case 3 :
case 4 :
printf (" the ");
printf (" time for all good men \n");
break;
case 5 :
case 6 :
printf (" to ");
break;
case 7 :
case 8 :
case 9 :
printf (" . ");
break; } }

4.4. Instrucţiuni repetitive

4.4.1. Instrucţiunea for

Forma generală a instrucţiunii for este:

for (initializare; conditie; incrementare)
instructiune;
unde:
- initializare este o instrucţiune de atribuire utilizată pentru iniţializarea variabilei de control a
ciclului. Nu există nici o restricţie privitoare la tipul său;

4
 - condiţie este o expresie relaţională care se testează înaintea fiecărei iteraţii: dacă condiţia este
adevărată (diferită de 0), ciclul se continuă; dacă condiţia este falsă (egală cu 0), instrucţiunea for se
încheie;
- incrementare se evaluează după fiecare iteraţie specificând astfel reiniţializarea ciclului.
Exemplu: Următorul program afişează pe ecran numerele de la 1 la 100.
# include <stdio.h>
void main (void) {
int x;
for (x = 1; x <= 100; x++) printf("%d ", x);
}
Nu întotdeauna ciclul for trebuie să se desfăşoare în sensul creşterii variabilei de control. Putem
crea cicluri for în care variabila de control se decrementează.
Exemplu: Programul următor afişează numerele de la 100 la 1.
# include <stdio.h>
void main (void) {
int x;
for (x =100; x > 0; x--) printf("%d", x);
}
Nu există restricţii în incrementarea sau decrementarea variabilei de control a ciclului.
Exemplu: Următorul program afişează pe ecran numerele de la 0 la 100 din 5 în 5:
# include <stdio.h>
void main (void) {
int x;
for (x = 0; x <= 100; x = x + 5) printf ("%d", x);
}
Instructiunea instrucţiune din declaraţia ciclului for poate fi o instrucţiune simplă sau un bloc
(un grup de instrucţiuni delimitate de acolade) care va fi executat repetitiv.

Exemplu: Programul următor afişează pe ecran numerele de la 0 la 99, precum şi pătratul acestora:
# include <stdio.h>
void main (void) {
int i;
for (i = 0; i < 100; i++) {
printf (" Acesta este i : %3d", i);
printf (" si i patrat : %5d \n", i*i); } }

4.4.2. Instrucţiunea while

Forma generală a instrucţiunii repetitive while este:

while (conditie)
instructiune;

unde instructiune poate fi o instrucţiune vidă, o instrucţiune simplă sau un bloc de instrucţiuni ce vor fi
executate repetitiv. În timpul execuţiei se evaluează mai întâi condiţia buclei a cărei valoare trebuie să
fie întreagă. Dacă valoarea calculată este diferită de 0 (condiţie adevărată), atunci instructiune se
execută. Dacă, după o evaluare (inclusiv prima) rezultă o valoare 0 (condiţie falsă), atunci controlul
este transferat la instrucţiunea ce urmează după while. Astfel, instrucţiunea asociată cu while se
execută repetat, cât timp valoarea asociată condiţiei este diferită de 0 sau condiţia este adevărată.

5
Exemplu: Programul următor calculează c.m.m.d.c. pentru o pereche x, y de numere întregi pozitive.
# include <stdio.h>
void main (void) {
int xi, yi, x, y;
printf (" Introduceti doua numere pozitive: \n");
scanf ("%d %d", &xi, &yi);
x = xi; y = yi;
while (x != y)
if (x > y)
x -= y;
else
y -= x;
printf (" C.m.m.d.c. (%d, %d) = %d", xi, yi, x); }

Metoda de calcul se bazează pe faptul că:

♦ daca x > y, atunci cmmdc (x, y) = cmmdc (x-y, x);
♦ daca x < y, atunci cmmdc (x, y) = cmmdc (x, y-x);
♦ daca x = y, atunci cmmdc (x, y) = x =y .
De exemplu, cmmdc (14, 21) = 7.
Deoarece instrucţiunea while realizează testarea condiţiei la începutul instrucţiunii, aceasta
instrucţiune este bună de utilizat în situaţiile în care nu se doreşte execuţia buclei, evident dacă condiţia
nu este adevărată.

Exemplu: Programul următor realizează centrarea unui text pe ecran:

# include <stdio.h>
# include <ctype.h>
void main (void) {
char sir[255];
printf(" Introduceti un sir de caractere: \n");
gets (sir);
centreaza (strlen (sir));
printf (sir); }
/* Se calculează numărul de spaţii pentru centrarea unui şir de
caractere cu lungimea lung */
centreaza (lung)
int lung;
{ lung = (80 - lung)/2;
while (lung > 0) {
printf (" "); lung--; } }

4.4.3. Instrucţiunea do-while

Spre deosebire de ciclurile programate cu while sau for, unde condiţia de ciclare este verificată
la început, în cazul folosisii mecanismului do-while, condiţia se evaluează după execuţia secvenţei de
instrucţiuni ce reprezintă corpul ciclului. Forma generală a buclei do-while este:
do { instructiune;
} while (conditie);
Semantic, do-while este echivalentă cu secvenţa:
instructiune;
while (conditie)
instructiune;
Deşi acoladele nu sunt necesare când instructiune este o instrucţiune simplă, de obicei se
utilizează pentru a evita confuzia cu while. Se remarcă faptul că instructiune ce reprezintă corpul
ciclului (adică, o instrucţiune simplă, o instrucţiune compusă sau o instrucţiune vidă) este executată cel
puţin odată. Celelalte execuţii sunt condiţionate de valoarea întreagă rezultată din evaluarea condiţiei.
Dacă această valoare este 0 (condiţie falsă), atunci controlul se transferă la următoarea instrucţiune din
program; în caz contrar se execută corpul ciclului şi se reevaluează condiţia.

6
Exemplu: Următoarea secvenţă asigură preluarea corectă a unei valori întregi între 1 şi 10:
# include <stdio.h>
void main (void) {
int num;
do {
printf("\n\nIntrod. un intreg între 1 si 10: ");
scanf ("%d", &num);
printf (" Numarul introdus este : %d ", num);
} while (num < 1 || num > 10);
}
Un caz tipic de utilizare a instrucţiunii do-while este oferit de programele interactive în care
selecţia unei opţiuni se face pe baza unui meniu afişat pe ecranul terminalului.
Exemplu: Următorul program implementează o versiune a unui meniu de verificare a corectitudinii
ortografice într-un text:
# include <stdio.h>
# include <ctype.h>
void main (void) {
char ch;
printf ("1. Verificarea ortografiei \n ");
printf ("2. Corectarea erorilor de ortografie \n");
printf ("3. Afisarea erorilor de ortografie \n ");
do {
printf ("\n Introduceti optiunea dumneavoastra: ");
ch=getche(); // Se citeste optiunea de la tastatura
switch (ch) {
case '1':
verifica_ortografia();
break;
case '2':
corecteaza_erorile();
break;
case '3':
afiseaza_erorile();
break; }
} while (ch != '1' && ch != '2' && ch != '3'); }
După afişarea opţiunilor, programul va bucla până când se va selecta o opţiune validă.

4.4.4. Instrucţiunea break

Instrucţiunea break are două utilizări. Prima utilizare constă în terminarea unui case în cadrul
instrucţiunii switch. A doua utilizare constă în terminarea imediată a unui ciclu scurtcircuitând testul
condiţional normal al buclei. Dacă într-o buclă se întâlneşte o instrucţiune break, calculatorul termină
(părăseşte) imediat bucla şi controlul programului se transferă la instrucţiunea ce urmează instrucţiunii
de buclare. De exemplu, programul:
# include <stdio.h>
void main (void)
{ int t;
for (t = 0; t < 100; t++) {
printf (" %3d ", t);
if (t == 10) break; }}

tipăreşte numerele până la 10 şi atunci se opreşte deoarece break determină ieşirea imediată din ciclu.

7
4.4.5. Instrucţiunea continue

Instrucţiunea continue, executată într-un ciclu, determină oprirea iteraţiei curente şi asigură
trecerea imediată la iteraţia următoare. De exemplu, programul următor va afişa pe ecran numai
numerele pare.
# include <stdio.h>
void main (void)
{ int x;
for (x = 0; t < 100; x++) {
if (x % 2) continue;
printf (" %d ", x); }
}
Se observă că atunci când se generează un număr impar se execută instrucţiunea continue ce va
determina trecerea la iteraţia următoare by-pasând instrucţiunea printf().
În cazul instrucţiunilor while şi do-while, o instrucţiune continue determină trecerea direct la
testul condiţional şi prin urmare, continuarea procesului de buclare. În cazul unui for, se realizează mai
întâi operaţia de incrementare a variabilei de control a ciclului, apoi testarea condiţiei de continuare a
buclei.

TEME:

1. Să se realizeze un program pentru calculul lui n!.

2. Să se realizeze un program care citeşte de la tastatură un număr între 1 şi 12 şi afişează numele
lunii respective şi numărul de zile ale lunii respective.
3. Dându-se trei numere întregi reprezentând o dată sub forma an, lună, zi să se scrie un program
ce stabileşte a câta zi din an este ziua respectivă. Să se modifice apoi programul scris astfel
încât dacă se cunoaşte a câta zi din săptămână este prima zi din anul respectiv, să se determine a
câta zi din săptămână este ziua corespunzătoare datei respective.
4. Dându-se două numere întregi reprezentând un număr de an şi un număr de ordine al unei zile
din anul respectiv să se scrie un proigram care determină data corespunzătoare zilei respective
sub forma an, lună, zi.
5. De pe mediul de intrare se citesc coordonatele a trei puncte din plan: (x1, y1), (x2, y2), (x3, y3).
B B B B B B B B B B B B

Să se verifice dacă acestea pot forma un triunghi şi în caz afirmativ să se calculeze suprafaţa
acestui triunghi şi natura sa: isoscel, echilateral, dreptunghic, oarecare.
6. Să se calculeze valoarea lui π din următoarea dezvoltare:

π 1 1 1
= 1− + − + ....
4 3 5 7
luându-se în considerare n termeni.
7. Să se scrie un program care, primind un unghi x şi o precizie EPS>0, calculează valoarea sin(x)
cu o precizie EPS folosind dezvoltarea în serie:

x x3 x5
sin( x) = − + − ...
1! 3! 3!
8. Să se calculeze ex cu o precizie EPS dată, ştiind că:
P P

x x2 x3
e x = 1+ + + + ...
1! 2! 3!