Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Informatică și Ingineria Sistemelor

RAPORT

Implementarea tipului de date abstract

Lucrarea de laborator nr.1

la Strucuri de Date și Algoritmi
V-9
Tema structurii: Imobil

A efectuat:

Chișinău 2019

Lucrarea de laborator nr. 1

Tema: Implementarea tipului de date abstract “Tablou de structuri” în
limbajul C.

Scopul lucrării: Obținerea deprinderilor practice de implementare și de

utilizare a tipului de date abstract (TDA) “Tablou de structuri” în
limbajul C.

Sarcina de lucru: De scris trei fisiere-text în limbajul C pentru

implementarea si utilizarea TDA “Tablou de structuri”:

1. Fişierul antet name.h care conține: a) specificația structurei

elementului tabloului (după varianta) şi b) prototipurile funcţiilor care
asigură operaţiunile de prelucrare a tabloului de structuri.
2. Fişierul name.cpp sau name.c care conţine codurile (implementările)
tuturor funcţiilor declarate în fişierul antet.
3. Fişierul utilizatorului lab1.cpp sau lab1.c care reprezintă un program
cu funcţia main ( ) pentru prelucrarea tabloului de structuri cu afişarea
meniului de opţiuni pe ecran si anume: alocarea memoriei dinamice
pentru tabloul de structuri cu n elemente, introducerea informaţiei despre
elementele tabloului de la tastatură, afişarea informaţiei despre elementele
tabloului pe ecran, căutarea elementului tabloului după unui cîmp al
structurei, modificarea cîmpurilor elementului tabloului, interschimbarea
a 2 elemente indicate ale tabloului, sortarea elementelor tabloului după
unui cîmp, adăugarea unui element nou la sfîrșitul tabloului, adăugarea
unui element nou la începutul tabloului, inserarea unui element nou în
tabloul la pozitia indicată, stergerea (eliminarea) unui element din tabloul,
scrierea (salvarea) informaţiei despre elementele tabloului în fişier, citirea
informaţiei despre elementele tabloului din fişier, eliberarea memoriei
dinamice alocate pentru tabloul, ieşire din program.

Varianta structurii:

9. Imobil
Tipuri de date abstracte
Tipul de date abstract este o entitate manipulata doar prin
operatiile ce definesc acel tip. Avantajele utilizarii tipurilor de
date abstracte sunt:
1. Programele devin independente de modul de reprezentare a
datelor. Modul de reprezentare poate fi modificat, fara însa
a afecta restul programului (de exemplu, o multime poate fi
implementata printr-un tablou sau printr-o lista ordonata,
dar partea de program ce foloseste operatorii tipului abstract
ramâne neschimbata).
2. Se previne violarea accidentala a datelor. Utilizatorul tipului
abstract este fortat sa manipuleze datele doar prin
intermediul operatorilor ce compun tipul abstract, astfel
reducându-se riscul unei distrugeri a datelor.
In C tipurile abstracte sunt realizate folosind fisiere. Acest mod
are desigur propriile sale limitari.

Fișierul fisierfun.h , care conține:

a) Specificațiile structurii cu compartimentele care
descriu proprietățile obiectului (imobilul).

b) Prototipurile funcțiilor care implementează

