Instructiuni

Instrucţiune = şir de cuvinte cheie cu sintaxa corespunzătoare sau de

expresii evaluabile terminat cu punct şi virgulă ;

Sintaxa: cuvinte cheie sau/şi expresii ;

Exemplu:

int a = 5;
a += 10;
int b;
b = a + 100;
Instructiuni
Instrucţiune compusă (bloc de instrucţiuni) = succesiune de instrucţiuni
incluse între acolade { }.
 poate contine (oriunde in bloc) declaratii/definitii
variabile locale (ce vor exista numai în interiorul acelui
bloc)

Sintaxa: { [lista declaraţii variabile locale ]

instrucţiune_1
. . . . . . . . . . . . . . .
instrucţiune_n
[ lista declaraţii variabile locale ]
instrucţiune_m
. . . . . . . . . . .
}
Observatie: Blocul de instrucţiuni se foloseşte acolo unde sintaxa
limbajului aşteptă o singură instrucţiune, iar utilizatorul
doreşte să folosească mai multe
Instructiuni

Instrucţiunea goto

 Instructiune de salt neconditionat = se intrerupe executarea

secventiala (la rand) a instructiunilor si se trece direct,
fara alta conditie, la executarea instructiunii precedata de
eticheta.

Sintaxa: goto etichetă;

. . . . . . . . . . .
etichetă: instrucţiune

Observatie: Instrucţiunea goto trebuie evitată, pe cât este posibil,

deoarece prin salturile pe care le introduce face ca urmărirea
şi depanarea unui program să se facă mai greu
Instructiuni

Instrucţiunea vida ;

 nu are nici un efect.

 se foloseste în cazul în care sintaxa cere o instrucţiune,
iar utilizatorul nu doreşte să folosească una.
Instructiuni

Instrucţiuni de decizie

 Folosite pentru ramificarea caii de executie a

programului în funcție de anumite condiții.
Instrucțiuni. Instrucțiuni de decizie
Instrucţiunea if

Sintaxa: if (expresie)
instrucţiune_1[compusă]
else
instrucţiune_2[compusă]

Efect: dacă expresie este adevărată atunci

execută instrucţiune_1
altfel
execută instrucţiune_2
Instrucțiuni. Instrucțiuni de decizie
Instrucţiunea if

expresie trebuie sa ofere ca rezultat o valoare logică, în caz contrar

acesta este convertit la o valoare logica cu regula cunoscuta (0 = false)

Exemplu 1:

float a, b;
cin>>a>>b;
if (b==0) // conditia b este un numar real
cout<<"Numitor zero";
else
cout<<"Rez=”<<a/b<<endl;
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea if

Exemplu 2:

char a;
cin>>a;
if (a>='a' && a<='z')
cout<<a<<" este litera mica"<<endl;
else if (a>='A' && a<='Z')
cout<<a<<" este majuscula"<<endl;
else
cout<<a<<" nu este litera"<<endl;
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea if

Observatie: Înlănţuirea instrucţiunilor if-else introduce

ambiguitate referitor la împerecherea blocurilor if cu cele else.
Regula este ca o ramură else se asociază întotdeauna
cu if-ul imediat anterior.

Exemplu : (scrierea neidentata a fost voită)

if (n>0) if (n>0) {
if (a>b) if(a>b)
z=a ; z=a; }
else else
z=b ; z=b;
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea if

Tema:

int main()
{ int a=0,b=0,x;

cin>>x; // de ex. x=5 apoi x=0

if((a=x)||(b=x+2))
cout<<"a= " << a <<"b= " << b << endl);
cout<<"a= " << a <<"b= " << b << endl);
return 0;
}
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea switch

 pentru ramificăre multipla = în urma evaluării unei expresii, în

funcţie de rezultat, putem avea mai multe alternative de
urmat
Sintaxa:
switch (expresie)
{ case constanta_1: [ instrucţiune_1 [compusă] ]
[ break; ]
case constanta_2: [ instrucţiune_2 [compusă] ]
[ break; ]
. . . . . . . . . . . . . . . . . . .
case constanta_n: [ instrucţiune_2 [compusă] ]
[ break; ]
[ default: instrucţiune [compusă] ]
}
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea switch Sintaxa:
switch (expresie)
{ case constanta_1: [ instrucţiune_1_1; ]
[ instrucţiune_1_2; ]
[ . . . . . . . . ]
[ break; ]
case constanta_2: [ instrucţiune_2_1; ]
[ instrucţiune_2_2; ]
[ . . . . . . . . . ]
[ break; ]
. . . . . . . . . . . . . . . . . . .
case constanta_n: [ instrucţiune_n_1; ]
[ instrucţiune_n_2; ]
[ . . . . . . . . . ]
[ break; ]
default:[ instrucţiune_d_1;]
[ instrucţiune_n_2;]
[ . . . . . . . . . ]
}
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea switch
Observație:
expresie obligatoriu = rezultat de tip întreg (sau caracter).

