Ministerul Educaţiei Tineretului şi Sportului din Republica Moldova
Universitatea Tehnică a MoldoveiFacultatea Calculatoare, Informatică şi Microelectronică
Catedra Informatica Aplicata
Lucrare de anLa disciplina
“Structuri de Date şi Algoritmi”
Tema:Baza de date a apartamentelor
A realizat:
A verificat:
Chisinau 201_
Cuprins:
1.Sarcina lucrarii………………………………………………............…3
2.Introducere.................................................…………………..................4
3.Noţiuni teoretice “Structuri de Date şi Algoritmi”…….........………..5
4.Descrierea instrucţiunilor,SD şi algoritmilor
folosite în program ………..................................................................….16
5.Descrierea programului.....................................................................…17
6.Schema logică……………………………………………............……..18
7.Listingul programului………………………………….........….……..22
8.Rezultatele execuţiei……………………………………...........………30
9.Concluzie............................................................................................….33
10.Bibliografie............................................................................................34
2
1.Sarcina lucrării: Elaborarea unui program care permite inregistrarea informaţiei existente despre oarecare apartamente şi înscrierea ei într-un fişier.Programul va permite manipularea cu toata informatia stocata:
Inregistrarea unui apartament nou; Cautarea dupa mai multe cimpuri Sortarea dupa mai multe cimpuri Editarea datelor referitoare unui apartament.Toate aceste optiuni vor fi accesate dintr-un meniu la dorinta persoanei.
3
2.Introducere:
Limbajul C este unul dintre cele mai răspîndit limbaj de programare şi unul din cel mai comod şi
accesibil model de programare. Din experienţa proprie pot afirma că înainte de a începe să studiez acest
limbaj îmi era foarte greu, iar acum spun că mai simplu limbaj nu cred că există. Este un limbaj
structurat , cu largi posibilităţi, creat de un programator pentru programatori. El nu este o invenţie
artificială, ci o consecinţă a aspiraţiei programatorilor spre un limbaj mai bun.
A fost inventat şi inplementat de Dennis Ritchie pe DEC PDP-11, folosind sistemul de operare UNIX
şi este rezultatul unui proces de dezvoltare care a început cu un limbaj mai vechi numit BCPL, creat de
Martin Richards. BCPL a influienţat limbajul numit B, inventat de Ken Thompson şi a condus la
apariţia limbajului C, în anii 1970.
Acest limbaj nou a fost descris mai amănunţit în lucrarea “The C programming Language ” de Brian
Kernighan şi D. Ritchie in 1970. Datorită popularităţii căpătate în 1983 a fost organizat un comitet care
să creeze srandartul ANSI pentru C. La ora actuală , standartul ANSI C este complet, toate
compilatoarele s-au conformat deja cu dînsul.
Deoarece se consideră că programarea în limbajele de asamblare este o sarcină anevoioasă, a existat
necesitatea apariţiei unui limbaj care să poată fi utilizat mai uşor şi în acelaşi timp să ofere aceeaşi
eficienţă ca şi limbajele de asamblare. Acesta e şi motivul pentru care C a fost iniţial proiectat. El
combină cu succes structurarea din limbajele de nivel înalt cu puterea şi eficienţa din limbajele de
asamblare.
Lucrarea în cauză este efectuată anume cu ajutorul acestui limbaj şi constă în aplicarea pe larg a
posibilităţilor sale. Am încercat deasemenea să modelez şi să structurez conţinutul programului
conform ortografiei şi lexicului de programare, introducînd în locurile cuvenite comentariile respective
cît şi unele funcţii standart C sau ale utilizatorului. Cît de bine mi-a reuşit voi da prioritate de a alege
profesorului calificativul, însă sper totodată că lucrarea să fie apreciată la justa valoare.
4
3.Noţiuni teoretice “Structuri de Date şi Algoritmi”
3.1.Generalităţi despre fişiere
Mai întîi voi prezenta noţiunea de ‘stream’. În C un stream este o interfaţă logică între computer şi
unul din diferitele perifericele sale dar, în general între computer şi un fişier. După cum defineşte
limbajul C noţiunea de fişier, el se poate referi la un fişier disc, ecran, tastatură, port, fişier bandă, etc.
Deşi fişierele diferă ca formă stream-urile sînt aceleaşi. Un stream este asociat unui fişier cu ajutorul
comenzii ‘open’ şi eliberat de el prin intermediul ‘close’. Există două tipuri de stream-uri: binar şi text.
Stream-ul text se utilizează pentru lucrul cu caractere ASCII. Trebuie de remarcat însă, că atunci cînd
lucrăm cu un stream text apare translatorul de caractere, astfel întîlnindu-se cu un caracter ‘newline’, de
exemplu, el este convertit într-un cod ‘caricatură’, deacea nu întotdeauna ceea ce vom tasta la monitor va
fi tipărit în fişerul text. În cazul celor binare translatorul nu apare, în fişier înscriindu-se fiecare bit.
Pentru a deschide un fişier şi a-l asocia unui stream se utilizează funcţia fopen( ); al cărei prototip este
FILE *fopen(char *fname, char *mode);
unde:
fopen( ); foloseşte fişierul header STDIO.H,
fname- este un pointer către numele fişierului ce va fi deschis,
mode- este un pointer către un şir şi care determină în ce mod va fi accesat fişierul. Unele din
aceste valori, cele mai frecvent utilizate sînt : ‘r’-deschidere pentru citire, ‘w’-pentru creare, ‘a’-
adăugare, etc. Dacă fopen( ); eşuează atunci valoarea returnată de ea va fi un pointer NULL. Dacă vom
încerca să deschidem un fişier pentru a adăuga în el careva date, iar el nu există, atunci fişierul va fi
creat. Cînd se va accesa un fişier existent cu ‘w’ atunci informaţia din el va fi irevocabil pierdută în
acelaşi timp creîndu-se unul nou. Un fişier deschis în prealabil poate fi închis cu funcţia fclose( ); al cărei
prototip este :
int fclose ( FILE *fp); această funcţie are menirea de a dezactiva stream-ul de la fişier.
În ideea de a spori eficienţa , datele sînt scrise pe disc după cum urmează:ele sînt depuse într-un
buffer pînă cînd cantitatea de informaţie este echivalentă cu cantitatea de informaţie ce poate fi scrisă pe
un sector de disc, şi apoi bufferul este scris fizic pe disc. Atunci cînd este apelată funcţia fclose ( ); ea scrie
automat informaţia conţinută în bufferul parţial plin. Această operaţie este numită flushing the buffer.
Odată deschis în fişier se pot efectua atît schimbări cît şi citire, scriere, etc. Pentru a scrie careva date
în fişier de regulă se utilizează următoarele funcţii: fgetc( FILE *fp), fscanf(FILE *fp, char
*control_string… ), fread( void *buffer, size_t size,size_num size, FILE *fp); fgetc( ) citeşte din fişier
următorul byte ca un unsigned char şi îl returnează ca un întreg. Motivul este acela că dacă apare o
eroare fgetc( ) returnează EOF care este o valoare întreagă, aceiaşi valoare returnîndu-se şi în cazul
5
sfîrşitului de fişier. Funcţia fscanf ( ) are puţină prioritate deoarece pot fi citite date din fişier cu un
anumit specificator de format. Funcţia fread( ) este cea mai puternică dintre funcţiile de citire,ea
cititeşte din fişier obiecte, fiecare obiect avînd lungimea size byte într-un ‘buffer’ punctat de buffer.
Acelaşi lucru, numai că scriu în fişier îl execută şi funcţile fpuc(), fprinf(),fwrite().
Deasemenea C ne oferă posibilitatea de a citi/scrie un fişier în mod secvenţial. Aceasta se realizează cu
ajutorul funcţiei fseek(FILE *fp, long offset,int origin); valoarea lui de orig
ine poate fi una din SEEK_CUR, SEEK_SET, SEEK_END. Locaţia curentă poate fi determinată cu
ajutorul funcţiei ftell(FILE *fp); În general aşa mod de acces se foloseşte pentru fişierele binare,însă
există o situaţie cînd putem folosi fseek() pentru un fişier text şi anume cînd căutăm o poziţie determinată
anterior cu ftell() folosind SEEK_SET ca origin. De remarcat un lucru important aici: orice fişier text
poate fi deschis ca fişier binar, deci restricţii la accesarea random a fişierelor text nu sînt.
Un fişier poate fi şters cu ajutorul funcţiei remove(char *file_name), iar poziţionarea la locaţia iniţială
fără a închide fişierul se va efectua cu funcţia rewind(FILE *fp);
Tot aici aş face o mică referinţă la stream-urile standart C. Cînd un program C este lansat în execuţie
în mod automat sînt deschise cinci streamuri şi anume: standart input (stdin), standart output (stdout),
standart error (stdeer),unul auxiliar,(stdaux) şi streamul pentru imprimantă (stdprn). De menţionat că
aceste stream-uri nu pot fi închise cu fclose(), ele automat se vor închide în momentul terminării
execuţiei.
3.2. Alocarea dinamică
Alocarea dinamică este procesul prin care memoria este alocată, după necesităţi, în timpul execuţiei
programului. Memoria alocată poate fi folosită pentru o varietate de scopuri, cum ar fi spre exemplu un
procesor de texte : el va încerca să permită utilizatorului să editeze documente cît mai mari posibile.
Dacă nu s-ar aloca memorie în timpul execuţiei ci la compilare, atunci volumul de memorie va fi
cunoscut apriori şi , deci, insuficient la un moment oarecare.
Alte utilizări ale alocării dinamice includ listele înlănţuite şi arborii binari. Principalele funcţii pentru
alocare de memorie în C sînt malloc (size) şi calloc (size); Eliberarea memoriei se execută cu ajutorul
funcţiei free (*ptr); size este volumul de bytes dorit spre alocare. Aceste funcţii folosesc fişierul header
STDLIB.H. Memoria este alocată dintr-o regiune numită heap, care se întinde între zona programului şi
stivă. Întru cît heap-ul are o lungime finită, o cerere de alocare poate eşua în caz de insuficienţă de
memorie. Cînd un program îşi termină execuţia, memoria alocată este eliberată automat.
3.3.Structuri şi reuniuni
O structură reprezintă un conglomerat de tipuri de date unite sub un nume comun. Spre deosebire de
tablouri, aici fiecare element numit cîmp poate avea tipul său propriu, care poate diferi de tipul oricărui
element. În C o structură se defineşte după cum urmează : struct tag_name { type element_1;
6
type elment_2;
type elemnt_n;} var_list
unde, cuvîntul cheie struct informează compilatorul despre noua structură creată, tag_name-tipul
structurii, var_list – o listă de variabile de tip tag_name. Pentru scriere afişare se folosesc funcţiile
standart de citire şi afişare printf() şi scanf(), cu deosebirea că se va specifica mai întîi numele variabilei
apoi cîmpul dorit delimitate prin punct. De asemenea, pentru o eficienţă mai mare se poate indexa
numele variabilei de tip structură astfel creîndu-se un tablou de astfel de variabile. În aceiaşi manieră
cum declarăm un pointer către un tip de date predefinit putem declara unul sau mai mulţi pointeri unei
structuri şi accesarea elementelor se va efectua nu cu operatorul ‘.’ ci cu ajutorul operatorului ‘->’.
O altă particularitate a structurilor este următoarea: două structuri pot fi incluse una în cealaltă ele
funcţionînd exact după acelaşi principiu.
C permite o variaţiune pentru elementele unei structuri, numită cîmp de biţi. Un cîmp de biţi este un
element al unei structuri, care permite accesul la unul sau mai mulţi biţi. Folosind cîmpurile de biţi se
poate accesa prin nume unul sau mai mulţi biţi dintr-un octet sau cuvînt. Un cîmp de biţi se declară
practic în mod analog cu structurile ordinare, specificîndu-se marimea dorită pentru fiecare cîmp.
În C, o reuniune este o zonă de memorie ce poate fi accesată de două sau mai multe variabile.
Variabilele ce pot accesa această zonă de memorie pot avea tipuri diferite. Este important de menţionat
că dimensiunea unei reuniuni este fixată în timpul compilării şi este suficient de mare pentru a putea
conţine cel mai lung element.
3.4Generalitati
Limbajul C este un limbaj de programare cu destinatie generala putand rezolva probleme tehnico-
stiintifice, prelucrari de date, analize ale unor variabile determinate experimental sau poate fi folosit
pentru scrierea programelor sistem. El a aparut in conjunctie cu dezvoltarea sistemului de operare
UNIX in 1972 pe masini DEC PDP-11, sistem de operare care este scris direct in C (13.000 de linii are tot
sistemului de operare, din care doar 800 sunt scrise in limbaj de asamblare). De aici rezulta
portabilitatea limbajului, adica posibilitatea transferarii programelor C de pe un tip de calculator pe
altul.
Caracteristici fundamentale ale limbajului:
· asigura programarea structurata
· este un limbaj de nivel inalt, dar permite si facilitati ale limbajului de
asamblare cum ar fi lucru pe biti sau accesul la porturi
· ofera posibilitatea de a scrie programe foarte compact
· permite lucrul cu functii care pot returna diferite tipuri de date, etc.
Etapele dezvoltarii unei aplicatii in limbajul C a)
7
a) Editarea - are ca efect generarea unui fisier cu extensia .C, numit fisier sursa sau program sursa,
care contine textul programului editat in conformitate cu regulile sintactice si semantice ale limbajului.
b) Compilarea - are rolul de a transforma programul sursa intr-un program obiect cu extensia .OBJ
prin interpretarea fiecarei instructiuni din fiserul sursa C si generarea secventei de instructiuni
corespunzatoare in cod masina. Programul care face compilarea se numeste compilator si el poate utiliza
anumite biblioteci de functii.
c) Linkeditarea - presupune "legarea" sau conectarea programului obiect cu bibliotecile de sistem sau
bibliotecile proprii utilizatorului in vederea obtinerii unui program direct executabil cu extensia EXE.
Legarea se face prin intermediul unui program numit linkeditor. De obicei mediul: editor, compilator,
linkeditor este integrat intr-un singur program care asigura toate functiile.
Orice program C este o colectie de una sau mai multe functii, din care in mod obligatoriu una este
functia main( ), numita functie principala. Comentariile se introduc in program prin incadrarea lor intre
/* si */ sau cu // la inceput de linie (la versiunile mai evoluate).
Elemente de baza ale limbajului
In continuare se prezinta principalele notiuni cu care opereaza limbajul C:
a) Nume - este o succesiune de litere sau litere si cifre folosita in scopul de a denumi sau identifica o
variabila, o functie, o structura, etc:
Exemple: n,a1,SUMA,_Suma,Indice,sirsit,str->elem1,str.el
b) Cuvinte cheie - sunt nume rezervate pentru limbaj si ele nu pot fi folosite de programator
pentru a denumi variabile sau functii. Cuvintele cheie se pot observa in Tabelul 6.1. (ANSI @ American
National Standard for Information)
Tabelul 6.1. Cuvinte cheie folosite de standardul ANSI C
auto
const
double
8
float
int
short
struct
unsigned
Break
continue
else
for
long
signed
switch
void
case
default
enum
goto
register
sizeof
typedef
volatile
char
do
extern
if
return
static
union
while
c) Tipuri de date de baza - in C se lucreaza cu valori care fie sunt constante, fie pot fi modificate in cursul
executiei programului. Valoarea variabila este accesibila indirect prin numele locatiei de memorie ce o
contine. Perechea nume - locatie poarta denumirea de variabila: locatie 1243
variabila
nume k
Informatia memorata in locatie poate fi de mai multe tipuri. Prin tip de date se intelege:
- multimea valorilor corespunzatoare tipului
- multimea operatiilor prin care valorile tipului pot fi prelucrate
9
- restrictiile de utilizare a operatorilor asupra tipurilor de date (vezi Tabelul 6.2)
Tabelul 6.2. Tipurile de baza in C
cuvant cheie
biti ocupati
semnificatie
int
16
intreg reprezentat in complement fata de 2 pe 2 octeti
short
16
intreg reprezentat in complement fata de 2 pe 2 octeti
long
32
intreg reprezentat in complement fata de 2 pe 4 octeti
Unsigned
16
intreg binar fara semn
char
8
caracter reprezentat prin codul ASCII
float
32
numar real reprezentat in simpla precizie
double
64
numar real reprezentat in dubla precizie
Constructia textuala prin care se asociaza un tip cu un nume este declaratia: de variabila, de functie,
etc.
Constructia textuala prin care o locatie de memorie se asociaza cu un nume si eventual se initializeaza
locatia cu o valoare conforma cu tipul numelui este definitia.
char ba'B'; /* cat si */
float pia3.1415; /* definitii */
int f(int); /* doar o declaratie */
d) Constante - O constanta este definita de tipul si valoarea sa. Constantele sunt determinate de
caracterele care intra in compunerea lor. Valoarea unei constante nu se poate modifica pe parcursul
executiei programului!
10
Constantele pot fi:
· intregi: sunt un sir de cifre zecimale din care prima este diferita de zero. Felul constantei intregi
(short, long, hexa) poate fi dat de literele L, l (long), U, u ( unsigned) sau x (hexazecimal):
2000u (16 biti)
2000U (16 biti)
49327 l (32 biti; unsigned)
2000 lu (32 biti; unsigned)
2000 u l (32 biti; unsigned)
0x123 (hexazecimal pe 16 biti)
0x12ab3f (hexazecimal pe 32 biti)
· flotante: se reprezinta in dubla precizie. Prezenta literelor f sau l indica simpla respectiv dubla
precizie.
123. 123
123.7 123,7
.25 0,25
78e4 78*104
1.1e-3 1.1*10-3 a0,0011
· caracter: reprezinta codificarea in ASCII a caracterului de memorat, care este plasat intre semnele
apostrof: 'a', 'A', '*'
Exceptii: i se codifica prin 'ii'
' se codifica prin 'i''
" se codifica prin 'i"'
Semnul i este folosit pentru a defini caractere negrafice:
'it' tabulator
'in' rand nou
'ir' retur de car
'if' salt la pagina noua
'ia' activare sunet
'ib' revenire cu un spatiu (backspace)
· sir de caractere: o succesiune de mai multe caractere incluse intre ghilimele. Caracterele se
pastreaza in memorie sub forma de coduri ASCII intr-o zona contigua, ultimul caracter fiind valoarea 0
(NULL), cu rol de marcaj de sfarsit de sir. Exista diferenta intre o constanta care reprezinta un caracter
si sirul de caractere care e format din acelasi caracter.
11
4.Descrierea instrucţiunilor,SD şi algoritmilor folosite în program
O funcţie este alcătuita dintr-o colecţie de instrucţiuni.
O instrucţiune este oricare linie din program care daca va fi compilata va produce o
acţiune. Unele acţiuni pot fi percepute de dumneavoastră, altele nu.
Funcţiile realizează acţiuni si pot întoarce valori. Anumite funcţii sunt gata realizate spre a
fi folosite. Sediul lor este o biblioteca de funcţii C.
Funcţii:
fseek - pozitioneza indicatorul in cadrul unui fişier,
seek_set - se poziţionează indicatorul fata de sfârşit ,
fwrite - scrie date fără formatate,
fclose - inchide un fişier,
ferror - detecteaza o eroare la scriere sau citire,
feof - detecteaza sfârşitul,
ffush - provoaca golirea buffer-ului,
fread - citeste date fără formatate,
free - elibereaza un bloc de memorie alocat anterior cu funcţiile malloc(), calloc(), realloc
(),
fscanf - citeste datele,
getche - citeste un caracter de la tastatura cu ecou.
5.Descrierea programului:
în mod general-
Programul este organizat într-o forma în care toate cele 6 funcţii (add(); afiş(); sort ();
corect (); cautare(); help(); main() ) pot fi apelate dintr-un meniu. Programul îşi începe
execuţia bineînţeles cu funcţia principala main(). Aici este apelată funcţia meniu care
12
face legătura între restul funcţiilor şi sarcina lucrării. Printr-un meniu din cadrul
acestei funcţii pot fi apelate la alegere următoarele funcţii : add(); afiş(); sort (); corect
();cautare().Ele au rolul lor in execuţia programului si îndeplinesc lucruri caracteristice
lor. Odată ce este terminată execuţia uneia din aceste funcţii se revine din nou la meniu
– adică la funcţia de unde au fost apelate. Funcţia care creează meniul primeşte un
număr variabil de parametri, primul fiind unul de tipul int şi este parametrul care
indică care element din meniu va fi selectat implicit, iar restul variabile de tip char *
sau tablouri unidimensionale, ultimul parametru fiind NULL. Această funcţie foloseşte
biblioteca stdarg.h pentru lucrul cu funcţii cu număr variabil de argumente. Funcţia
preia toţi parametri şi îi afişează sub forma unui meniu. Ea mai returnează şi numărul
de ordine a elementului selectat sau 0 dacă nu s-a selectat nimic ( s-a acţionat tasta
Esc.). În program se mai utilizează o funcţie fer(), care desenează pe monitorul
calculatorului o fereastră cu un chenar. Programul mai utilizează şi bibliotecile
standarde pentru a avea posibilitatea la lucrul cu fişierele, la gestiunea cu culori a
ecranul. În funcţa ‘help()’ este demostat într-un mod clar cum poţi să te foloseşti de
acest program. Cînd este dat programul la execuţie ne apare meniul princial din care
putem alege opţiunea dorita, pentru a ne folosi de program mai uşor pentru aevita
dificultaţile pe parcurs apelam functia help() pentru a vedea structura şi modul de
utilizare.Pentru a ieşire dintr-o funcţie oarecare tastam tasta Escape pentru a ieşi din
meniu apelaţi functia Ieşire.
13
6.Schema logică:Schema funcţională a programului:
Funcţia add( ):
14
Fisiere Selectari Aranjari IesireEditari
Inscriere
Adaugare
Corectare
Stergere
Creare
Stergere
Meniu
Stop
Start
f=fopen(DATAFILE,”w”);
START
END.
f==NULL
“Eroare la deschiderea fisieriului”
Orasul;camera;suprafata;etajul;nr.balcoane
n++;
fwrite(&list,sizeof(apartament),n,f);fclose(f);
Schema bloc a funcţiei: main().
15
Start
Meniu:
Creare
Afisare
7.Listingul programului:
#include <stdio.h>#include <conio.h>#include <string.h>#include <stdlib.h>#include <ctype.h>//elementele listei---------------------------------------------------------typedef struct apartamente_ { char orasul[20];
int camere;long suprafata;long etajul;int nr_balcoane;
} apartament;//structura ce contine lista-------------------------------------------------typedef struct List_ { apartament data;
struct List_ *Next, *Back; } List;List *First=NULL, *Last=NULL;const char *file="apartament.txt";
16
Deschidere
Adaugare
sortare
Cautare
Modificare
Eliminare
salvare
Exit
aa
d
Stop
int iConstr;int operatie;FILE *f;int alocare(apartament *item);apartament inc(apartament Constr);int adaugare_apartament(apartament Constr, int i);int creare(void);int afisare(void);int adaugare(void);int salvare(List *pFirst);int open(void);int sortare(void);int cautare(List *intrep);int modificare(void);int sterge(void);void meniu(void);void contin(List *Constr);//functiile------------------------------------------------------------------int main() {
while(1){ meniu();
fflush(stdin);switch(operatie)
{ case 1: clrscr(); puts("\n\n\tBAZA DE DATE A APARTAMENTELOR\n\n"); creare(); break;
case 2: clrscr(); afisare(); break;
case 3: open(); break;case 4: clrscr();
adaugare();clrscr(); afisare(); break;
case 5: clrscr(); sortare(); clrscr(); afisare(); break;
case 6: clrscr(); cautare(First); break;
case 7: clrscr(); modificare(); clrscr(); afisare(); break;
case 8: clrscr(); sterge(); break;
case 9: salvare(First); break;case 0: int k;
clrscr();printf("\n\tSalvati modificarile inainte de iesire?\n");printf("\n\t1- Da 2- Nu\n");scanf("%d",&k);if(k==1)
17
{ salvare(First); exit(0); }if(k==2) exit(0);
default: printf("\n\n\tEroare!!!""\n\t\tTastati o tasta pentru reintoarcere...");
getch(); break;}
}return 0;
}//alocare de memorie---------------------------------------------------------int alocare(apartament *item) { List *New_item;
New_item = (List *)malloc(sizeof(List));if(!New_item){ printf("\n\tEroare!!!"
"\n\tMai incercati o data!!!");getch(); return 0;}
New_item->data = *item;if (First)First->Back = New_item;(*New_item).Back = NULL;(*New_item).Next = First;First = New_item;return 1;
}//introducerea datelor despre apartament----------------------------------------apartament inc(apartament Constr) { fflush(stdin);
printf("\n\tLocatia apartamentului(orasul): "); scanf("%15s", &Constr.orasul); fflush(stdin); printf("\tcamere in apartament: "); scanf("%d", &Constr.camere); fflush(stdin); printf("\tsuprafata : "); scanf("%ld", &Constr.suprafata); fflush(stdin); printf("\tetajul : "); scanf("%ld", &Constr.etajul); fflush(stdin); printf("\tnr. balcoane : "); scanf("%d", &Constr.nr_balcoane); fflush(stdin); return Constr;
}//adaugare apartamente--------------------------------------------------------int adaugare_apartament(apartament Constr, int i) { int v;
do{i++;alocare(&(inc(Constr)));
18
puts("\n\tMai aveti nevoie de audaugat apartamente?"" 1 - Da, 0 - Iesire\n");scanf("%d",&v);}while (v);printf("\n\tLista cu apartamente este creata si completatata cu succes.\n\tTastati oricare tasta
pentru continuare...\n"); getch(); }//crearea listei de apartamente------------------------------------------------int creare() { apartament Constr;
int i=0,k;if (First != NULL){ printf("\n\tExista deja o lista,daca continuati "
"o pierdeti!!! \n\t1 - Continuare 0-Anulare\n");scanf("%d",&k);if (k!=1)return 0;else First=NULL;
}else{ alocare(&(inc(Constr)));
}adaugare_apartament(Constr, i);return i;
}//---------------------------------------------------------------------------int adaugare() { apartament Constr; int i=0;
adaugare_apartament(Constr, i);return i;
}//salvarea listei de apartamente------------------------------------------------int salvare(List *First) { apartament Constr; List *intrep;
int i=1;int r;intrep=First;if (f=fopen(file, "rb"))
{ printf("\n\tExista deja fisier,""veti pierde informatia. \n");printf("\n\n\tPentru revenire tastati-1 \n\tPentru continuare tastati-0\n");scanf("%d",&r);if (r) return 0;}
f=fopen(file, "wb");while(intrep){ fwrite(&intrep->data, sizeof(apartament),1,f);
intrep= intrep->Next;++i;}fclose(f);printf("\n\tLista cu apartamente este salvata cu succes""in fisier <%s>!!!", file); getch();return 0;
}
19
//deschiderea fisierului pt actiune-------------------------------------------int open() { apartament constr;
int i=0;int c;if (First != NULL){ printf("\n\tLista exista, daca continuati "
"o pierdeti!!! \n\t1 - Continuare 0-Anulare\n");scanf("%d",&c);if (!c)return 0; else First=NULL;}
if(!(f=fopen(file, "rb"))){ puts("\n\t\tCreati mai intii fisierul!!!");
getch();return 0;}
fread(&constr,sizeof(apartament), 1, f);while(! feof(f)){ alocare(&constr);
fread(&constr, sizeof(apartament), 1, f);}return (afisare());
}//continutul listei de apartamente----------------------------------------------void contin(List *intrep) { int i=1;
while(intrep){ printf(" | %2d |", i); printf(" %13s|",intrep->data.orasul); printf(" %8d|",intrep->data.camere); printf(" %9ld|",intrep->data.suprafata); printf(" %6ld |",intrep->data.etajul); printf(" %11d|",intrep->data.nr_balcoane); printf("
______________________________________________________________________\n"); intrep = intrep->Next; ++i;
} }//afisare listei de apartamente-------------------------------------------------int afisare() { int j=1;
puts("\n\t\t\tINFORMATIA DESPRE APARTAMENTE:\n");printf(" | Nr. | Orasul | camere | suprafata | etajul | nr. balcoane |\n");contin(First);printf("\n\t\tTastati o tasta pentru continuare...");getch();return (j-1);
}//sortare listei de apartamente-------------------------------------------------int sortare() { List *temp1, *temp2, *min, *prev, *Sort=NULL;
int i, j, iConstr=0,ales;iConstr=afisare()-1;
20
puts("");printf("\n\t Sortati lista dupa:\n");puts("\t 1 - orasul apartamentului");puts("\t 2 - etajul");puts("\t 3 - numarul balcoane");puts("\t 0 - Inapoi\n");scanf("%d",&ales);switch(ales) { case 1:
{ while(First != NULL) { prev = NULL;
min = temp1 = First;temp2 = First -> Next;while ( temp2 != NULL )
{ if(strcmpi(min -> data.orasul, temp2 -> data.orasul) > 0) { min = temp2; prev = temp1;
}temp1 = temp2;temp2 = temp2 -> Next;}if(prev == NULL)
First = min -> Next;elseprev -> Next = min -> Next;
min -> Next = NULL;if( Sort == NULL )
Sort = min;else { temp1 = Sort;
while( temp1 -> Next != NULL)temp1 = temp1 -> Next;temp1 -> Next = min;
}} break;
}case 2:
{ while(First != NULL){ prev = NULL; min = temp1 = First; temp2 = First -> Next; while ( temp2 != NULL ){ if(min -> data.etajul > temp2 -> data.etajul)
{ min = temp2; prev = temp1;}
temp1 = temp2;temp2 = temp2 -> Next;}if(prev == NULL)
First = min -> Next;elseprev -> Next = min -> Next;
min -> Next = NULL;if( Sort == NULL )
Sort = min;else
21
{ temp1 = Sort; while( temp1 -> Next != NULL) temp1 = temp1 -> Next;
temp1 -> Next = min;}
} break;}
case 3:{ while(First != NULL)
{ prev = NULL; min = temp1 = First; temp2 = First -> Next; while ( temp2 != NULL ){ if(min -> data.nr_balcoane > temp2 -> data.nr_balcoane)
{ min = temp2; prev = temp1;}
temp1 = temp2;temp2 = temp2 -> Next;}if(prev == NULL)
First = min -> Next;elseprev -> Next = min -> Next;
min -> Next = NULL;if( Sort == NULL )
Sort = min;else{ temp1 = Sort; while( temp1 -> Next != NULL) temp1 = temp1 -> Next;
temp1 -> Next = min;}
} break;}
case 0: break;default:
{ printf("\n\t\tNu ati ales varianta potrivita!!! \n\t");getch(); break; exit(0);}
}First=Sort;printf("\n\t\tTastati o tasta pentru continuare... "); getch();return 0;
}//cautarea in lista de apartamente----------------------------------------------int cautare(List *intrep) { int j=1; char eticheta[20]; List *Start;
Start=intrep;if (First == NULL){ printf("\n\t\tLista este vida!!!"); getch(); return 0;}printf("\n\t\tIntroduceti orasul apartamentului cautat:\n ");gets(eticheta);
22
puts("\n\t\t\tINFORMATIA DESPRE APARTAMENTE:\n");printf(" | Nr. | orasul apartament | camere | suprafata | etajul |nr_balcoane |\n");
while(Start){ if(strcmpi(Start->data.orasul, eticheta) == 0)
{ printf(" | %2d |", j); printf(" %-17s|",Start->data.orasul); printf(" %-7d|",Start->data.camere); printf(" %-10ld|",Start->data.suprafata); printf(" %-6ld|",Start->data.etajul); printf(" %11d|\n",Start->data.nr_balcoane); printf("
________________________________________________________________________\n");
++j;
} Start = Start->Next;}
printf("\n\t\tTastati o tasta pentru continuare...");getch();return (j-1);
}//modificarea listei de apartamente---------------------------------------------int modificare() { int i,k,ales;
List *Curent; apartament Constr;Curent = First;afisare();printf("\n\tIntroduceti numarul elementului pe care doriti sa-l monificati: ");scanf("%d", &ales);fflush(stdin);if (ales < 0) return 0;for (i=1; i<ales; ++i){
Curent = Curent->Next;if (!Curent)
{printf("\n\t\tEroare!!! Elementul nu este gasit!Tastati o tasta pentru continuare...");getch();return 0;}
}printf("\n\tCare cimp doriti sa modificati?"
"\n\t1- orasul apartamentului""\n\t2- camere""\n\t3- suprafata""\n\t4- etajul""\n\t5- nr. balcoane\n");
scanf("%d",&k);
switch(k){ case 1:
23
printf("\n\tIntroduceti date noi despre ");printf("\n\torasul apartamentului: ");scanf("%s",&Curent->data.orasul);fflush(stdin);break;
case 2:printf("\n\tIntroduceti date noi despre ");printf("\n\tcamere: ");scanf("%d",&Curent->data.camere);fflush(stdin);break;
case 3:printf("\n\tIntroduceti date noi despre ");printf("\n\tsuprafata: ");scanf("%ld", &Curent->data.suprafata);fflush(stdin);break;
case 4:printf("\n\tIntroduceti date noi despre ");printf("\n\tetajul: ");scanf("%ld", &Curent->data.etajul);fflush(stdin);break;
case 5:printf("\n\tIntroduceti date noi despre ");printf("\n\tnr. balcoane: ");scanf("%d", &Curent->data.nr_balcoane);fflush(stdin);break;
default: printf("\n\tNu ati ales nici o varianta potrivita!!! \n\t"); getch(); return 0;
}
return 1;}//stergere---------------------------------------------------------------------------int sterge() { int k;
List *del;if (!First){
printf("\n\t\tNu exista nici o lista de sters!!!");getch();return 0;
}printf("\n\tAceasta operatie va sterge lista de apartamente\n\t""din memorie!!!""\n\tDoriti sa stergeti lista???""\n\t1 - Da, 0- Nu\n", file);scanf("%d",&k);if (k){
while(First){
del = First;
24
First = First->Next;free(del);
}printf("\n\tLista este stearsa cu succes!!!");getch();
}
return 1; }//meniul---------------------------------------------------------------------void meniu() { clrscr(); puts("\tMENIU:"); puts("\t1 CREARE"); puts("\t2 AFISARE"); puts("\t3 DESCHIDERE"); puts("\t4 ADAUGARE"); puts("\t5 SORTARE"); puts("\t6 CAUTARE"); puts("\t7 MODIFICARE"); puts("\t8 ELIMINARE"); puts("\t9 SALVARE"); puts("\t0 EXIT"); puts("\n\tINTRODUCETI COMANDA:\n"); scanf("%d",&operatie);}
8.Concluzie:
In aceasta lucarare de curs, noi am realizat o baza de date la continutul informatiei despre apartamente.
Pentru a forma baza introducem de la tastatura toata informatia necesara, de tipul: locatia, camere,
etajul si nr. balcoane. Toata informatia introdusa se salveaza intr-un fisier. Din acest fisier mai tirziu
putem accesa orice informatie. Informatia extrasa o putem sorta dupa notiunea ceruta. Putem gasi
manualul cerut stiind orasul. Printre plusurile programului putem evidentia ca dupa finisarea lucrului in
compilator informatia se stocheaza in fisier, ceea ce ne permite in continuu sa modificam si amelioram
baza noastra de date, fara a pierde rezultatetle interioare. Acest program poate fi folosit de companiile ce
se preocupa de cautarea si sortarea apartamentelor dupa anumite cirterii.
25
9.Bibliografie:
• Eugen Rotariu, "Objective C", PC Report nr. 30 (martie 1995)
• Muslea Ionut, Initiere în C şi C++, microInformatica, Cluj-Napoca, 1993
• Ionescu Felicia C şi C++ , Teora, Bucureşti,2001
• A.Grimalschi, I. Spinei, Informatica , Limbajul Pascal, Ed. Ştiinţa,
Chişinău 2000
26