sda laborator

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


long

32


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)



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)



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

sda laborator

Documents