Functii de intrare si iesire
Pentru realizarea calculului matriceal este necesara existenta matricei sau matricelor. Crearea necorespunzatoare a obiectului de lucru, si anume matricea, duce la efecte total neasteptate. De aceea, pentru a fi lipsiti de neplaceri, atentia acordata acestor functii este maxima.
În calculul matriceal sunt incluse si functii de intrare si iesire. Aceste functii realizeaza:
crearea matricei, fie de la consola ca în cazul bibliotecii matrice.h, fie initializata cu zero ca în cazul clasei matrix( constructorul cu parametrii);
afisarea matricei pe ecran.
Cum în biblioteca de functii matrice.h se lucreaza cu o matrice de dimensiuni constante, iar în clasa matrix se utilizeaza o variabila de tip pointer, deci dinamic, sunt prezentate ambele moduri de creare( dinamic si static).
În continuare se 757j97h prezinta functiile care realizeaza creare matricei. În practica se observa, ca pe lânga matricea dorita, sunt folosite o serie de matrice ajutatoare cum ar fi matricea unitate, matricea booleana, matricea cu 1 pe o linie si în rest zero etc.. Functiile de creare a acestor matrice sunt functii de intrare, iar afisarea lor este realizata tot cu functii de iesire.
Matricea este creata în modul de lucru static de la consola folosind functia din cadrul bibliotecii matrice.h :
void creation(int *n, int *m, int x[30][30])
Dupa cum se observa tipul functiei este void. Functia primeste ca parametrii urmatoarele variabile:
int x[30][30]- variabila de tip pointer constant( se aloca memorie pentru 30 de linii si 30 de coloane, fig.1) la întreg. Aceasta reprezinta matricea care este citita de la tastatura.
int *n- parametru de iesire, numarul de linii a matricei, care este citit de la tastatura. Transferul se realizeaza prin valoare.
int *m- parametru de iesire, numarul de coloane a matricei, care este citit de la tastatura. Transferul se realizeaza prin valoare.
Declarând matricea de dimensiuni constante se aloca de fiecare data un tablou cu 30 de linii si 30 de coloane:
......... 30 de coloane
.........
............
30 de linii ..........
fig. 1
, chiar daca este necesar de exemplu decât o matrice de doua linii si doua coloane( în fig.1 casutele albe reprezinta matricea introdusa de la tastatura cu doua linii si doua coloane).
Continutul functiei creation este urmatorul :
printf("\n Matrix lines number:");
scanf("%d",n);
valid_l_c(n);
printf("\n Matrix columns number:");
scanf("%d",m);
valid_l_c(m);
printf("\n The matrix is:");
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
Se citeste numarul de linii si de coloane ale matricei, urmând introducerea elementelor matricei. Dupa cum se observa fiecare citire este urmata de o validare. Validarea asigura ca nu sunt introduse date eronate( caractere în loc de întregi, float în loc de întreg, numarul de linii sau de coloane depaseste 30, sau este mai mic sau egal cu zero). Validarea se realizeaza cu ajutorul a doua functii:
void valid_no_integer(int *l, int k);
void valid_l_c(int *l).
void valid_l_c(int *l)- realizeaza validarea numarului de linii si de coloane introduse de la tastatura. Functia primeste ca parametru(atât de intrare cât si de iesire) un întreg int *l, care este transferat catre alte functii prin valoare. Continutul acestei functii este urmatorul:
if((*l<1)||(*l>30))
do
while ((*l<1)||(*l>30)||(*endptr>9));
Aceasta validare este foarte puternica deoarece nu permite si introducerea cifrelor urmate de caractere. Numarul introdus de la tastatura este citit ca un sir de caractere. Se realizeaza conversia de la sir de caractere la întreg cu ajutorul functiei int strtod(char, & char*) din cadrul bibliotecii stdlib.h. În caz de introducere necorespunzatoare se afiseaza mesajul Error.
void valid_no_integer(int *l, int k) realizeaza validarea introducerii unui întreg de la tastatura. Este folosita în cadrul functiei de creare a matricei în mod static atunci când sunt introduse de la tastatura elementele matricei. Functia primeste ca parametrii doua variabile de tip întreg si anume:
int k- parametru de intrare; functia scanf întoarce valoare 0 daca citirea este incorecta sau 1 in cazul citirii corecte. Aceasta valoare este primita de functia valid_no_integer prin intermediul parametrului k. Daca k este egal cu 0 se afiseaza mesajul Error si se cere o noua introducere a elementului.
int *l- reprezinta valoarea introdusa care îndeplineste toate conditiile de validitate. Transferul parametrului de iesire se realizeaza prin valoare.
Continutul acestei functii este urmatorul:
if (k==0)
while(k==0);
}
Spre deosebire de functia de validare precedenta, aceasta nu este la fel de puternica deoarece permite introducerea numerelor urmate de caractere.
Asadar aceasta a fost functia de creare de la tastatura a unei matrice în mod static. În continuare se prezinta modul de creare de la consola a unei matrice alocate dinamic. Lucrul cu matrice alocate dinamic este implementat în clasa matrix. Crearea de la tastatura a unei matrice se realizeaza în cadrul constructorului implicit al clasei matrix, precum si cu operatorul de shiftare la dreapta.
Clasa matrix are implementata doi constructori. Unul este implicit fara parametri si realizeaza introducerea matricei de la tastatura, iar cel de-al doilea primeste ca parametrii numarul de linii si de coloane si creaza matricea cu elementele zero.
Constructorul implicit are urmatoarea configuratie:
matrix::matrix()
Declararea unei matrice cuprinde tipul de data asociat elementului, numele masivului si numarul de dimensiuni ale acestuia, adica [ ][ ] ,sau putem declara un pointer la o matrice de forma int **x.
Folosind a doua metoda de declarare a unei matrice folosim atât spatiu cât ne trebuie, alocându-l dinamic în functie de câte linii si coloane avem.
Alocarea dinamica presupune utilizarea memoriei într-un mult mai eficient si anume se aloca memorie exact cât este necesar pentru memorarea matricei. Pentru a realiza aceasta se foloseste functia membru int** aloc_mat(int, int). Dupa cum se observa din secventa prezentata mai sus alocarea memoriei necesare matricei se realizeaza dupa introducerea numarului de linii si coloane. Este foarte important sa nu se omita acest pas, altfel rezultatele obtinute fiind cu totul altele. Functia de alocarea a matricei are ca drept de acces private.
Continutul ei este urmatorul:
int **pmat;
pmat=(int **)malloc(n*sizeof(int*));
for (int i=0;i<n;i++)
pmat[i]=(int*)malloc(m*sizeof(int));
return pmat;
Functia primeste ca date de intrare numarul de linii n si numarul de coloane m al matricei si întoarce un pointer la aceasta.
Matricea X de dimensiuni n=4 si m=3, 
, unde n este numarul de linii si m este numarul de coloane, este
alocata în memorie ca în Figura 2.
Figura 2. Alocare dinamica de memorie pentru o matrice
La început este alocata zona de memorie pentru un vector de pointeri, care reprezinta începutul fiecarei linii a matricei. Vectorul contine n componente. Urmeaza alocarea zonei de memorie pentru fiecare linie a matricei. Linia matricei este alcatuita din m elemente. Dupa alocarea spatiului necesar memorarii matricei se continua cu introducerea elementelor matricei.
O alta functie de intrare este functia de supraâncarcare a operatorului de shiftare la dreapta ">>". Aceasta este declarata ca functie prietena si are urmatoarea forma:
istream &operator>>(istream &c,matrix &a)
return c;
}
Operatorul ">>" realizeaza introducerea elementelor matricei, deoarece citirea unei matrice de la tastatura este realizata atunci când este apelat constructorul cu parametrii, adica constructorul care initializeaza numarul de linii si de coloane ale matricei cu datele dorite, precum si elementele matricei cu zero. Daca este apelat constructorul implicit acesta realizeaza citirea numarului de linii, numarului de coloane si elementele matricei. Deci recitirea numarului de linii si de coloane este inutila. A se retine însa faptul ca operatorul de shiftare la dreapta este asociat unor obiecte create cu constructorul cu parametrii.
Constructorul cu parametrii amintit mai sus are structura urmatoare:
matrix::matrix(int k,int l)
Asadar au fost prezentate functiile de intrare de la consola la nivel de matrice. Au fost prezentate în paralel modul de alocare static si varianta dinamica.
În continuare sunt prezentate functiile care creaza matricele speciale. Prezentarea este facuta în paralel( static si dinamic).
Revenim la biblioteca matrice.h pentru prezentarea functiei de creare a matricei unitate. Acesta este realizata cu functia void creating_unit(int *n,int *m, int x[30][30]). Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea unitate.
Secventa care realizeaza crearea matricei unitate este urmatoarea:
printf("\n Lines and columns number:");
scanf("%d",n);
valid_l_c(n);
*m=*n;
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
if(i==j) x[i][j]=1;
else x[i][j]=0;
Matricea unitate presupune o matrice patratica si de aceea numarul de coloane si linii este citit în aceeasi secventa.
În clasa matrix matricea unitate este creata cu ajutorul functiei membru void creating_unit() . Desi se lucreaza cu o matrice alocata dinamic nu mai este necesara alocarea spatiului de memorie deoarece acesta a fost pus la dispozitie în momentul apelarii constructorului cu parametrii. De retinut ca toate functiile de creare a matricelor speciale sunt asociate obiectelor create cu constructorul cu parametrii. Secventa care realizeaza aceasta este urmatoarea:
for (i=0;i<n;i++)
for(j=0;j<=i;j++)
if (i==j) a[i][j]=1;
else a[i][j]=a[j][i]=0;
Deci, singura diferenta dintre functia creating_unit din matrice.h si functia creating_unit din clasa matrix este aceea ca în functia membra clasei citirea numarul de linii si de coloane nu mai este necesara. Numarul este cunoscut, n si m fiind membrii în clasa si sunt initializati prin apelarea constructorului cu parametrii.
Functia void creating_column_1(int *n,int *m, int x[30][30]) creaza matricea cu valoarea 1 pe o coloana dorita, care se introduce de la tastatura, si în rest elementele matricei vor fi zero. Functia primeste urmatorii parametrii:
int *n- parametru de iesire si reprezinta numarul de linii;
int *m- parametru de iesire si reprezinta numarul de coloane;
int x[30][30]-parametru de iesire si reprezinta matricea ce este obtinuta prin apelarea acestei functii.
Secventa care realizeaza crearea matricei cu valoarea 1 pe o coloana dorita este urmatoarea:
printf("\n The column with elements one is:");
k=scanf("%d",&c);
c--;
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
În clasa matrix matricea cu 1 pe coloana dorita este realizata cu functia membra void creating_column_1(int c). Acesta are ca parametru de intrare int c care reprezinta coloana cu elementele 1. Secventa care realizeaza crearea matricei este urmatoarea:
if (c<m)
for (i=0;i<n;i++)
for (j=0;j<m;j++)
if (j==c) a[i][c]=1;
else a[i][j]=0;
else cout<<"Column doesn't exist!";
În clasa coloana dorita a fi 1 este primita ca parametru în timp ce în functia din biblioteca matrice.h este citita de la tastatura.
Functia void creating_line_1(int *n,int *m, int x[30][30]) creaza matricea cu valoarea 1 pe o linie dorita, care se introduce de la tastatura, si în rest elementele matricei vor fi zero. Functia primeste urmatorii parametrii:
int *n- parametru de iesire si reprezinta numarul de linii;
int *m- parametru de iesire si reprezinta numarul de coloane;
int x[30][30]-parametru de iesire si reprezinta matricea ce este obtinuta prin apelarea acestei functii.
Secventa care realizeaza crearea matricei cu valoarea 1 pe o linie dorita este urmatoarea:
printf("\n The line with elements one is:");
k=scanf("%d",&l);
l--;
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
În clasa matrix matricea cu 1 pe linia dorita este realizata cu functia membra void creating_line_1(int l). Acesta are ca parametru de intrare int l care reprezinta linia cu elementele 1. Secventa care realizeaza crearea matricei este urmatoarea:
if (l<n)
for (i=0;i<n;i++)
for (j=0;j<m;j++)
if (i==l) a[l][j]=1;
else a[i][j]=0;
else cout<<"Line doesn't exist!";
În clasa linia dorita a fi 1 este primita ca parametru în timp ce în functia din biblioteca matrice.h este citita de la tastatura.
Functia void creating_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 1 pe diagonala secundara, restul elementelor matricei având valoarea 0. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 1 pe diagonala secundara.
Secventa care realizeaza crearea matricei cu 1 pe diagonala secundara este urmatoarea:
printf("\n Matrix lines number:");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix columns number:");
scanf("%d",m);
valid_square(m,*n);
for (int i=0;i<*n;i++)
for(int j=0;j<*n;j++)
if (j==((*n)-i-1)) x[i][j]=1;
else x[i][j]=0;
Matricea cu valoarea 1 pe diagonala secundara presupune matricea patratica si de aceea este folosita functia de validare valid_square(m,*n). Ea verifica daca numarul liniilor si cel al coloanelor este egal. În cazul în care sunt diferite este afisat mesajul Error si se cere o noua introducere a numarului de coloane.
În clasa matrix matricea cu 1 pe diagonala secundara este creata cu ajutorul functiei membru void creating_sec_diag(). Secventa care realizeaza aceasta este urmatoarea:
for (i=0;i<n;i++)
for(j=0;j<n;j++)
if (j==(n-i-1)) a[i][j]=1;
else a[i][j]=a[j][i]=0;
Numarul de linii si de coloane este cunoscut, n si m fiind membrii în clasa si sunt initializati prin apelarea constructorului cu parametrii.
Functia void creating_0_up_main_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 deasupra diagonalei principale, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 deasupra diagonalei principale.
Secventa care realizeaza crearea matricei cu 0 deasupra diagonalei principale este urmatoarea:
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
printf("\n The matrix is:\n");
for(int i=0;i<*n;i++)
for(int j=0;j<*m;j++)
if (i>=j)
else x[i][j]=0;
Dinamic, adica în clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_up_main_diag(). Continutul functiei este acelasi cu cel al functie de mai sus. Cum se lucreaza cu obiecte nu mai este necesara citirea numarului de linii si de coloane.
Functia void creating_0_main_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 pe diagonala principala, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 pe diagonala principala.
Secventa care realizeaza crearea matricei cu 0 pe diagonala principala este urmatoarea:
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
if (i!=j)
else x[i][j]=0;
În clasa matrix, functia care realizeaza aceasta operatie se numeste creating_0_main_diag(). Functia este declarata ca functie membra fara tip. Continutul functiei este acelasi cu cel al functie de mai sus. Cum se lucreaza cu obiecte nu mai este necesara citirea numarului de linii si de coloane.
Functia void creating_0_under_main_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 sub diagonala principala, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 sub diagonala principala.
Secventa care realizeaza crearea matricei cu 0 sub diagonala principala este urmatoarea:
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
printf("\n The matrix is:\n");
for(int i=0;i<*n;i++)
for(int j=0;j<*m;j++)
if (i<=j)
else x[i][j]=0;
Dinamic, adica în clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_under_main_diag().
Functia creating_0_under_main_diag() este functie membra fara tip si are acelasi continut cu functia creating_0_under_main_diag() din biblioteca matrice.h, mai putin citirea numarului de linii si de coloane. Initializarea lor este realizata prin apelarea constructorului cu parametrii.
Functia void creating_0_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 pe diagonala secundara, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 pe diagonala secundara.
Secventa care realizeaza crearea matricei cu 0 pe diagonala secundara este urmatoarea:
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
if (j!=*n-i-1)
else x[i][j]=0;
În clasa matrix, functia care realizeaza aceasta operatie se numeste creating_0_sec_diag(). Functia este declarata ca functie membra fara tip. Continutul functiei este acelasi cu cel al functie de mai sus, mai putin citirea numarului de linii si de coloane care sunt initializate în momentul apelarii constructorului cu parametrii.
Functia void creating_0_up_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 deasupra diagonalei secundare, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 deasupra diagonalei secundare.
Secventa care realizeaza crearea matricei cu 0 deasupra diagonalei secundare este urmatoarea:
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
printf("\n The matrix is:\n");
for(int i=0;i<*n;i++)
for(int j=0;j<*m;j++)
if (i+j>=*n-1)
else x[i][j]=0;
Dinamic, adica în clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_up_sec_diag(). Continutul functiei este acelasi cu cel al functie de mai sus, mai putin citirea numarului de linii si de coloane deoarece se lucreaza cu obiecte si nu mai este necesara citirea lor.
Functia void creating_0_under_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 sub diagonala secundara, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:
int *n- parametru de iesire si reprezinta liniile matricei x;
int *m- parametru de iesire si reprezinta coloanele matricei x;
int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 sub diagonala secundara.
Secventa care realizeaza crearea matricei cu 0 sub diagonala secundara este urmatoarea:
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
printf("\n The matrix is:\n");
for(int i=0;i<*n;i++)
for(int j=0;j<*m;j++)
if (i+j<=*n-1)
else x[i][j]=0;
Dinamic, adica în clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_under_sec_diag().Functia creating_0_under_sec_diag() este functie membra fara tip si are acelasi continut cu functia creating_0_under_sec_diag() din biblioteca matrice.h, mai putin citirea numarului de linii si de coloane. Initializarea este realizata prin apelarea constructorului cu parametrii.
Functia void creating_bool_matrix(int n, int m, int x[30][30], int b[30][30]) creaza matricea booleana. Matricea booleana este matricea ale carei elemente iau valori în multimea .
Deci B=bij, unde
i=1,n si j=1,m si bij=
. Matricea
booleana este asociata întotdeauna unei alte matrice.
Functia primeste ca parametrii urmatoarele variabile:
int n- parametru de intrare si reprezinta liniile matricei x;
int m- parametru de intrare si reprezinta coloanele matricei x;
int x[30][30]- parametru de intrare si reprezinta matricea careia i se asociaza matricea booleana;
int b[30][30]- parametru de iesire si reprezinta matricea booleana asociata matricei x.
Secventa care realizeaza crearea matricei booleane este urmatoarea:
for (i=0;i<n;i++)
for(j=0;j<m;j++)
if (a[i][j]==0) b[i][j]=0;
else b[i][j]=1;
În clasa matrix matricea booleana este obtinuta cu ajutorul functiei membre fara tip creating_bool_matrix(matrix &). Functia primeste ca parametru de iesire un obiect de tip matrix care se transfera prin referinta. Parametrul de intrare este reprezentat de pionterul this caruia i se asociaza obiectul de tip matrix , matrice booleana. Functia este urmatoarea :
void matrix::creating_bool_matrix(matrix &b)
Dupa efectuarea operatiilor este foarte important sa vizualizam efectele create. Acesta se realizeaza cu ajutorul functiilor de iesire. În cazul de fata sunt realizate numai functii de iesire catre monitor. Exista functii de iesire care transmit informatia unei imprimante, unui fisier sau mai multor fisiere etc.
Afisarea pe ecran este obtinuta în cazul lucrului în mod static cu ajutorul functiei void show_matrix(int n,int m,int x[30][30]), în timp ce în modul de lucru dinamic( implementat în clasa matrix) este realizat prin supraâncarcarea operatorului de shiftare la stânga "<<", care lucreaza acum la nivel de obiecte de tip matrix.
Functia show_matrix(n,m,x) afiseaza pe ecran matricea x. Ea are ca parametrii de intrare :
int n- numarul de linii;
int m- numarul de coloane;
int x[30][30]-matricea care este afisata.
Functia este urmatoarea:
int i,j;
printf("\n The matrix is:\n");
for (i=0;i<n;i++)
Daca avem de exemplu matricea de 3 linii si 3 coloane, care are elementele 1,2,3,4,5,6,7,8,9 dupa apelul acestei functii pe ecran sunt afisate urmatoarele:
The matrix is:
1 2 3
4 5 6
7 8 9
Operatorul de shiftare la stânga "<<" are ca efect exact acelasi mesaj ca si functia show_matrix. El a fost supraîncarcat ca functie prietena astfel:
ostream &operator<<(ostream &c,matrix a)
}
else cout<<"\nNothing to list !!!";
getch();
return c;
}
Calculul matriceal presupune existenta matricelor. Aceasta problema este rezolvata cu ajutorul functiilor de intrare. Pentru monitorizarea efectelor obtinute în urma operatiilor realizate sunt foarte necesare functiile de iesire. De aceea functiile de intrare si iesire trebuie tratate cu toata seriozitatea de catre programatori.
|