operațiile asupra componentelor (proprietăților)
obiectului.
Fișierul fisierfun1.cpp , care conține codurile
( implementările) funcțiilor din etapa 1 (fişierul antet).
Codul:
| void showS(imobil *S,int n){
int i;
puts("Informatia despre imobil:");
for (i=0;i<n;i++){
printf("%d) \n\tTipul de imobil: %s \n\tSuprafata m^2: %d \n\tPretul $: %.2f\n\tProprietarul:
%s \n\tAdresa: %s\n", i+1, S[i].type,S[i].surface,S[i].price,S[i].owner,S[i].address);
}
return;
}

int searchS(imobil*S,int n,char*nume){

int i;
for (i=0;i<n;i++){
if(stricmp(S[i].type,S[i].type)==0){
return i;
}
}
return -1;
}
void sortS(imobil*S,int n){
int i,k;
imobil t;
for(i=0;i<n-1;i++){
for(k=0;k<n-1-i;k++){
if(S[k].surface<S[k+1].surface){
t=S[k];
S[k]=S[k+1];
S[k+1]=t;
}
}
}
return;
}

void modifyS(imobil*S,int k){

int f;
puts("Doriti sa schimbati typul imobilului?(1/0):");
scanf("%d",&f);
if(f){
puts("\tNoul tip al imobilului:");
fflush(stdin);
gets(S[k].type);
}

puts("Doriti sa schimbati suprafata?(1/0):");

scanf("%d",&f);
if(f){
puts("\n\tSuprafata noua:");
scanf("%d",&S[k].surface);
}
puts("Doriti sa schimbati pretul?(1/0):");
scanf("%d",&f);
if(f){
puts("\n\tPretul nou:");
scanf("%f",&S[k].price);
}
puts("Doriti sa schimbati adresa imobilului?(1/0):");
scanf("%d",&f);
if(f){
puts("\tNoua adresa a imobilului:");
fflush(stdin);
gets(S[k].address);
}
puts("Doriti sa schimbati proprietarul imobilului?(1/0):");
scanf("%d",&f);
if(f){
puts("\tProprietarul nou:");
fflush(stdin);
gets(S[k].owner);
}
return;
}

imobil *appendS(imobil*S,int*n,imobil a){

imobil*B;
 B=(imobil*)realloc(S,(*n+1)*sizeof(*B));
if(!B){
return B;
}
B[*n]=a;
*n=*n+1;
return B;
}

imobil*prependS(imobil*S,int*n,imobil a){
imobil*B;
int i;
B=(imobil*)realloc(S,(*n+1)*sizeof(*B));
if(!B){
return B;
}
for (i=*n;i>0;i--){
B[i]=B[i-1];
}
B[0]=a;
*n=*n+1;
return B;
}

imobil*insertS(imobil*S,int*n,imobil a,int k){

imobil *B;
int i;
B=(imobil*)realloc(S,(*n+1)*sizeof(*B));
if(!B){
return B;
}
for(i=*n;i>k;i--){
B[i]=B[i-1];
}
B[k]=a;
*n=*n+1;
return B;
}

imobil*deleteS(imobil*S,int*n,int k){
int i;
imobil *B;
for(i=k;i<*n-1;i++){
S[i]=S[i+1];
}
B=(imobil*)realloc(S,(*n-1)*sizeof(*B));
*n=*n-1;
return B;
}

void swapS(imobil*S,int k1,int k2){

imobil t;
t=S[k1];
S[k1]=S[k2];
S[k2]=t;
return;
}
//functia care salveaza in fisier:
int saveS(imobil *S,int n,char *fnume){
FILE *fp;
int i;
fp=fopen("fnume","w");
if(!fp){
return 0;
}
for (int i = 0; i < n; ++i)
{
fprintf(fp," %s %d %.2f %s %s\n ",S[i].type,S[i].surface,S[i].price,S[i].owner,S[i].address);
}
fclose(fp);
return 1;
}
//functia care citeste din fisier
int loadS(imobil *S,int n,char *fnume){
FILE *fp;
int i;
fp=fopen("fnume", "r");
if(!fp){
return 0;
}
for (int i = 0; i < n; ++i)
{
fscanf(fp," %s %d %.2f %s %s\n
",S[i].type,S[i].surface,S[i].price,S[i].owner,S[i].address);
}
fclose(fp); return1 ; }

Codul programului SDA.c, care conține fișierele

fisierfun.h și fișierul fisierfun1.cpp
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "fisierfun.h"
#include "fisierfun1.cpp"

int main()
{
int n;
int k,k1,k2,f;
imobil *S = NULL;
imobil *B = NULL;
imobil a;
char num[40];
int nm;
while(1)
{
puts("\n********************MENU********************\n");
puts("1. Introducerea numarului de imobile");
puts("2. Introducerea informatiei despre imobil");
 puts("3. Afisarea informatiei despre imobil");
puts("4. Cautarea imobilului dupa tip");
puts("5. Sortarea tabloului de imobil dupa suprafata");
puts("6. Modificarea imobilului.");
puts("7. Adaugarea unui imobil la sfarsitul listei");
puts("8. Adaugarea unui imobil la inceputul listei");
puts("9. Inserarea unui imobil");
puts("10. Stergerea unui imobil");
puts("11. Interschimbarea imobilelor in lista");
puts("12. Stergerea tabloului de imobile din memorie");
puts("13. Salvarea informatiei despre imobile in fisier");
puts("14. Citirea informatiei despre imobile din fisier");
puts("n. Eliberarea memoriei.");
puts("0. Iesirea din program");
puts("\n*********************************************\n");

puts("Alegeti optiunea: ");

scanf("%d",&nm);

switch(nm)
{
case 1:
printf("Dati n: ");
scanf("%d", &n);
S=(imobil*)malloc(n*sizeof(*S));
if (!S){
puts("Memoria nu a fost alocata pentru numarul dat");
exit(1);
}
puts("Pentru a continua apasati ENTER");
getch();
break;

case 2:
readS(S,n);
getch();
break;

case 3:
showS(S,n);
getch();
break;

case 4:
puts("Dati tipul imobilului de cautat:");
fflush(stdin);
gets(num);
k=searchS(S,n,num);
if(k==-1){
puts("Imobilul nu a fost gasit");
}
else{
puts("Informatia despre imobilul cautat:");
printf("%d) \tTipul de imobil: %s \n\tSuprafata m^2: %d \n\tPretul:
%.2f\n\Proprietarul: %s\n", k+1, S[k].type,S[k].surface,S[k].price,S[k].owner);
}
 getch();
break;

case 5:
sortS(S,n);
puts("De afisat lista sortata de imobile? (1/0)");
scanf("%f",&f);
if(f){
showS(S,n);
}
getch();
break;

case 6:
puts("Dati numarul de ordine al imobilului de modificat: ");
scanf("%d",&k);
modifyS(S,k-1);
getch();
break;

case 7:
puts("Dati informatia despre imobilul de adaugat la sfarsit:");
printf("\tTipul imobilului: ");
fflush(stdin);
gets(a.type);
printf("\tSuprafata: ");
scanf("%d",&a.surface);
printf("\tPretul: ");
scanf("%f",&a.price);
printf("\tAdresa:");
fflush(stdin);
gets(a.address);
printf("\tProprietarul:");
fflush(stdin);
gets(a.owner);
B= appendS(S,&n,a);
if(B==NULL)
{
puts("Adaugarea imobilului nu a fost efectuata");
}
else{
S=B;
}
getch();
break;

case 8:
puts("Dati informatia despre imobilul de adaugat la inceput:");
printf("\tTipul imobilului: ");
fflush(stdin);
gets(a.type);
printf("\tSuprafata: ");
scanf("%d",&a.surface);
printf("\tPretul: ");
scanf("%f",&a.price);
printf("\tAdresa:");
 fflush(stdin);
gets(a.address);
printf("\tProprietarul:");
fflush(stdin);
gets(a.owner);
B= prependS(S,&n,a);
if(B==NULL){
puts("Adaugarea imobilului nu a fost efectuata");
}
else{
S=B;
}
getch();
break;

case 9:
printf("Dati informatia despre imobilul de inserat:\n");
printf("\tTipul imobilului: ");
fflush(stdin);
gets(a.type);
printf("\tSuprafata: ");
scanf("%d",&a.surface);
printf("\tPretul: ");
scanf("%f",&a.price);
printf("\tAdresa:");
fflush(stdin);
gets(a.address);
printf("\tProprietarul:");
fflush(stdin);
gets(a.owner);
printf("\tDati locul unde sa fie adaugat imobilul: ");
scanf("%d",&k);
B=insertS(S,&n,a,k-1);
if(B==NULL){
puts("Inserarea elementului nu a fost efectuata");
}
else{
S=B;
}
getch();
break;

case 10:
printf("Dati numarul imobilului de sters:");
scanf("%d",&k);
B=deleteS(S,&n,k-1);
if(B==NULL){
puts("Stergerea imobilului nu a fost efectuata");
}
else{
S=B;
}
getch();
break;

case 11: // problema la introducerea unor numere mai mari decit cele din lista
 printf("Dati numerele de ordine ale elementelor de interschimbat: ");
scanf("%d",&k1);
scanf("%d",&k2);
swapS(S,k1-1,k2-1);
puts("Interschimbarea a fost efectuata cu succes!");
getch ();
break;

case 12:
printf("Doriti sa eliberati memoria dinamica? (1/0):");
scanf("%d",&f);
if(f){
free(S);
S=NULL;
}
getch ();
break;
case 13:
printf("dati numele fisierului pentru salvarea informatiei despre imobile:");
fflush(stdin);
gets(num);
saveS(S,n,num);
getch ();
break;

case 14:
printf("dati numele fisierului pentru citirea informatiei despre imobile:");
fflush(stdin);
gets(num);
loadS(S,n,num);
getch ();
break;

case 0:
printf("doriti sa iesiti din program? (1/0):");
scanf("%d",&f);
if(f){
free(S);
return 0;
}
puts("alegeti optiunea corecta");
getch ();
break;

}
}
}
void readS(imobil*S,int n){
int i;
puts("Dati informatia despre imobile:");
for (i=0;i<n;i++){
printf("Imobil %d:\n",i+1);
printf("\tTipul imobilului: ");
fflush(stdin);
gets(S[i].type);
printf("\tSuprafata m^2: ");
 scanf("%d",&S[i].surface);
printf("\tPretul $: ");
scanf("%f",&S[i].price);
printf("\tAdresa: ");
fflush(stdin);
gets(S[i].address);
printf("\tProprietarul: ");
fflush(stdin);
gets(S[i].owner);
} return; }

Rezultatele obținute:

Consola ***MENU***

Exemplu: Opțiunea nr.2

Concluzii:

1) Am obtinut un design al softului , care poate fi citit si inteles mai usor, am obtinut structurarea
eficienta a codului programului in diferite fisiere.

2) Am obtinut deprinderi a structura codul efficient , in acelasi timp putem sa ascundem detaliile
de implementare a unor algoritmi si functii.
3)Am observant utilitatea tipului abstract de date in proiectarea codului si programului ca unitate.

Bibliografie
1. Lucrarea de laborator nr.1 la SDA pentru studenţii an. 1 CR, RM, FCIM, UTM. 2019
2. Conspectul prelegerilor cursului Structuri de date și algoritmi pentru studenții grupei CR-
181. Lector dr., conf. univ. M. Kulev. Chișinău, UTM, 2019.