INSTRUCTIUNI
Instructiuni de atribuire
Structuri de date
Comentarii
Alegerea instructiunilor
Scrierea de cod omogen
Organizarea pe blocuri
Introducerea validarilor
Elaborarea de variante
Managementul
Instructiuni de atribuire
Programele includ instructiuni de atribuire de forma:
variabila=expresie aritmetica;
ca in exemplele:
a=7;
a=a+b;
a=b*b+c*c+d*d;
a=(x+y+z)/(q-v-d-1);
a=1/(x+y)+1/(x+y+z)+1/(x+y+z+w);
a=y--x++ ;
i++;
f[i]=g[i*j+k]-h[i*k+j*j];
a=s(x,y,z)+s(c,d,r)*w[i]*u[i][j];
Pentru limbajele evoluate, operatorul = , operatorul de atribuire, este un operator ca oricare altul si atunci, in loc de instructiune
de atribuire se va spune expresie de atribuire.
Operatorii au prioritati de evaluare.
In expresia:
e=a+b*c;
- mai intai se efectueaza inmultirea temp1=a*b
- dupa aceea se efectueaza adunarea temp2=temp1+a
- in final se efectueaza atribuirea a:=temp2; in limbajul C++ pentru atribuire se foloseste operatorul =. Existenta operatorului conditional:
(expresie1)? expresie2:expresie3;
si utilizarea lui in instructiuni de atribuire are menirea sa creasca complexitatea expresiilor.
Pentru evaluarea expresiei:
e=minim{a,b}
se va scrie instructiunea de atribuire:
e=(a>b)?b:a;
Pentru evaluarea expresiei:
e=minim{a,b,c}
se va scrie expresia de atribuire:
e=(a>b)?(b>c)?e=c:e=b:(a>c)e=c:e=a;
In cazul in care expresiile includ operatori logici complexitatea creste vizibil. Expresiile:
e=a>b - c<=d;
e=(a==b)+(c>d)*x+(f
confirma acest lucru.
Evaluarea expresiilor se efectueaza de la dreapta la stanga. In alte cazuri specidicate, sensul de evaluare este de la stanga la dreapta la
Prioritatile operatorilor sunt:


Categoria Operatorii Prioritatea Sens parcurgere
Primari()functie() -> 1 stanga->dreapta
Unitari++ -- ! & sizeof() 2stanga->dreapta
Aritmetici()* / % 3stanga->dreapta
Aritmetici()+ - 4stanga->dreapta
Deplasare<< >> 5stanga->dreapta
Comparare< > <= >= 6stanga->dreapta
Biti()& | 7stanga->dreapta
Logici&& || 8stanga->dreapta
Conditional()? : 9stanga->dreapta
Atribuire= *= /= += -= 10stanga->dreapta
Secventa , 11stanga->dreapta
Instructiunea
if(expresie1)expresie2; else expresie3;
implementeaza structura alternativa.
Pentru evaluarea expresiei:
e=1 daca x>0.
e=2 daca x==0.
e=3 daca x<0.
se va scrie secventa:
if(x>0)e=1;
if(x<0)e=3;
if(x==0)e=2;
care reproduce fidel textul enuntului, fara a fi o secventa eficienta.
Secventa eficienta este:
if(x>0)e=1; else
if(x==0)e=2; else e=3;
Instructiunea
for(expresie1; expresie2;expresie3)expresie4;
detrmina repetarea expresiei4 atat timp cat expresie2 este nenula.
Pentru calculul sumelor elementelor de pe liniile si a sumelor de pe coloanele matricei a[][] cu m linii si n coloane se scriu secvente care:
- initializeaza vectorul totalurilor pe linii tot_lin[]
- initializarea vectorului totalurilor pe coloane tot_col[]
- efectuarea insumarilor.
Secventa de program este:
for(i=0; i for(j=0; j for(i=0; i for(j=0; j tot_lin[i]+=a[i][j];
tot_col[j]+=a[i][j];
}
In limbajul C++ sunt implementare distinct:
- structura repetitiva conditionata anterior while()
- structura repetitiva conditionata posterior do while()
- structura alternativa multipla switch().
revenire

Structuri de date
Limbajul de programare C++ permite definirea de variabile elementare avatd tipurile deswcrise in tabelul:

Tip Descriptor Lungime Domeniu Exemple
Intreg scurtshort int 1 [-127; +127] sort int a,b;
Intregint 2[-32767;+32767]int x,y;
Intreg lunglong int 4[;]long int a,b,c;
Virgula mobilafloat4[;]float x,y,s;
Virgula mobila dubla preciziedouble 8[;]double x,r,h,k;
Virgula mobila format lunglong dooublestanga->10[;]long double c,x,u;
Caracter char 1[00h;0FFh]char z,q,a,b;
Pointer tip * 4[0;65535]float *pa,*pb
Poiner spre pointertip ** 4[0;65535]char **ppa,**ppc;
Masiv unidimensional= tip [N] N*lg(tip) tip int x[20];
Masiv bidimensional tip [M][N] M*N*lg(tip)tipfloat a[10][7];
Masiv multidimensional tip [n1][n2]..[nk] n1*n2*...*nk*lg(tip)tipchar a[3][5][6][8][10];
Articol struct suma lunigimi campuritipuristruct{ int a;float b; char c; double x;};
revenire

Comentarii
Programatorul adevarat isi autodocumenteaza programele pentru:
- pregatirea documentatiei
- identificarea facila a secventelor la depanare
- scurtarea timpului de reamintire a ceea ce face programul in procesul de mentenanta
- realizarea concordantei dintre codul scris si diagrame, respectiv, specificatii.
Comentariile se scriu pe fiecare linie de program folosind doua slashuri, iar atunci cand se intind pe mai multe randuri se incadreaza la inceput prin /* si la sfarsit prin */.
In cazul in care se elaboreaza o procedura pentru insumarea elementelor unui sir, textul elaborat de un programator care face o treaba buna si se mai si respecta este:

/*
**************************************************************************
* Programul insumeaza elementele masivului x[N] de tip intreg
* se folosec urmatoarele variabile:
* i - variabila de control utilizata in secvente repetitive
* s - variabila de tip intreg in care se calculeaza suma
* x[i] - element din vectorul x[N]
* N - dimensiunea maxima a masivului x[]
* programul a fost scris de Daniel Ionescu la data de 13 ianuarie 2005
***************************************************************************
*/
int calcul(int x[], int n)
{
// deschide blocul procedurii int i; // defineste variabila de control
int s; // defineste variabila in care se calculeaza suma elementelor vectorului
s=0; // initializeaza suma
for(i=0; i s+=x[i] ; // s=x[0]+x[1]+x[2]+....+x[n] return(s);// revenire in programul apelator cu transmiterea parametrului s
}
// inchidere bloc procedura Comentariile includ detalii de programare si explicatii necesare procesului de depanare.
Se insacriu chiar elemente pe care programatorul va trebui sa le includa in viitor in program.
Se descriu restrictii de programare pe care utilizatorul trebuie sa le respecte si care documentatia trebuie sa le includa pentru a face programul operational.
Comentariile includ si valori ale unor parametri care determina selectii.
revenire

Alegerea instructiunilor
Programul este o constructie arminioasa.
Programatorul trebuie sa aleaga cu grija tipurile de date si instructiunile cu care refera operanzii.
Daca de exemplu, pentru calculul mediei aritmetice a inaltimii indivizilor dintr-o colectivitate formata din 15 componente se lucreza cu variabile elementare, programul are structura:
void main()
{
int h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,
h11,h12,h13,h14,h15;
float h_mediu=0;
float medie;
***********************************************************
initializare date prin citire de la tastatura
***********************************************************
prinf("\n introduceti h1:");
scanf("%d",&h1);
prinf("\n introduceti h2:");
scanf("%d",&h2);
prinf("\n introduceti h3:");
scanf("%d",&h3);
prinf("\n introduceti h4:");
scanf("%d",&h4);
prinf("\n introduceti h5:");
scanf("%d",&h5);
prinf("\n introduceti h6:");
scanf("%d",&h6);
prinf("\n introduceti h7:");
scanf("%d",&h7);
prinf("\n introduceti h8:");
scanf("%d",&h8);
prinf("\n introduceti h9:");
scanf("%d",&h9);
prinf("\n introduceti h10:");
scanf("%d",&h10);
prinf("\n introduceti h11:");
scanf("%d",&h11);
prinf("\n introduceti h12:");
scanf("%d",&h12);
prinf("\n introduceti h13:");
scanf("%d",&h13);
prinf("\n introduceti h14:");
scanf("%d",&h14);
prinf("\n introduceti h15:");
scanf("%d",&h15);
*********************************************************
efectuare calcule
*********************************************************
h_mediu+=h1;
h_mediu+=h2;
h_mediu+=h3;
h_mediu+=h4;
h_mediu+=h5;
h_mediu+=h6;
h_mediu+=h7;
h_mediu+=h8;
h_mediu+=h9;
h_mediu+=h10;
h_mediu+=h11;
h_mediu+=h12;
h_mediu+=h13;
h_mediu+=h14;
h_mediu+=h15;
*************************************************************
calcul medie si afisare
*************************************************************
medie=h_mediu/15;
printf("\n media este: %f",medie);
}

Utilizarea datelor elementare este inadecvata pentru ca:
- programul este foarte lung
- numarul de citiri si numarul de insumari depind de numarul indivizilor din colectivitate
- daca trebuie sa se adauge elemente in colectivitate, se modifica si structura proigramului
- daca pleaca elemente din colectivitate trebuie eliminate instructiuni din program,
In acest caz, structura de date adecvata este masivul unidimensional.
Programul care are la baza o astfel de structura este:

void main()
{
int n; // numarul de elemente din colectivitate
int h[100];
float h_mediu=0;
float medie;
***********************************************************
initializare date prin citire de la tastatura
***********************************************************
prinf("\n introduceti numarul de termeni:");
scanf("%d",&n);
for(i=0; i {
prinf("\n introduceti termenul %d:", i+1);
scanf("%d",&x[i]);
}
*********************************************************
efectuare calcule
*********************************************************
for(i=0;i h_mediu+=x[i]; // insumare elemente vector
medie=h_mediu/n; // calcul medie
*****************************************************
afisare rezultat
*****************************************************
medie=h_mediu/15;
printf("\n media este: %f",medie);
}

Daca pentru aflarea minimului dintre trei elemente se defineste si se initializeaza la definire articolul:
articol struct
{
int a;
int b;
int c;
int min;
} yy=<10,20,5,0>;

iar pentru prelucrare se construieste secventa:
if(yy.a>yy.b)yy.min=yy.b;
else
yy.min=yy.a;
if(min>yy.c)yy.min=yy.c;

se observa ca este vorba de utilizarea unei structuri de date neadecvate penru ca:
- datele a,b,c sunt omogene ca tip, in timp ce structura de tip articol presupune lucru cu campuri membre neomogene
- numarul elementelor este restrans, iar complexitatea expresiei de referire impune utilizarea de variabile elementare.
revenire

Scrierea de cod omogen
Programele trebuie sa fie formate din secvente cat mai omogene.
Vor exista secvente ce corespund initializarilor.
Vor exista secvente ce corespund prelucrarilor.
Daca se alege ca secventele repetitive sa fie realizate cu instructiunea while(), este preferabil, pe cat posibil, sa fie utilizate numai astfel de constructii.
Daca designerul structureaza corect porgramul, se vor elabora proceduri de calcul, proceduri de initializare, proceduri de citire, proceduri de afisare.
Daca se folosesc variabile pointeri, acest tip de variabile trebuie sa fie utilizate cat mai mult posibil, fara a realiza secvente mixte, in care variabila este referita direct dar este referita si cu pointeri.
Limbajele evoluate permit realizarea de constructii deosebit de agregate.
Este preferabil sa se scrie secvente cat mai apropiate de modul in care au fost elaborate diagramele, chiar daca programatorul are o alta solutie.
revenire

Organizarea pe blocuri
Programatorul grupeaza instructiunile in blocuri.
Programul in integralitatea, la nivel macro, sa include o structura liniara.
Daca se considera o problema P care se descompune in subproblemele SP_1, SP_2, SP_3,....., SP_k, programul va contine un bloc P.
{


// blocul P


}
Blocul acesta va include unul dupa celalalt, blocurile aferente subproblemelor.
{
// blocul P

{
// blocul SP_1
.............
}
{
// blocul SP_2
.............
}
..................
..................
{
// blocul SP_k
.............
}
{
In interiorul fiecarui bloc instructiunile se dispun cat mai aerisit pentru a face programul inteligibil.
O secventa se scrie cat mai compact:
a=b=c=d=e=f=0;
sau mai desfasurat, cu explicatii:
a=0; // initializarea variabilei a
b=0; // initializarea variabilei b
c=0; // initializarea variabilei c
d=0; // initializarea variabilei d
e=0; // initializarea variabilei e
f=0; // initializarea variabilei f
Includerea in blocuri a instructiunilor apartinand aceleiasi selectii conduce la simplificarea fluxurilor si la elaborarea unui program cat mai clar.
revenire

Introducerea validarilor
Validarile sunt de fapt secvente de instructiuni
if(expresie1)expresie2; expresie3:
care preced prelucrari generatoare de erori.
Inainte de a evalua expresia: e=(a*a+b*b)/(c*c_d*d-h*h);
este necesar sa se testeze daca expresia:
(c*c_d*d-h*h)
este diferita de zero si numai daca este diferita de zero se va trece la evaluarea expresiei si atribuirea valorii variabilei e.
Se va scrie secventa:
w=(c*c_d*d-h*h);
vb=1; // variabila booleana egala cu THRUE daca ww!=0
if(w) e=(a*a+b*b)/(c*c_d*d-h*h);
else
vb=0; // variabila booleana cu valoare FALSE daca impartirea nu se executa

Validarile sunt importante dupa efectuarea operatiilor de initializare prin introducere date din fisiere intrucat:
- datele trebuie sa apartina unui anumit domeniu
- variabilele din lista trebuie initializate toate
- controlul executiei trebuie mentinut exclusiv prin mesaje din program.
Dupa apelul fiecarei functii se va testa daca s-a efectuat prelucrarea in mod corespunzator.
Este necesar ca procedurile sa includa variabile de stare care sa permita efectuarea de teste asupra calitatii rezultatelor returnate.
Elaborarea documentatiei revine la a scrie:
- ghidul programatorului
- ghidul utilizatorului
- ghidul de prezentare.
Documentatia este folosita:
- in procesul de mentenanta
- de catre operatorii care introduc date
- la depanare
- la prezentarea produsului pentru cumparatori.
revenire

Elaborarea de variante
Un program se scrie intr-o mie de feluri, cel putin.
Programatorul este obligat sa elaboreze pentru fiecare secventa de prelucrare mai multe secvente de instructiuni.
Secventei:
s1=0;
for(i=0;i s1=s1+x[i];
s2=0;
for(i=0;i s2=s1+x[i]*x[i];
s3=0;
for(i=0;i s3=s1+x[i]*y[i];
s4=0;
for(i=0;i if(x[i])s4=s4+x[i];
s5=0;
for(i=0;i s5=s5+x[i]*x[i]*x[i];
s6=0;
for(i=0;i s6=s6+x[i]*x[i]*x[i]*y[i];

ii va corespunde varianta:
s1=0;
s2=0;
s3=0;
s4=0;
s5=0;
s6=0;
for(i=0;i {
s1=s1+x[i];
s2=s1+x[i]*x[i];
s3=s1+x[i]*y[i];
if(x[i])s4=s4+x[i];
s5=s5+x[i]*x[i]*x[i];
s6=s6+x[i]*x[i]*x[i]*y[i];

}
. Programatorul va elabora o varianta ceva mai compacta:
s1=s2=s3=s4=s5=s6=0;
for(i=0;i {
gg=x[i];
vv=y[i];
gg2=gg*gg;
gg3=gg2*gg;
gv=gg*vv;
gv2=gg2*gv; // produs scalar a doi vectori
s1+=gg; // suma elemente sir
s2+=gg2; // suma patrate elemente sir
s3+=gv;
if(gg)s4+=gg;// suma elemente pozitive din sir
s5+=gg3; // suma de cuburi ale elementelor din sir
s6+=gg2*gv; // suma de cub al lui x[i] inmultit cu y[i]

}
. In cazul in care sumele sunt utilizate pentru a alte prelucrari, programatorul decide daca se definesc ca un vector cu 6 componente, care in viitor sa fie incluse in structuri repetitive cu for() sau while().
\
revenire

Managementul
Managementul utilizarii instructiunilor presupune:
- alegerea instructiunii potrivite cu prelucrarea
- exploatarea efectelor generate de instructiune
- includerea in secvente numai a instructiunilor care servesc obiectivului
- alegerea dintre mai multe variante a acelei variante care garanteaza ca prelucrarile vor conduce la rezultatele corecte si complete asteptate
- programul va trebui sa fie expresia unui echilibru intre utilizarea unor cat mai rezonabile tipuri de instructiuni
- utilizarea de noi constructii trebuie sa fie rezultatul natural al cerintei secventei si nu dorinta de a experimenta ceva nou.
revenire

revenire