Efect:
 daca rezultatul = una dintre
constanta_1, constanta_2,…, constanta_n,
atunci
executa ramura case din dreptul constantei respective şi
continuă până la întâlnirea primei comenzi
break => iese din blocul instrucţiunii switch.

 dacă rezultat expresiei nu se regăseşte printre constante,

atunci
execută ramura default, dacă există!!
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea switch Observatii:

Dacă nu avem break după execuţia instrucţiunii desemnate de rezultatul

expresie, atunci se vor executa şi instrucţiunile ce vor
urma, deci cele asociate următoarelor constante, până la
întâlnirea primului break sau a ultimei acolade }.
Exemplu: Numararea inversa de la n (intre 1 si 5) la 1
int a;
cin>>a;
switch (a)
{ case 5: cout<<5<<endl;
case 4: cout<<4<<endl;
case 3: cout<<3<<endl;
case 2: cout<<2<<endl;
case 1: cout<<1<<endl;
break; // TREBUIE ???
default: cout<<” Numar intre 1 si 5!!”;
}
Instructiuni. Instrucțiuni de decizie.
Instrucţiunea switch Observatii:

Instrucţiunea asociată unei constante poate să lipsească, caz în care va

fi executată instrucţiunea etichetei imediat următoare.
Astfel, mai multe constante conduc la execuţia aceleiaşi instrucţiuni

Exemplu: Determină numere pare/impare între 1 si 6

int a;
cin>>a;
switch (a)
{ case 2:
case 4:
case 6: cout<<”Numar par”<<endl;
break;
case 1:
case 3:
case 5: cout<<”Numar impar”<<endl;
break; // TREBUIE ???
default: cout<<” Numar intre 1 si 6!!”;
Instructiuni
Instrucţiuni de buclare (ciclare)

 folosite in cazul in care un bloc de instructiuni trebuie

executat de mai multe ori, relativ la un anumit criteriu
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea while = ciclu cu test iniţial

Sintaxa: while(expresie)
instrucţiune [compusă]

Efect: cât timp expresie este adevărată

execută instrucţiune [compusă]
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea while

Observatii:

1. Datorită testarii înainte intrarii in ciclu:

daca expresia este falsă de la început
atunci instrucţiunea nu se execute niciodată.

2. Dacă în locul expresiei se pune valoarea 1 se obţine un ciclu infinit.

Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea while

Exemplu: tipărirea numerele de la 0 la 9 si calcularea sumei lor

int main()
{ int nr = 0, suma = 0; //initializare nr si suma
while( nr < 10 ) //cit timp nr e mai mic decat 10
{ suma += nr;
cout<<"nr="<<nr++<<"suma="<<suma<<endl;
}
return 0;
}
Tema: se poate?
while( nr < 10)
cout<<"nr="<<nr++<<"suma="<<suma+=nr<<endl;
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea while

Exemplu: determina tipul unui caracter (litera/cifra), ciclu infinit

int main()
{ char a;
while(1)
{ cin>>a;
if(a>=‘a’ && a<=‘z’ || a>=‘A’ && A<=‘Z’)
cout << ”Litera” << endl;
else if(a>=‘0’ && a<=‘9’)
cout<<”Cifra”<<endl;
else if(a == 27)
return 0;
else
cout<<”Caracter special”;
}
return 0;
}
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea while

Exemplu: calcul n factorial

int main()
{ int nr;
long fact;
while(1)
{ cout<<“nr= ”;
cin >> nr;
fact = 1;
while(nr)
fact = fact * nr--;
cout << “factorial = ” << fact << endl;
}
return 0;
}
Tema: Ce valori se pot introduce pentru nr ?
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea do while = ciclu cu test final

Sintaxa: do
instrucţiune [compusă]
while(expresie);

Efect: execută
instrucţiune [compusă]
cât timp expresie este adevărată

Observație: Condiția de ieșire din ciclu este

expresie este falsă

Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea do while

Observatii:

1. Datorită testarii la sfârșitul ciclului, chiar daca la prima testare

expersie este falsă, blocul de instrucțiuni se execută cel puțin o
data:
execută
instrucţiune [compusă]
cât timp ... Dacă expersie este falsă, se iese
din ciclu abia la sfârșit dupa execiția blocului

2. Dacă în locul expresiei se pune valoarea 1 se obţine un ciclu infinit.

Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea do while

Exemplu: Program care aşteptă introducerea de la tastatură a

anumitor caractere, de exemplu d sau D

int main()
{ char c;
cout<<"Doriti sa continuati? (da/nu) ");
do
c = getch();
while( c!='d' && c!='D' );
cout<<"Programul s-a terminat!!"<<endl;
}
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for

