Fişiere text
Se numeşte fişier text o succesiune de caractere ASCII terminată cu caracterul ^Z . Putem considera fişierul ca fiind alcătuit din linii separate prin două caractere (cr şi lf ) şI care nu au în mod obligatoriu lungimea egală , deşi în practică de multe ori fişiere text cu o singură linie.
Fişierele text au o importanţă deosebită din două motive:
• Sunt direct afişabile
• Orice editor de texte lucrează cu fişiere de acest tip.
Structura generală a unui fişier text se observă în figura de mai jos.
Întrucât , în general , liniile nu au acelaşi număr de caractere , accesul la o anumită linie in fişier se face secvenţional (se citesc pe rând liniile , până se ajunge la linia căutată ).
În program , un fişier text se declară ca variabilă de tip predefinit şi anume text:
VAR a, b :text;
Pentru a face legătura între numele fişierului din program şi numele său de suport extern pe care se află sau se creează , se foloseşte procedura assign.
Apelul procedurii se realizează prin :
ASSIGN (nume fişier în program , ‘nume fişier pe suport extern ‘).
Exemplul 1 var a:text;
……….
assign(a,’f1.dat’)
În acest caz , fişierul va fi creat sau se va găsi în directorul în care ne aflăm şi se numeşte f1.dat.
O formă echivalentă pentru assignare de acest tip este:
Exemplul2
var a:text;
b:string;
………..
b:=’f1.dat’
assign(a,b)
Exemplul3
Fişierul se găseşte sau se va găsi pe a şi va avea numele t.txt.
var a:text;
…………
assign (a,’a:\t.txt’)
Exemplul4
Fişierul se găseşte sau se va găsi pe C în subdirectorul v al directorului h şi se numeşte util
var a:text;
…………
assign (a,c:\h\v\util).
CREAREA ŞI EXPLOATAREA FIŞIERELOR TEXT
Odată declarat şi efectuată legătura între numele său din program şi numele său depe suport extern, un fişier se poate crea. Procedura care deschide deschide un fişier pentru a fi creat este rewrite. Formula generală este:
REWRITE (variabila fişier).
Scrierea înregistrărilor în fişier se face utilizând două proceduri – WRITE şi WRITELN. pentru început, vom face scrieri şi citiri în fişier utilizând numai variabile de tip string. Din acest motiv vom prezenta o formă simplificată a procedurilor enunţate. Forma de apel simplificată a procedurii WRITELN este:
WRITELN (var Fişier, variabilă de tip string);
Procedura WRITE scrie o linie în fişier, conţinutul liniei este dat de conţinutul variabilei de tip string şi marchiază sfârşiitul de linie (CR, LF).
După ce a fost creat, fişierul se închide (se marchează sfârşiitul de line).
Inchiderea se face utilizând procedura close. Forma generală a acesteia este:
CLOSE (nume fişier).
Programul următor creează un fişier text cu mai multe linii.
program txt1;
var f:text;
a:string;
begin
assign(f,’f1.dat’);
rewrite(f);
while not eof do
begin
readln(a);
writeln(f,a)
end;
close(f)
end.
Datele sunt introduse de la tastatură .Să presupunem că introducem următoarele date:
Asdfghj(ENTER)
12weh(ENTER)
a g(ENTER)
1 ^z(ultimul caracter introdus s-a obţinut tastând (CTRL+Z).
Fişierul creat va conţine 4 linii:
Linia 1 asdfghj
Linia2 12weh
Linia3 a g
Linia4 1
Liniile sunt separate cu CR+LF. Funcţia booleană EOF ia valoarea TRUE dacă este întâlnit caracterul ^z (acesta va marca sfârşiitul introducerii datelor).
Considerăm programul următor ce creează un fişier text.
program txt3
var f:text;
a:string:
begin
assign(f,’f2.dat’);
rewrite(f);
while not eof do
begin
readln(a);
write(f,a)
end;
close(f)
end.
În acest program am înlocuit procedura WRITELN cu procedura WRITE . Consecinţa? La acelaşi şir de intrare, noul fişier text va avea o singură linie ce conţine toate caracterele introduse, mai puţin CR. Putem acum prezenta forma simplificată a procedurii WRITE. Aceasta este:
WRITE (variabilă de tip string).
Are rol de a scrie în fişier conţinutul variabilei string dar nu marchează sfârşitul de linie. Astefel, la un eventual apel ulterior al acestei proceduri se va scrie în continuarea liniei.
Este normal să şi citim fişierul creat anterior.
Pentru aceasta, trebuie prezentate alte trei proceduri: RESET, READLN, READ.
Procedura RESET deschide un fişier pentru citire şi are forma generală:
RESET (variabilă fişier)
Pentru procedurile READ şi READLN se vor prezenta forme simplificate.
Forma procedurii READLN este:
READLN (var fişier, variabilă de tip string)
Citeşte maxim 256 de caractere din linia curentă a fişierului. Dacă linia are mai puţin de 256 de caractere este citită toată iar conţinutul efectiv al variabilei de tip string va fi fişierul de caractere până la CR. Indiferent de caz, după citire se trece la linia următoare a fişierului. Funcţia booleană EOF (VARIABILĂ FIŞIER) ia valoarea TRUE dacă s-a la sfârşiitul fişierului , în caz contrar ia valoarea FALSE.
Programul următor citeşte fişierul creat cu ajutorul lui WRITELN.
program txt3;
var f:text;
a:string:
begin
assign(f,’f1.dat’);
reset(f);
while not eof do
begin
readln(f,a);
writeln(a)
end;
end.
procedura READ are forma generală :
READ (var fişier, variabila de tip string)
Pentru a înţelege exact cum funcţionează READ ne imaginăm o linie de fişier cu mai mult de 256 de caractere . După deschiderea fişierului şi plasarea la începutul acestei linii apelăm pentru prim dată READ .Vor fi citite 256 (dacă au mai rămas atâtea caractere necitite în linie) sau câte au mai rămas până la întâlnirea sfârşitului de linie .În programul txt4 se citeşte fişierul text f2.dat (cel creat pe o singură linie ).
program txt4;
var f:text;
a:string;
begin
assign(f,’f1.dat’);
reset(f);
while not eof(f) do
begin
read(f,a);
writeln(a)
end;
end.
Oare variabilele de tip string sunt singurele care se pot scrie şi citi din fişiere? Răspunsul la această întrebare este negativ , şi cum este momentul să prezentăm instrucţiunile de citire şi scriere în mod generalizat.
Atât cu READ cât şi cu READLN se pot citi mai multe tipuri de variabile :
• De tip char
• De tip string
• De tip numeric
Forma lor generală este:
READ(var nume fişier, v1[,v2,…,vn]);
READLN(var nume fisier,v1[,v2,…,vn]);
Variabilele v1…vn sunt de tipurile prezentate anterior .
Procedura READLN se execută la fel ca READ după care se face saltul la linia următoare .
Pentru a înţelege exact modul de citire (scriere) a acestei variabile , să ne imaginăm întregul fişier text(ca însuşire de caractere ASCII). De asemenea , ne imaginăm o săgeată (se numeşte pointer) care ne indică în permanenţă la care caracter am ajuns. Când deschidem un fişier pentru citire , pointer-ul indică primul caracter din prima linie a acestuia. Considerăm, de asemenea, mulţimea caracterelor ASCII împărţită în două submulţimi:
• cu rol de separare (spaţiu, CR, LF, TAB, BACKSPACE, BELL) .
• submulţimea alcătuită din restul caracterelor.
CITIREA VARIABILELOR DE TIP CHAR
Se citeşte acel caracter care se găseşte pe poziţia curentă a pointer-ului (nu interesează dacă este vorba de caractere care au un rol separator. După citire , pointer-ul avansează în fişierul cu un caracter . Că este aşa , o demonstrează programul următor:
program txt5;
var f:text;
a:char;
begin
assign(f.’f1.dat’);
reset(f);
while not eof(f) do
begin
read(f,a);
write(a)
end
end.
Acest program listează fişierul creat la începutul lucrării. Liniile apar listate exact în ordinea în care au fost introduse (se ştie că f1.dat a fost creat pe mai multe linii).
CITIREA VARIABILELOR DE TIP STRING
Aceste variabile se citesc din poziţia curentă a cursorului până este citit numărul de caractere necesar tipului sau până s-a ajuns la sfârşit de linie. Programul următor demonstrează acest fapt (dacă linia 1 a fişierului are 3 caractere , se vor tipări două pe un rând şi unul pe al doilea rând). După citirea unei astfel de variabile , pointer-ul se află sau pe caracterul ce urmează după ultimul caracter citit sau pe CR. În situaţia în care pointer-ul se află pe CR şi se forţează o nouă citire de tip string , se returnează şirul vid.
program txt6;
var f:text:
a:string[2];
b:string;
begin
assign(f,’f1.dat’);
reset(f);
read(f,a);
writeln(a);
read(f,b);
writeln(b)
end.
CITIREA –VARIABILELOR DE TIP NMERIC
Se plecă de la poziţia curentă a pointer-ului . Dacă se întâlneşte un caracter separator , pointer-ul care la următorul caracter şi procedeul se repetă până s-a ajuns la un caracter ce nu este separator sau până când s-a ajuns la sfârşit de linie. În al doilea caz , se solicită o nouă linie , iar pointer-ul sare la începutul liniei următoare . În primul caz , se tastează caracterele cuprinse între poziţia curentă a pointer-ului şi primul caracter separator. Dacă acestea se încadrează în diagrama de sintaxă pentru întreg (dacă se citeşte un tip întreg ) sau real(dacă se citeşte un tip întreg) , citirea se face , iar pointer0ul se aşează pe primul caracter separator ; dacă sintaxa nu este îndeplinită , programul se încheie cu eroare.
Exemple
Avem următoarele variabile a:integer , e:real , d:string[2].
• Se execută read (f,a,f,e); pointer-ul este poziţionat pe primul caracter din linie , iar linia este bbb12b34bbbbt (prin b am notat caracterul blanc). În urma execuţiei vom avea : a=12 , f=34 , d=bbbbt.
• Se execut[ read (f,d,e,f) , prima linie din fişier este bm iar a doua 2b3 (prin b am notat blanc). Variabila d va conţine bm ,e va conţine şirul vid , iar f va fi 2.
• Se execută read(a) iar prima linie din fişier va fi 3t (pointer-ul va fi poziţionat pe primul caracter din linie). Execuţia se încheie cu o eroare (a nu respectă tipul numeric).
Procedura READLN fără parametri de tip variabilă produce saltul pe linia următoare (exemplul READLN(F) ) , iar cu parametri , după ce a reuşit tentativa de citire se sare pe linia următoare.
Pentru scriere , se folosesc procedurile WRITE şi ERITELN .Forma generală a acestor proceduri WRITE este:
WRITE (var nume fişier , v1[v2,…,vn])
unde v1,v2,…,vn reprezintă nume de variabile sau date ce se scriu în fişier.
Procedura WRITELN are forma generală:
WRITELN(var nume fişier , v1 [v2,…,vn] ).
Parametri au aceeaşi semnificaţie ca la procedura WRITE. Spre deosebire de WRITE , după scriere procedura WRITELN încheie linia din fişier (scrie CR şi LF) şi trece pe linia următoare ( pointer-ul este poziţionat pe primul caracter al liniei următaoare ). Se pot scrie de tipul:
• Numeric (întreg sau real );
• Char;
• String;
• Boolean;
Scrierea se poate faceîn două feluri:
• Cu format implicit ;
• Cu format explicit.
SCRIEREA CU FORMAT IMPLICIT
În toate aceste cazuri , se scrie incepând din poziţia curentă a pointer-ului .
• Datele întregi se scriu cu toate cifrele semnificative , iar dacă numărul este negativ , se scrie în faţa semnului -;
• Datele reale se scriu în forma ştiinţifică (exemplu : -3.35 se scrie –3.3500000000E-01 ) care se citeşte ce numaăr (cu semn ) * 10 la puterea (cu semn) ;
• Datele de tip caracter se scriu pe o singură poziţie ;
• Datele de tip string se scriu pe o lungime efectivă a şirului;
• Pentru o dată de tip boolean se scriu TRUE sau FALSE;
SCRIEREA CU FORMAT EXPLICIT
SCRIEREA DATELOR DE TIP ÎNTREG
Pentru fiecare variabilă întreagă (prezentă în instrucţiunea de scriere ) se poate preciza numărul m de poziţii pe care se face scrierea .
Exemplu : WRITE (F,A :6) .
În cazul în care numărul de poziţii ocupate de un număr este mai mare decăt numărul m , parametrul este ignorat , iar dacă m este mai mare decât numărul de poziţii ocupate efectiv , numărul se scrie aliniat dreapta (se va ţine cont de faptul ca un număr negativ va fi precedat de semn).
SCRIEREA DATELOR DE TIP REAL
Pentru aceste date se pot preciza doi parametri m şi n.
Exemplu WRITE ( f,a:5:2)
unde a este o variabilă reală , m are valoarea 5 iar n are valoarea 2 .
Parametrul m specifică numărul de poziţii pe care se csrie data reală.
Parametrul n specifică numărul de poziţii rezervate părţii zecimale(exclusiv punctul). În cazul în care sunt prezenţi ambii parametri , numărul se scrie în forma cunoscută nouă şi anume cu punct (de exemplu 23.67) .Dacă valoarea parametrului m este prea mică (numărul ocupă mai multe poziţii) , ea este ignorată (se scrie numărul cu toate cifrele lui), numărul va fi scris rotunjit cu un număr de zecimale egal cu valoarea lui n. În cazul în care numărul aliniat dreapta (în faţă se pun blancuri). Dacă parametrul m are o valoare prea mică , numărul este rotunjit , iar dacă are o valoare prea mare , el este aliniat la dreapta.
SCRIEREA DATELOR DE TIP CARACTER
Pentru aceste date se poate folosi numai parametrul m care semnifică numărul de poziţii pe care se scrie acesta. Dacă m este mai mare decât 1 , datase scrie aliniată la dreapta , iar în faţă se pun blancuri.
SCRIEREA DATELOR DE TIP STRING
Pentru date de acest tip, se iau în considerare lungimea efectivă a şirului şi valoarea parametrului m ce specifică numărul de poziţii pe care se face scrierea. În cazul în care valoarea lui m este mai mică decât lungimea efectivă a şirului, acestea se ignoră, şirul va fi scris pe lungimea sa efectivă. Dacă valoarea lui m este mai mare decât lungimea efectivă a şirului, acesta este scris pe m poziţii aliniat dreapta, iar în faţă se pun blancuri.
CRIEREA DATELOR DE TIP BOOLEAN
Avem numai două astfel de date, TRUE şi FALSE. Şi pentru date de acest tip se poate preciza numărul de poziţii pe care să se facă scrierea. Dacă numărul de poziţii este mai mic, se ignoră, iar dacă este mai mare, acestea se scriu aliniat dreapta, în faţă se pun blancuri (ex. WRITE (f, TRUE:9)).
ALTE PROCEDURI ŞI FUNCŢII CARE LUCREAZĂ CU FIŞIERE TEXT
PROCEDURA APPEND
Această procedură are rolul de a deschide un fişier text care a creat pentru extindere (scriere la sfârşit de fişier). Forma generală este APPEND (var fişier text.
În situaţia în care fişierul nu există , se generează o eroare de intrare ieşire.
Pentru un fişier deschis cu APPEND este posibilă numai operaţia de scriere. În exemplul care urmează , se adaugă alte linii fişieruului f1.dat.
program txt;
var f:text;
a:string;
begin
assign(f,’f1.dat’);
append(f);
while not eof do
begin
readln(a);
writeln(f,a)
end;
close(f);
end.
FUNCŢIA EOLN
Are ca parametru formal o valoare fişier şi este de tip boolean. La execuţie , funcţia întoarce valoarea TRUE dacă pointer-ul este la sfârşit de linie şi FALSE în caz contrar.
In progranul care urmează se tipăreşte ultumul caracter al primei linii pentru un fişier text crteat anterior.
program txt7;
var f:text;
a:char;
begin
assign(f,’f1.dat’);
reset(f);
while not eoln(f) do read(f,a);
writeln(a);
close(f)
end.
FIŞIER TEXT STANDARD
FIŞIERELE INPUT ŞI OUTPUT
Aceste fişiere se consideră declarate (nu mai este necesară declararea lor ca fişier text). Ele se asignează în mod automat la tastatura INPUT şi monitor OUTPUT. În situaţia în care procedurile READ, READLN, WRITE, WRITELN nu au precizată la apel variabila fişier, aceasta este considerată automat IMPUT pentru procedurile de citire şi OUTPUT pentru procedurile de scrieere.
Toate operaţiile de citire şi scriere efectuate în programele din capitolele anterioare au fost făcute cu aceste fişiere.
FIŞIERUL PRN
Dacă dorim ca rezultatele programului să fie scrise la imprimantă, folosim fişierul standard PRN. Aceasta se declară în cadrul proce4durt5ii ASSIGN ca nume extern pentru fişier.
Vom lua, ca exemplu , o imprimantă care scrie pe hârtie de format A4 (coală normală de scris). Se consideră că pe o astfel de coală se pot scrie 55 de rânduri. În programul care urmează vom scrie în primele două rânduri texte, după care se sare la pagină nouă (se scriu 53 de rânduri vide cu ajutorul procedurii WRITELN) .
program txt;
var imp:text;
i:integer;
begin
assign(imp,’prn’);
rewrite(imp);
writeln (imp,’am scris un text’);
writeln(imp,’am scris alt text’);
for i:=1 to 53 do writeln(imp);
close(imp);
end.
Regulile prin care se scriu diversele date la imprimantă sunt aceleaşi ca pentru oricare alt fişier text.
VALIDAREA OPERAŢIILOR DE INTRARE / IEŞIRE
Din categoria operaţiilor de intrare / ieşire fac parte citirile , scrierile în şi din diverse fişiere dar şi operaţii cum ar fi deschiderea unui fişier pentru citire sau scriere. Nu întotdeauna aceste operaţii se desfăşoară în mod normal. Să ne imaginăm următoarea situaţie : programul nostru citeşte o variabilă numerică şi noi, din greşeală introducem o literă . Programul se va opri şi va da un mesaj de eroare. Poate veţi spune
Că trebuie să fim atenţi la introducerea datelor . Dar sunt situaţii în care erorile sunt inerente . De exemplu, pentru a crea un fişier ce se foloseşte în practică (şi nu unul didactic, care are doar câteva linii) se introduc mii de date. Este aproape imposibil ca la introducerea lor să nu se greşească –caz în care ar trebui să o luăm de la capăt. Ce este de făcut pentru preîntâmpinarea acestor situaţii? Limbajul Turbo Pascal ne permite să prevedem în program astfel de cazuri şi să acţionăm în consecinţă.
Presupunem că programul pe care l-am conceput nu a prevăzut posibilitatea ca operaţiile de intrare / ieşire să nu se desfăşoare în mod corespunzător. În acest caz programul se încheie cu eroare (se afişează codul erorii). Într-un prim pas , este necesar ca programul să nu se oprească într-o astfel de situaţie. Pentru aceasta există o posibilitate şi anume directiva de4 compilare {$I} ce poate avea două valori {$i-} şi {$i+} . Directiva {$i-} determină ca toate operaţiile de intrare / ieşire cuprinse între ea şi directiva {$I+} sau sfârşitul programului să nu determine întreruperea acestuia.
Ne putem întreba ce realizăm dacă procedăm astfel , pentru că oricum rezultatele vor fi eronate. Există posibilitatea să determinăm dacă operaţia de intrare / ieşire a reuşit sau nu . Funcţia IORESULT (funcţie de tip byte care se găseşte prezentă în unit-ul SYSTEM ) ne ajută în acest sens. În cazul unei opraţii reuşite , la execuţie funcţia ia valoarea 0, în caz contrar ia valoarea diferită de 0. Pin testul valorii pe care o furnizează această funcţie avem posibilitatea să reluăm operaţia până când ea reuşeşte. În cele ce urmează se va da mai multe exemple ca re au menirea să convingă de utilitatea de a lucra în acest mod.
Exemplul 1:
program v1;
var a:=integer;
begin
repeat
write(‘a=’);
{$i-} readln(a) {$i+}
until ioresult=0
end.
Exemplul 2:
Să presupunem că se doreşte crearea unui fişier text. Deschiderea lui pentru scriere se face utilizând procedura REWRITE. În situaţia în care pe suport se găseşte alt fişier cu acelaşi nume , acesta din urmă este şters. Este bine să fim avertizaţi în acest sens. Prin urmare , se încearcă deschiderea fişierului care urmează a fi creat (prin RESET). Dacă el se găseşte pe suport , funcţia IORESULT va lua valoarea 0 iar în caz contrar va lua valoarea 1. În cazul în care aceasta ia valoarea 0, operatorul va decide dacă fişierul se va crea(deci cel vechi se distruge) sau nu.
program v2;
var f:text;
a:string;
rasp:char;
begin
write(‘Dati numel fisierului ce se va crea ‘);
readln(a);
assign(f,a);
{$i-} reset(f) {i+};
if ioresult<>0 then
begin
write (Fisierul se gaseste pe suport.Continuam? (y/n’);
readln(rasp)
end;
if rasp=’y’ then
begin
writeln (‘Fisierul a fost sters’);
rewrite(f)
end
end.
Exemplul 3:
Dorim să scriem un text la imprimantă . Există mai multe motive pentru care tentativa noastră poate eşua:
• Imprimanta nu este deschisă;
• Imprimanta nu este ON LINE;
• Nu am pus hârtie.
În toate aceste cazuri , un program neprotejat se opreşte . Programul care urmează scrie mesajul până când operaţia de scriere reuşeşte (IORESULT ia valoarea 0).
program v3;
var imp:text;
begin
assign(imp,’prn’);
rewrite(imp);
repeat
{$i-} writeln(imp, ‘un mesaj’);
until ioresult=0
end.
ALTE TIPURI DE VALIDĂRI
VALIDAREA NATURII DATELOR
Din acest punct de vedere datele se pot clasifica astfel:
• Date numerice ( numere întregi şi reale);
• Date alfabetice (nu conţin cifre, sunt formate din literele mari şi mici ale alfabetului);
• Date alfanumerice (conţin atât literele alfabetului cât şi cifre).
Să presupunem că se doreşte citirea unor nume de persoane . Evident, acestea sunt date alfabetice. Cum putem testa dacă nu cumva , din greşeală , în cadrul unor nume nu s-au introdus şi cifre? Exemple de acest tip ar putea continua.
TESTATREA NATURII NUMERICE A DATELOR
O modalitate de test numeric a fost deja prezentat (prin introducerea unei litere la citirea unei variabile numerice funcţia IORESULT ia valoarea 0).
Există şi o altă modalitate de a efectua acest test. Pentru aceasta se procedează astfel :
• Citirea datei se face într-o variabilă de tip string (deci se pot introduce orice fel de date)
• Se face o tentativă de conversie din tipul string în tipul numeric solicitat (procedura VAL)
• În situaţia în care tentativa reuşeşte , data introdusă a fost numerică
• În caz contrar , data introdusă nu a fost numerică deci se reia citirea .
Această modalitate de lucru prezintă şi mari avantaje de a ne oferi posibilitatea să tastăm numărul de cifre introduse , prin analiza lungimii şirului de tip string (funcţia LENGTH)
În programul care urmează se citeşte o dată care trebuie să fie numerică şi să fie scrisă pe trei cifre (care pot fi şi 0).
program v4;
var a:string;
c_er,b:integer;
begin
repeat
write(‘b=’);
readln(a);
val(a,b,c_er)
until (c_er=0)and(length(a)=3)
end.
TESTAREA NATURII ALFABETICE A DATELOR
Pentru acest test se procedează astfel:
• Literele mari şi mici ale alfabetului alcătuiesc o mulţime şi se declară constante
• Citirea se face într-o variabilă de tip string
• Se testează toate caracterele şirului citit
• Dacă cel puţin un caracter nu aparţine mulţimii considerate , citirea se reia.
În programul care urmează se explică acest test.
program v5;
const alfabet=[‘a’..’z’,’A’..’Z’];
var a:string;
i,c_er:integer;
begin
repeat
c_er:=0;
write(‘dati data ‘);
readln(a);
for i:=1 to length(a) do
if not (a[i] in alfabet thenc_er:=1
until c_er=0
end.
Datele alfanumerice nu necesită validitate.
Toate tipurile de validare prezentate aici sunt valabile indiferent de tipul de fişier ales.
FIŞIERE CU TIP
Fişierele cu tip sunt construite din articole cu lungime fixă , de acelaşi tip , motiv pentru care se mai numesc şi fişiere cu prelucrare la nivel de articol.
Tipul fişier cu tip se declară conform figurii de mai jos:
EXEMPLE de declarare
• Se declară două fişiere ale căror articole sunt construite dintr-un singur octet:
type fisoct=file of byte
var f1,f2:fisoct;
Aceleaşi două fişiere se pot declara printr-un tip anonim:
var f1,f2 : file of byte
• Se declară un fişiere ale carui articole sunt numerice îtregi :
type fisint=file of integer;
…………………………..
var a:fisint;
• Se declară un fişier cu articole de tip record:
type inreg=record
nume:string[30];
varsta:bvyte
end;
fisier=file of inreg;
var f:fisier;
Ca şi pentru fişierele text , procedura ASSGN face legătura între numele fişierului din program şi numele de pe suportul extern. Forma generală este :
ASSIGN(nume fişier în program,’nume estern’).
Numele extern este de tip string.
Exemplu : assign (f,’fişier’) unde f reprezintă numele variabilei fişier în program ier ‚fişier’ reprezintă numele sub care aceasta se găseşte pe suport.
CREAEA FIŞIERELOR CU TIP
Pentru a putea realiza o astfel de operaţie , trebuie cunoscute câteva proceduri şi funcţii.
Procedura REWRITE are forma generală:
REWRITE (var fişier)
şi are rolul de a deschide un fişier spre a fi creat în situaţia în care există un fişier cu acelaşi nume , acesta se distruge. Din acest motiv , este bine să se facă testul de existenţă .
Procedura WRITE are forma generală:
WRITE(var fişier,v1…vn)
Parametrii v1…vn reprezintă variabile ce vor fi scrise în fişier . Principiul de execuţie este următorul:
• Se scrie prima înregistrare preluată din cadrul variabilei v1;
• Se scrie a doua înregistrare preluată din cadrul variabilei v2
.
.
.
• Se scrie înregistrarea n din cadrul variabilei vn;
• Pointer-ul se poziţionează pe următoarea înregistrare.
Funcţia booleană EOF are forma generală:
EOF (var fişier)
Şi returnează TRUE dacă pointer-ul se găseşte la sfârşit de fişier, în caz contrar returnează FALSE.
Procedura CLOSE are forma generală:
CLOSE (var fişier)
Şi are rolul de a închide fişierul.
În programul care urmează , după fiecare înregistrare citită da la tastatură şi scrisă în fişier, utilizatorul este întrebat dacă să se continue sau nu. După ce au fost scrise toate înregistrările, fişierul se închide.
program ft1;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
c:char;
begin
assign(f1,’fdat’);
rewrite(f1);
repeat
write(‘nume’);
readln(inreg.nume);
write(‘varsta’);
readln(inreg.varsta);
write(f1,inreg);
write(‘comtinuati ? (y/n) ‘);
readln (c);
until c=’n’;
close(f1)
end.
Evident , nu este obligatoriu ca un fişier să se creeze de la tastatură , e3l poate fi creat utilizând informaţii preluate din alte fişiere, însă pentru aceasta trebuie să ştim cum se citeşte un fişier.
Pentru a fi citit, un fişier se deschide cu ajutorul procedurii RESET, care are forma generală:
RESET(var fişier).
Procedura READ are rolul de a citi una sau mai multe înregistrări ale unui fişier. Forma generală a acestei proceduri este:
READ (var fişier, v1,v2,…vn).
Principiul de execuţie este următorul:
• Se citeşte înregistrarea pe care se află pointer-ul în variabila v1;
• Pointer-ul trece pe următoarea înregistrare care este citită în variabila v2;
• Procedeul continuă până când este citită variabila vn şi pointer-ul se plasează pe următoarea înregistrare necitită sau pe marcajul de sfârşit de fişier.
Programul care urmează citeşte fişierul creat anterior şi îl tipăreşte pe monitor.
program ft2;
type inr=record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
begin
assign(f1,’fdat’);
reset(f1);
while not eof(fi) do
begin
read (f1,inreg);
writeln(inreg.nume, ‘ ‘,inreg.varsta)
end;
close(f1)
end.
Aplicaţie:
Concatenare de fişiere
Dacă se dau două fişiere , prin operaţia de concatenare a lor se înţelege crearea cu ajutorul lor a unui al treilea fişier care conţine înregistrările celor două în ordinea următoare: înregistrările primului fişier urmate de înregistrările celui de-al doilea fişier.
Programul care urmează concatenează două fişiere. În esenţă , pentru a realiza această operaţie, se procedează astfel:
• Se deschid toate fişierele (două pentru citire , unul pentru scriere);
• Toate înregistraările primului fişier se copiază în cadrul celui de-al treilea;
• Toate înregistrările celui de-al doilea fişier se copiază, în continuare, în cadrul celui de-al treilea;
• În final, se închid cele trei fişiere.
program ft3;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1,f2,f3:fisier;
begin
assign(f1,’fdat’);
assign(f2,’fdat1′);
assign(f3,’fdat2′);
reset(f1);
reset(f2);
rewrite(f3);
while not eof(f1) do
begin
read (f1,inreg);
write(f3,inreg);
end;
while not eof(f2) do
begin
read(f2,inreg);
write(f3,inre4g);
end;
close(f1);
close(f2);
close(f3);
end.
PROCEDURA SEEK ŞI FUNCŢIA FILESIZE
Înregistrările unui fişier cu tip au aceeaşi lungime. Fiecărei înregistrări i se poate asocia un număr de ordine cuprins între 0 (pentru prima înregistrare) şi n-1 (pentru înregistrarea n). Datorită lungimii fixe a înregistrărilor, acestea pot fi accesate direct (se poate poziţiona pointer-ul pe înregistrarea cu un anumit număr de ordine). Este firesc să fie posibil acest lucru, întrucât dacă se doreşte să poziţionăm pointer-ul pe înregistrarea i, adresa de început a acesteia (a primului ei octet) se obţine înmulţind lungimea unei înregistrări cu i (înregistrările sunt numerotate între 0 n-1).
Procedura SEEK are forma generală:
SEEK (var fişier, număr înregistrare)
Şi are rolul de a poziţiona pointer-ul pe înregistrarea cu numărul de ordine ’număr înregistrare’ .
Funcţia FILESIZE având forma generală :
FILESIZE (var fişier)
Este tip longit şi furnizează numărul de componente pe care le are fişierul. Dacă din rezultatul furnizat de această funcţie se scade 1, obţinem numărul de ordine al ultimei componente din fişier.
În programul care urmează , se listează un fişier utilizând funcţia FILESIZE
program ft4;
type inr= record
nume :string[10];
varsta:byte
end;
fisier=file of inr;
var inreg;inr;
f1:fisier;
i:integer;
begin
assign(f1,’fdat2′);
reset(f1);
for i:=0 to filesiye(f1)-1 do
begin
read (f1, inreg);
writeln(inreg.nume, ‘ ‘,inreg.varsta);
end;
close(f1)
end.
ADĂUGAREA DE ARTICOLE
Fiind dat un fişier , se cere să-i adăugăm un număr de articole. În programul următor, adăugarea articolelor se face la sfârşitul fişierului (deci după toate articolele conţinute deja în fişier).
Pentru a realiza acest lucru se poziţionează pointer-ul pe marcajul sfârşitului de fişier (seek(f1,filesize(f1)), iar înregistrările care se adaugă sunt citite de la tastatură şi scrise în continuare. Se observă că deschiderea fişierului a fost făcută cu RESET (o deschidere cu RESET permite şi scrierea în fişier).
program ft5;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
dfghjkl;c:char;
begin
assign(f1,’fdat2′);
reset(f1);
seek(f1,filesize(f1));
repeat
write(‘nume’);
readln(inreg.nume);
write(‘varsta’);
readln(inreg.varsta);
write(f1,inreg);
write(‘continuati ? (y/n) ‘);
readln (c);
until c=’n’;
close(f1)
end.
De multe ori , adăugarea noilor înregistrări trebuie făcută în interiorul fişierului (după o anumită înregistrare). Limbajul Turbo Pascal nu permite ca această operaţie să se facă în mod direct . Din acest motiv , pentru a realiza ceea ce dorim se procedează în felul următor:
• Se deschide un al doilea fişier;
• Se copiază în acesta toate înregistrările care se găsesc plasate înaintea celor care se adaugă ;
• Se scriu , în continuare, noile înregistrări;
• Se copiază restul înregistrărilor (din vechiul fişier);
• Vechiul fişier este şters , iar noul fişier capătă numele vechiului fişier.
Programul care urmează citeşte de la tastatură înregistrările ce se adaugă .Pentru ştergere, se foloseşte procedura ERASE care are forma generală:
ERASE (var fişier, ‘nume’)
unde ‘nume’ este un parametru de tip string şi reprezintă noul nume al fişierului.
program ft6;
type inr=record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1,f2:fisier;
c:char;
i:integer;
begin
assign(f1,’fdat2′);
reset(f1);
assign(f2,’fis1′);
rewrite(f2);
for i:=1 to 3 do
begin
read(f1,inreg);
write(f2,inreg);
end;
repeat
write(‘nume’);
readln(inreg.nume);
write(‘varsta’);
readln(inreg.varsta);
write(f2,inreg);
write(‘continuati ? (y/n) ‘);
readln (c);
until c=’n’;
while not eof(f1) do
begin
read(f1,inreg);
write(f2,inreg)
end;
close(f1);
close(f2);
erase (f1);
rename(f2,’fdat2′)
end.
De multe ori, este necesar să modificăm un câmp (sau mai multe) al unei înregistrări (sau ale mai multor înregistrări). Programul ft7 face modificare 1n câmpul vârstă al înregistrării cu n unele de ordine 4. Pentru aceasta , se procedează în felul următor:
• După deschiderea fişierului (cu RESET) , poziţionăm pointer-ul pe înregistrarea care urmează a fi modificată (cu SEEK);
• Se citeşte înregistrarea;
• Se face modificarea în câmpul corespunzător;
• Întrucât, la citire, pointer-ul s-a poziţionat pe înregistrarea următoare, acesta se repoziţionează pe înregistrarea care a fost citită;
• Această înregistrare este suprascrisă (câmpul a fost modificat) cu procedura WRITE.
program ft7;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
begin
assign(f1,’fdat2′);
reset(f1);
seek(f1,4);
read(f1,inreg);
inreg.varsta:=70;
seek(f1,inreg);
close(f1)
end.
Cum putem şterge una sau mai multe înregistrări ale fişerului? În practică, pentru aceasta se poate proceda în două feluri:
• Înregistrările se şterg fizic;
• Înregistrările se şterg logic.
Ştergerea fizică nu este posibilă decât dacă prin a crea un nou fişier care să nu conţină înregistrările care se şterg. Vechiul fişier este şters iar noul fişier capătă numele fişierului iniţial (cel din care s-au şters înregistrări). Programul care urmează şterge înregistrarea a patra din fişier.
Din păcate , această modalitate de ştergere cere mult timp (pentru a şterge o înregistrare am creat un alt fişier).
program ft8;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1,f2:fisier;
i:integer;
begin
assign(f1,’fdat2′);
assign(f2,’fman’);
reset(f1);
rewrite(f2);
for i:=1 to 3 do
begin
read(f1,inreg);
write(f2,inreg)
end;
seek(f1,filepos(f1)+1);
while not eof(f1) do
begin
read(f1,inreg);
write(f2,inreg)
end;
close(f1);
close(f2);
erase(f1);
rename(f2,’fdat2′)
end.
end.
Ştergerea logică are la bază următorul mecanism: fiecare înregistrare a fişierului în care urmează să se facă ştergeri are un câmp în plus şi anume un indicator de ştergere (is). Convenim ca acest câmp să conţină valoarea 1 în situaţia în care înregistrarea nu este ştearsă şi să conţină valoarea 0 în caz contrar. În acest fel , a şterge o înregistrare înseamnă să modificăm câmpul is (va lua valoarea 0) . Această modalitate de ştergere este mult mai rapidă , dar prezintă dezavantajul că înregistrările şterse rămân pe suport (se ocupă spaţiu).
Următoarele trei programe creează , listează şi efectuează ştergeri pentru un fişier.
Observaţie: orice program care lucrează cu un astfel de fişier trebuie să testeze, pentru fiecare înregistrare, valoarea indicatorului de ştergere (nu vor fi supuse prelucrării înregistrări şterse).
program ft9;
type inr=record
is:byte;
nume:string[10];
varsta:byte;
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
c:char;
begin
assign(f1,’fdat2′);
rewrite(f1);
repeat
write(‘nume’);
readln(inreg.nume);
write(‘varsta’);
readln(inreg.varsta);
inreg.is:1;
write(f1,inreg);
write(‘continuati ? (y/n) ‘);
readln(c);
until c=’n’;
close(f1)
end.
program ft10;
type inr= record
is:byte;
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
c:char;
begin
assign(f1,’fdat2′);
reset(f1);
while not eof(f1) do
begin
read(f1,inreg);
if inreg.is=1 then writeln(inreg.nume, ‘ ‘,inreg.varsta)
end;
close(f1)
end.
program ft11;
type inr= record
is:byte;
nume:string[10];
varsta:byte;
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
begin
assign(f1,’fdat2′);
reset(f1);
seek(f1,5);
read(f1,inreg);
seek(f1,filepos(f1)-1);
inreg.is:=0;
write(f1,inreg);
close(f1)
end.
Se consideră un fişier. Se cere ca acesta să fie sortat crescător (sau descrescător) după valorile unui anumit câmp. În programul care urmează , fişierul se sortează după valoarea câmpului nume (sortarea alfabetică).
Pentru a realiza sortarea , se foloseşte „metoda bulelor” . În esenţă , se parcurge fişierul de mai multe ori şi se inversează înregistrările alăturate care nu sunt în ordinea cerută . Dacă la o parcurgere s-a efectuat cel puţin o inversare , fişierul se parcurge din nou.
program ft12;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var f1:fisier;
i:integer;
inv:boolean;
inr1,inr2:inr;
begin
assign(f1,’fdat2′);
reset(f1);
repeat
inv:=false;
for i:=0 to filesize(f1)-2 do
begin
seek(f1,i);
read(f1,inr1,inr2);
if inr1.nume>inr2.nume then
begin
seek(f1,i);
write(f1,inr2,inr1);
inv:=true
end
end
until not inv;
close(f1)
end.
UN EXEMPLU DE LUCRU CU UN FIŞIER
Se cere să se scrie un program care să permită prelucrarea pe calculator a rezultatelor unui examen de admitere la liceu. Acest program trebuie să creeze , să actualizeze şi să listeze un fişier ce conţine rezultatele obţinute de fiecare candidat. Fiecare înregistrare trebuie să conţină:
• Numele elevului;
• Nota obţinută la proba 1;
• Nota obţinută la proba 2;
• Media generală.
Această aplicaţie urmăreşte să de4monstreze complexitatea programelor care se folosesc în practică. Desigur, există limbaje specializate pentru scrierea aplicaţiilor de acest gen (DBASE, FOXPRO).
Programul realizează următoarele:
• Crearea fişierului;
• Adăugarea unor înregistrări;
• Ştergere de înregistrări;
• Modificarea înregistrărilor;
• Sortarea fişierului în ordinea descrescătoare a mediilor;
• Listarea lui pe monitor, în vederea verificării informaţiilor;
• Listarea la imprimantă a candidaţilor admişi.
În afara acestora , programul trebuie să realizeze şi alte operaţii cum ar fi:
• Listarea la imprimantă a candidaţilor respinşi;
• Listarea pe monitor atât a candidaţilor admişi, cât şi a celor respinşi.
Schema de principiu a aplicaţiei:
Apelul procedurilor care realizează funcţiile specifice este realizat de procedura APLIC, prezentă în cadrul unităţii de program FIS. Aceasta creează un meniu prin utilizarea unităţii MENU. În afara procedurilor care realizează funcţiile specificate, mai este apelată o procedură numită DIALOG 1.
Procedura DIALOG 1 cere numele fişierului de candidaţi cu care se va lucra în continuare. Procedura testează dacă acest fişier se găseşte sau nu pe suportul magnetic. Rezultatul este afişat pe ecran . Pentru aceasta se procedează astfel:
• Se încearcă deschiderea pentru citire a fişierului cu nume specificat (opţiunile de compilare {$i/} şi {$I+} ce încadrează procedura RESET au rolul de a inhiba o eventuală oprire a unui fişier inexistent iar funcţia IORESULT returnează valoarea 0 în cazul unei operaţii de intrare / ieşire reuşite, altfel returnează o valoare diferită de 0).
• În funcţie de reuşita sau nu a operaţiei, se afişează mesajul corespunzător;
• În cazul în care fişierul a fost deschis spre citire (deci se găseşte pe suport) este închis;
• Numele fişierului este reţinut în variabila nume_f, variabilă la care au acces toate procedurile din unitatea de program.
Procedura CREARE are rolul de a crea fişierul cu candidaţi. Numele său este preluat din variabila nume_f. Pentru aceasta se procedează astfel:
• Pentru citirea informaţiilor de pe ecran se foloseşte procedura CITIRE_TAST;
• Media generală care este conţinută în înregistrare se calculează înainte de a scrie înregistrarea în fişier;
• După fiecare înregistrare , utilizatorul este întrebat dacă doreşte sau nu să continue.
Procedura CITIRE_TAST apelează repetitiv procedura INTERFATA (spre a citi datele de pe ecran) până când utilizatorul consideră că datele tastate sunt corecte.
Procedura INTERFATA realizează următoarele:
• Şterge ecranul;
• Afişează numărul înregistrării curente (care urmează să fie citită);
• Afişează în locuri fixe numele informaţiilor ce urmează a fi citite;
• Citeşte în locuri fixe informaţiile , procedând în felul următor:
o Citirea propriu-zisă se face în variabile de tip string;
o În cazul notelor, care sunt numere reale, citirea se face în mod repetitiv până când sunt îndeplinite simultan condiţiile:
– Conţinutul tipului string în care au fost citite se poate converti fără eroare în variabile reale (pentru aceasta se utilizează procedura VAL cu cei trei parametri: numele variabilei de tip string, numele variabilei reale în care urmează să se facă conversia şi numele variabilei care reţine dacă operaţia a reuşit , caz în care ia valoarea 0, astfel ia o valoare diferită de 0);
– Notele tastate sunt mai mari ca 0 şi mai mici sau egale cu 10;
– Şirul citit nu este vid (datorită apăsării din greşeală a tastei RETURN).
Procedura ADAUGARE are rolul de a adăuga la sfârşitul fişierului una sau mai multe înregistrări. Se procedează în felul următor:
• Se deschide fişierul pentru citire ;
• Se află numărul de înregistrări ale fişierului (pentru aceasta se utilizează funcţia FILESIZE);
• Cu ajutorul funcţiei SEEK se face poziţionarea după ultima înregistrare (pe marcajul sfârşitului de fişier);
• Cu ajutorul procedurii CITIRE_TAST se citesc informaţiile de la tastatură;
• După calculul mediei generale, înregistrarea este scrisă;
• Procedeul continuă până când utilizatorul , care este întrebat de fiecare dată dacă doreşte sau nu acest lucru, răspunde negativ.
Procedura STERGERE are rolul de şterge o înregistrare. În acest scop se procedează astfel:
• Se cere numele candidatului ce urmează a fi şters;
• Întrucât în fişiere secvenţele nu există o instruncţiune capabilă de a şterge o înregistrare, fişierul de unde urmează a fi ştearsă înregistrarea este citit iar fiecare înregistrare diferită de cea care urmează a fi ştearsă este trecută într-un fişier de manevră; în final , fişierul iniţial este şters iar fişierul de manevră capătă numele iniţial;
• În plus, dacă este găsită înregistrarea ce urmează a fi ştearsă , se semnalează acest lucru într-o variabilă booleană iar la sfârşit utilizatorul ştie dacă acţiunea de ştergere a fost încununată de succes sau nu.
Funcţia POS are rolul de a căuta un subşir şi în cazul în care acesta este găsit ia o valoare diferită de 0 , în caz contrar ia valoarea 0. Această funcţie este folosită în procedură pentru a căuta numele candidatului în cadrul variabilei ce reţine numele din înregistrarea citită (în felul acesta se evită cerinţa suplimentară ca atât numele prezent în cadrul înregistrării cât şi numele tastat în procedură să ocupe aceleaşi poziţii în cadrul variabilelor ce le corespund).
Procedura MODIFICARE are rolul de a modifica o înregistrare din cadrul fişierului. Se procedează astfel:
• Se cere numele candidatului a cărui înregistrare urmează a fi modificată;
• Se parcurge fişierul până când este găsită înregistrarea corespunzătoare sau până când a fost citit tot fişierul;
• Dacă înregistrarea a fost găsită , poziţionăm pointer-ul asupra ei (utilizând funcţia FILEPOS , care furnizează numărul de înregistrări deja citite şi procedura SEEK pentru poziţionare);
• Se citesc noile informaţii corespunzătoare ei prin intermediul procedurii CITIRE_TAST , informaţii care sunt trecute în locul vechii înregistrări;
• Se semnalează utilizatorului dacă înregistrarea cu numele citit în procedură nu a fost găsită.
Procedura SORTARE are rolul de a sorta fişierul de candidaţi în ordinea descrescătoare mediilor. Pentru aceasta se foloseşte o metodă cunoscută sub numele de metoda bulelor. Algoritmul este următorul:
• Se compară media generală a candidatului care se găseşte în prima înregistrare cu media generală a candidatului ce se găseşte în a doua înregistrare din fişier iar în cazul în care prima medie este mică decât a doua cele două înregistrări se inversează;
• Se compară în mod asemănător şi se inversează dacă este cazul înregistrările a doua cu a treia ;
• Se compară şi se inversează dacă este cazul penultima şi ultima înregistrare din fişier;
• Dacă în timpul parcurgerii fişierului s-a efectuat cel puţin o interschimbare de înregistrări , se reia parcurgerea fişierului , în caz contrar algoritmul se încheie iar înregistrările sale sunt sortate.
Procedura LISTARE_P listează pe monitor fişierul de candidaţi:
• Utilizează procedura CAPTAB ce are rolul de a tipări capul de tabel (întrucât procedura CAPTAB are posibilitatea de a tipări capul de tabel atât pe monitor cât şi la imprimantă , aceasta este apelată ca un parametru ce ia valoarea 0 pentru monitor şi valoarea 1 pentru imprimantă);
• Pentru a evita consecinţele neplăcute ale fenomenului de defilare pe monitor , se cere numărul de rânduri ce vor fi prezentate simultan pe ecran (număr ce include şi cele 4 rânduri ocupate de capul de tabel şi titlul raportului);
• După fiecare ecran listat utilizatorul este întrebat dacă doreşte să continue sau nu listarea.
Listarea la imprimantă a candidaţilor admişi se face prin apelarea a trei proceduri:
• DIALOG
• ADMRESP
• LISTARE_A.
Procedura DIALOG îi cere utilizatorului numărul de locuri puse la dispoziţia candidaţilor. Dialogul cu utilizatorul se face luând măsurile de protecţie următoare:
• De a nu introduce un număr greşit (pentru siguranţă , utilizatorul este întrebat dacă ce a introdus este corect sau nu);
• Dea inhiba o eventuală întrerupere de program ca urmare a introducerii unei litere în locul unei cifre.
Procedura ADMRESP calculează numărul de candidaţi admişi şi numărul de candidaţi respinşi. Pentru ca un candidat să fie admis este necesar să îndeplinească următoarele condiţii:
• Să aibă o medie generală mai mare sau egală cu 5;
• În ordinea descrescătoare a mediilor să aibă o medie care se încadrează în numărul de locuri , sau egală cu cea a candidatului ultim admis;
• Numărul de candidaţi respinşi se calculează ca diferenţa dintre numărul candidaţilor (numărul de înregistrări din fişier) şi cei admişi.
Procedura LISTARE_A are rolul de a lista la imprimantă candidaţii admişi. Ea cere utilizatorului să furnizeze numărul de rânduri ce se vor tipări pe o pagină:
• Se tipăreşte capul de tabel utilizând procedura CAPTAB cu parametrul 1 (pentru a lista capul de tabel şi titlul la imprimantă);
• Informaţiile corespunzătoare fiecărei înregistrări sunt convenite în variabile de tip string (cu procedura STR ce are doi parametri: numele variabilei sursă şi numele variabilei destinaţie), iar acestea sunt inserate în variabile de tip string rând (cu ajutorul procedurii INSERT cu trei parametri şi anume variabila destinaţie , variabila sursă şi lungimea pe care să se facă transferul );
• Variabila rând este tipărită;
• După fiecare pagină se aşteaptă introducerea noii pagini după care procesul se reia până la tipărirea tuturor candidaţilor;
Procedura CAPTAB scrie titlul şi capul de tabel pe monitor sau la imprimantă, după parametrul cu care a fost apelată (0 sau1).Pentru scrierea titlului se apelează procedura TITLU cu acelaşi parametru (0 şi 1) pentru monitor sau imprimantă.
Programul utilizator care lansează această aplicaţie este următorul:
program examen;
uses fis;
begin
aplic
end.
Iată şi unitatea de program:
unit fis;
interface
uses crt, menu,util;
procedure aplic;
implementation
type inr= record
nume:string[20];
nota1,nota2,media:real
end;
var n1,n2:real;
nume,nume_f:string[20];
tit:string[40];
buf:string[5];
c_er,inr_loc,nr_adm,nr_resp:integer;
inreg:inr;
f,h:file of inr;
imprim:text;
procedure interfata;
begin
window(1,1,80,25);
textbackground(negru);
textcolor(alb);
clrscr;
cursor(true);
gotoxy(25,1);
write(‘inregistrarea ‘,i);
gotoxy(3,3);
write(‘nume candidat’);
gotoxy(3,5);
write(‘nota proba 1’);
gotoxy(3,7);
write(‘nota proba 2’);
repeat
gotoxy(20,3);
clreol;
readln(nume)
until nume<>”;
repeat
gotoxy(20,5);
clreol;
readln(buf);
val(buf,n1,c_er)
until (c_er=0) and (buf<>”) and (n1>=0 and (n1<=10;
repeat
gotoxy(20,7);
clreol;
readln(buf);
val(buf,n2,c_er)
until (c_er=0) and (buf<>”) and (n2>=0) and (n2<=10);
end;
procedure citire_tast;
var c:char;
begin
repeat
interfata;
gotoxy(3,20);
write(‘corect (y/n)’);
gotoxy(17,20);
c:=readkey;
until c<>’n’
end;
procedure creare;
var c:char;
begin
rewrite(f);
i:=0
repeat
i:=i+1;
citire_tast;
inreg.nume:=nume;
inreg.nota1:=n1;
inreg.nota2:=n2;
inreg.media:=(n1+n2)/2;
write(f,inreg);
gotoxy(3,21);
write(‘continuati (y/n) ‘);
gotoxy(20,21);
c:=readkey;
until c=’n’;
close(f)
end;
procedure dialog1;
var c:char;
begin
textbackground(negru);
textcolor(alb);
clscr;
gotoxy(10,4);
write(‘numele fisierului’);
repeat
gotoxy(30,4);clreol;
read(nume_f);
gotoxy(10,20);
write(‘corect (y/n)’);
gotoxy(25,20);
readln;
c:=reakey;
delline
until c=’y’;
assign(f,nume_f);
{$i-} reset(f); {$i+}
gotoxy(10,20);
if ioresult=0 then
begin
close(f);
gotoxy(10,20);
write(‘fisierul exista ‘);
end
else write(‘fisierul trebuie creat ‘);
delay(2000);
end;
procedure adaugare;
var c:char;
begin
assign(f,nume_f);
reset(f);
i:=filesiye(f);
seek(f,i);
repeat
i:=i+1;
citire_tast;
inreg.nume:=nume;
inreg.nota1:=n1;
inreg.nota2:=n2;
inreg.media:=(n11+m2)/2;
write(f,inreg);
gotoxy(3,21);
write(‘continuati (y/n) ‘ );
gotoxy(20,21);
c:=readkey;
until c=’n’;
close(f);
end;
procedure stergere;
var c:inr;
num:string[80];
gasit:boolean;
a:string[1];
begin
window(1,1,80,25);
textbackground(negru);
textcolor(alb);
clrscr;
write(‘numele candidatuluipe care il stergeti : ‘);
readln(num);
assign(f,nume_f);
reset(f);
assign(h,’fman.dat’);
rewrite(h);
gasit:=false;
while not eof(f) do
begin
read(f,c);
if pos(num,c.nume)<>0 then gasit:=true
else write(h,c);
end;
if gasit then writeln (‘succes-inregistrare stearsa’)
else writeln (‘inregistrare negasita ‘);
close(f);
close(h);
erase(f);
rename*(h,nume_f);
gotoxy(1,20);
writeln(‘apasati o tasta…’);
a:=readkey
end;
procedure modificare;
var c:inr;
num:string[80];
gasit:boolean;
a:string[1];
begin
window(1,1,89,25);
textbackground(negru);
textcolor(alb);
clrscr;
cursor(true);
assign(f,nume_f);
reset(f);
write(‘numele candidatului ce urmeaza a fi modificat ?’);
readln(num);
gasit:=false;
while (not eof(f)) and (not gasit)do
begin
read(f,c);
if num=c.nume then gasit:=true;
end;
i:=filepos(f);
if gasit then
begin
citire_tast;
c.nume:=nume;
c.nota1:=n1;
c.nota2:=n2;
c.media:=(n1+n2)/2;
seek(f,i-1);
write(f,c);
end
else writeln(‘nu exista aceasta inregistrare ‘);
writeln(apasati o tasta’);
a:=readkey;
close(f);
end;
procedure sortare;
var c,d:inr;
n,j:integer;
inversari:boolean;
begin
assign(f,nume_f);
reset(f);
n:=filesize(f);
repeat
inversari:=false;
for j:=0 to n-2 do
begin
seek(f,j);
read(f,c);
read(f,d);
if d.media>c.media then
begin
seek(f,j);
write(f,d);
write(f,c);
inversari:=true
end
end
until not invarsari;
close(f)
end;
procedure titlu(t:integer);
var c:char;
begin
if t=0 then
begin
clrscr;
gotoxy(14,1);
write(tit)
end
else
begin
writeln(‘deschideti imprimanta’);
writeln(‘apasati o tasta’);
c:=readkey;
repeat
{$i-}
writeln(imprim,tit);
{$i+}
until ioresult=0
end;
end;
procedure captab(t: integer);
var a,b:string[60];
begin
a:=’***********************************************************’;
b:=’*nc* nume elev * nota1 * nota2 * media *’;
titlu(t);
if t=0 then
begin
gotoxy(1,2);write(a);
gotoxy(1,3);write(b);
gotoxy(1,4);write(a);
end
else
begin
a:=’ ‘+a;
b:=’ ‘+b;
writeln(imprim,a);
writeln(imprim,b);
writeln(imprim,a);
end
end;
procedure listare_p;
var nr_rand,j:integr;
c:string[1];
begin
tit:=’lista de verificare’;
repeat
window(1,1,80,25);
textbackground(negru);
textcolor(alb);
clrscr;
cursor(true);
write(‘cate randuri sa se tipareasca pe ecran ? ‘);
readln(nr_rand)
until (nr_rand>=4) and (nr_rand<=20);
assign(f,nume_f);
reset(f);
c:=’y’;
i:=1;
while (not eof(f)) and (c<>’n’) do
begin
j:=5;
captab(0);
while (j<=nr_rand) and (not eof(f)) and (c<>’n’) do
begin
read(f,inreg);
gotoxy(2,j); write(i);
gotoxy(5,j); write(inreg.nume);
gotoxy(26,j); write(inreg.nota1:2:2);
gotoxy(34,j); write(inreg.nota2:2:2);
gotoxy(42,j); write(inreg.media:2:2);
j:=j+1;
i:=i+1
end;
gotoxy(1,21);
write(‘continuati? (y/n) ‘);
gotoxy(20,21);
readln(c);
end;
close(f)
end;
procedure listare_a;
var c:char;
n,j,k:integer;
rand :string[60];
man:string[3];
man1:string[5];
begin
if nr_adm<>0 then
begin
clrscr;
assign(f,nume_f);
reset(f);
repeat
write(‘cate randuri pe pagina (5..55) ‘);
{$i-} readln(n) {$i+}
until (ioresult=0) and (n>5) and(n<=55);
j:=1;
assign(imprim,’prn’);
rewrite(imprim);
repeat
k:=5;
tit:=’candidati admisi’;
captab(1);
repeat
read(f,inreg);
rand:=’
man:=’ ‘;
man1:=’ ‘;
str(j,man);
insert(man,rand,2);
insert(inreg.nume.rand,5);
str(inreg.nota1:2:2,man1);
insert(man1,rand,26);
str(inreg.nota2:2:2,man1);
insert(man1,rand,34);
str(inreg.media:2:2,man1);
insert(man1,rand,42);
rand:=’ ‘+rand;
writeln(imprim,rand);
j:=j+1;
k:=k+1
until (k=n) or ( j=nr_adm+1)
until j=nr_adm+1;
close(f);
close(imprim)
end
end;
procedure dialog;
var c:char;
begin
window(1,1,80,25);
textbackground(negru);
textcolor(alb);
cursor(true);
clrscr;
repeat
repeat
write(‘cate locuri sunt ? ‘);
{$i-} readln(nr_loc);{$i+}
until ioresult=0;
write (,corect (y/n) ‘);
readln(c);
until c=’y’
end;
procedure admresp;
var c:inr;
n:real;
d:char;
begin
nr_adm:=0;
assign(f,nume_f);
reset(f);
repeat
read(f,c);
if c.media>=5 then nr_adm:=nr_adm+1
until eof(f) or (c.media>5) or(nr_adm=nr_loc);
n:=c.media;
while (c.media=n) and (n>=5) and (not eof(f) do
begin
read(f,c);
if c.media=n then nr_adm:=nr_adm+1;
end;
nr_resp:=filesize(f)-nr_adm;
clrscr;
writeln(‘nr_adm=’,nr_adm);
writeln(‘nr_resp+’,nr_resp);
close(f);
writeln(‘apasati o tasta ‘);
d:=readkey
end;
procedure aplic;
var a:men;
b:string;
begin
dialog1;
textbackground(negru);
clrscr;
b:=’ CREARE ADAUGARE STERGERE ‘;
b:=-b+’MODIFICARE SORTARE ‘;
b:=b+’ LIST-PROB LIST-ADMS ‘;
a.deschidm(2,1,77,1,rosu,verde,0,11,0,b,false);
repeat
if a.selectat then a. salvez;
case a.citxb of
1: creare;
12: adaugare;
23: stergere;
34: modificare;
45: sortare;
56: listare_p;
67: begin
dialog;
admresp;
listare_a
end
end {case};
a.restaurezm
until a.inchis
end;
end.
FIŞIERE FĂRĂ TIP
Fişierele fără tip sunt constituite din blocuri de lungime fixă, motiv pentru care acestea se mai numesc şi fişiere cu prelucrare la nivel de bloc. În cadrul blocurilor, informaţia se scrie direct sub forma în care apare în memoria internă, fără a se converti.
Blocurile se numerotează cu numere cuprinse între 0 şi n. Din acest motiv se poate folosi procedura SEEK în forma cunoscută şi ea are rolul de a poziţiona pointer-ul pe un anume loc. O variabilă de tip fişier fără tip se declară cu ajutorul cuvântului cheie FILE.
Exemplu: a:file;
Asignarea fişierului la suportul extern se face cu ajutorul procedurii ASSIGN, exact cum se procedează şi în cazul celorlalte tipuri de fişiere.
Deschiderea fişierelor pentru a creare se realizează cu ajutorul procedurii REWRITE. Forma generală a acestei proceduri este:
REWRITE (var nume fişier,[număr de octeţi pentru un bloc])
În cazul în care al doilea parametru este absent, blocul va avea o lungime standard de 128 octeţi.
Scrierea blocurilor se face cu ajutorul procedurii BLOCKWRITE care are următoarea formă generală :
BLOCKWRITE (nume fişier, nume variabilă în care se face citirea, număr de blocuri care se citesc ,[variabila ce re’ine numărul de blocuri efectiv citite]).
În cazul în care ultimul parametru este absent se citesc mai puţine blocuri decât au fost solicitate , procedura se termină cu eroare de intrare / ieşire.
Programul care urmează creează un fişier fără tip cu n înregistrări.
program fft1;
type inreg= record
nume:string[16];
varsta:integer;
end;
var f:file;
inr:inreg;
n,i:integer;
begin
assign(f,’fblk’);
write(‘n’);
readln(n);
rewrite(f,19);
for i:=1 to n do
begin
write(‘nume=’);
readln(inr.nume);
write(‘varsta=’);
readln(inr.varsta);
blockwrite(f,inr,1);
end;
close(f)
end.
Deschiderea pentru citire (sau scriere, în caz de actualizare a fişierului) se face cu ajutorul procedurii RESET care are forma de apel:
RESET (variabila fişier,[număr de octeţi pe care a fost scris blocul]).
Citirea unui bloc se face cu ajutorul procedurii BLOCKREAD, în care:
BLOCKREAD (variabila fişier, variabila unde se face citirea , numărul de blocuri care se vor citi, [variabila care reţine numărul de blocuri efectiv citite]).
Sfârşitul de fişier se testează cu ajutorul funcţiei booleene EOF, la fel ca şi la celelalte tipuri de fişiere.
program fft2;
type inreg= record
nume:string[16];
varsta:integer;
end;
var f:file;
inr:inreg;
begin
assign(f,’fblk’);
reset(f,19);
while not eof(f) do
begin
blockread(f,inr,1);
writeln(inr.nume, ‘ ‘, inr.varsta)
end;
close(f)
end.
Nu este obligatoriu să se citească un fişier fără tip într-o variabilă de tip record. Blocul se memorează începând cu o anumită variabilă , pe toată lungimea lui (acolo trebuie să se găsească alte variabile în care să se facă memorarea). Un exemplu, în acest sens , îl constituie programul următor (listează acelaşi fişier).
program fft3;
{$a-}
var f:file;
nume:string[16];
varsta:integer;
begin
assign9f,’fblk’);
reset(f,19);
while not eof(f) do
begin
blockread(f,nume,1);
writeln(nume,’ ‘, varsta)
end;
close(f)
end.
compilatorul rezervă spaţiu pentru variabile în memoria internă, după un anumit mecanism. Astfel, pentru o variabilă de tip integer se rezervă doi octeţi la o adresă multiplu de 2. Din acest motiv, apar octeţi neocupaţi de variabile, care însă sunt folosiţi la citirea blocului. În acest fel, este posibil să nu regăsim rezultatele pe care le aşteptăm. Rolul opţiunii de compilare este acela de a comanda compilatorul ca toate variabilele să fie adrese multiple de 1 (deci nu rămân octeţi nerezervaţi).
Şi pentru aceste fişiere poate fi folosită funcţia FILESIZE la fel ca la cele cu tip. Toate operaţiile de actualizare se fac la fel cala fişierele cu tip.
NOTA IMPORTANTA: ARTICOLELE PUBLICATE IN PAGINA DE REFERATE AU SCOP DIDACTIC SI SUNT ELABORATE IN URMA UNEI DOCUMENTARI SUSTINUTE. ESTE STRICT INTERZISA PRELUAREA ARTICOLELOR DE PE SITE SI PREZENTAREA LOR LA ORELE DE CURS. Referatele din aceasta sectiune sunt trimise de diferiti colaboratori ai proiectului nostru. Referatele va sunt prezentate pentru COMPLETAREA STUDIULUI INDIVIDUAL, si va incurajam si sustinem sa faceti si voi altele noi bazate pe cercetari proprii.
Referat trimis de: Radu Serban