Sintaxa: for(expr_1; expr_2; expr_3)

instrucţiune [compusă]

Efect: execută expr_1;

cât timp expr_2 este adevărată
execută { instrucţiune [compusă]
expr_3;
}
Observație: Condiția de ieșire din ciclu este
expr_2 este falsă
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Observație: Față de alte limbaje, în C++, instrucțiunea for are un
caracter mai general, în sensul ca cele 3 expresii pot fi de orice
formă, evaluarea lor se face în ordinea descrisă anterior
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Observație: Față de alte limbaje, în C++, instrucțiunea for are un
caracter mai general, în sensul ca cele 3 expresii pot fi de orice
formă, evaluarea lor se face în ordinea descrisă anterior

În cazul particular: ciclu cu contor, sintaxa devine:

Sintaxa: for(expr_init; expr_stop; expr_incr)

instrucţiune [compusă]

în care: expr_init se folosește pentru inițializarea contorului

expr_stop verifică dacă contorul a ajuns la sfârșitul
domeniului de variație
expr_incr actualizează contorul, de obicei îl
incrementează
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Exemplu: Folosirea unui ciclu for (cu contor )pentru afișarea
numerelor de la 1 la 10

int main()
{ int i;

for( i = 1; i < 11; i++ )

cout << i << endl;
}
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Observații: Ciclul infinit se obține când lipsește expr_2 , deci cu
sintaxa:
for( expr_1; ;expr_3 )

Caz particular, foarte des utilizat:

for( ; ; )
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Exemplu: Funcţie pentru calcularea factorialului

int main()
{ int f=1;
int n=10;

for ( ; n; )
f *= n--;

return 0;
}
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Exemplu: Program care citeşte o frază de la tastatură, terminarea ei fiind
determinată de apăsarea tastei Escape. În timp ce se introduce
textul se numără de câte ori apare caracterului a

int main()
{ char c; int i;

for(i=0,c=getche();c!='\x1b';i+=c=='a'?1:0,c=getche());

cout << endl << "S-au introduse " << i << " litere a";

return 0;
}
Instrucțiuni. Instrucțiuni de bulcare (ciclare)
Instrucţiunea for
Exemplu: Program care tipăreşte tabla înmulţirii.
Folosește cicluri imbricate

int main()
{ int col, rand;

cout << endl; //linie noua

for(rand=1; rand<13; rand++) //bucla externa
{ for(col=1; col<13; col++) //bucla interna
cout << col*rand << “ “; //tipareste produsul

cout << endl; //linie noua

}
}
Instrucțiuni.
Instrucţiunea break

Sintaxa: break;

Utilizare: oprirea execuţiei unui ciclu într-un anumit moment sau

pentru terminarea unei instrucţiuni switch

Observație: Folosirea instrucţiunii break în ciclurile imbricate

conduce numai la părăsirea ciclului de nivel curent, în
care se află instrucțiunea.
Instrucțiuni.
Instrucţiunea break
Exemplu / Tema: Ce afișează programul:
int main()
{ int i,k;
i=k=1;
while(i++<10)
{ cout << i << endl;
while( k++ )
{ cout << k << endl;
if ( k == i ) break;
}

return 0;

}
Instrucțiuni.
Instrucţiunea continue

Sintaxa: continue;

Utilizare: reluarea ciclului de la condiţia de testare, prin urmare nu se

mai execută instrucţiunile din ciclu care se află între
instrucțiunea continue şi sfârşitul ciclului.
Într-un ciclu for saltul se face la executarea expresiei de
incrementare.
Instrucțiuni.
Instrucţiunea continue
int main()
Exemplu: { int s=0,n;
while(1)
Program care adună numerele pare
{ cout << “n=”;
introduse de la tastatură până când
suma depăşeşte 25. Dacă în timp ce se cin >> n;
calculează suma ajunge zece, atunci se if( s == 10 )
reia procesul de la capăt. { s = 0;
continue;
}
s += n%2 ? 0 : n;
if( s > 25 )
break;
}
return 0;
}