Datastrukturer

For at kunne arbejde med filer i Delphi er det nødvendigt at forstå strukturen i de filer man laver. En fil, hvor der kun er gemt fx en shortstring i, vil man kunne forstå som en lille firkant, der illustrerer den ene shortstring. Hvis man så fx skal forstå strukturen af en array[1..4] of shortstring bliver det straks lidt mere avanceret - men prøv nu at forstå shortstring 1 som om den repræsenterer det første lysegule felt i illustrationen og at shortstring 2 repræsenterer det mørkegule felt på nr. 2 plads i illustrationen og så videre. Det er den måde det skal forstås, og hvis man ikke forstår det vil det være håbløst for en når man først begynder på de avancerede datastrukturer.

Nu er vi alle så heldige, at lige fra den allerførste version af Pascal til Delphi 5, har Borland/Inprise haft lavet nogle standard-procedurer til at behandle filer med. De forskellige procedurer skiftede godt nok navn op i Delphi tiden, men ikke så drastisk at det gør noget.

AssignFile	Klargører filen, og er desuden nødvendig før alle andre procedurer
Reset	Flytter pointeren hen til starten af filen
Append	Flytter pointeren hen til slutningen af filen
Seek	Flytter pointeren hen til den adresse du indtastede
ReWrite	Opretter filen fysisk
EOF	En boolean der fortæller om pointeren er ved EndOfFile
Read	Læser alle slags forskellige data, der er gemt i en fil
Write	Skriver alle slags forskellige data til filen
ReadLn	Bruges til TextFile-filer
WriteLn	Bruges til TextFile-filer
BlockRead	Bruges til at læse fra avancerede record/memory filer
BlockWrite	Bruges til at skrive til avancerede record/memory filer
CloseFile	Lukker filen så den ikke bliver skrevet til mere

Bare rolig - vi starter selvfølgelig i det simple UDEN avancerede datastrukturer (i hvert fald i første omgang). En af de vigtigste ting at kende til, når man arbejder med datastrukturer, er at kende sin Pointer. Pointeren er ganske simpelt det sted vores fil vil skrive eller hente fra. Pointeren kan flyttes med procedurerne Seek, Reset og Append. Vores mål er lige nu, at lære hvordan man nu kan gøre al denne teori til praksis med god gammeldags kode i et program, der gemmer et navn i en fil.

var
  HentStreng: ShortString;

Procedure Tform1.GemTilFil(filnavn: string; navn: shortstring);
Var MinFil: file of shortstring;
Begin
AssignFile(MinFil, filnavn); //Klargører filen til skrivning
ReWrite(MinFil); //Opretter filen, som en fysisk enhed
Reset(MinFil); //Flytter pointeren til starten af filen
Write(MinFil, navn); //Skriver 'navn' ind i filen
CloseFile(MinFil); //Lukker filen så vi ikke kommer til at skrive til den ved en fejl
end;

Procedure Tform1.HentFraFil(filnavn: string; var hentetnavn: shortstring);
Var MinFil: file of shortstring;
    navn: shortstring;
begin
AssignFile(MinFil, filnavn); //Klargører filen til skrivning
Reset(MinFil); //Flytter pointeren til starten af filen
Read(MinFil, navn); //Skriver 'navn' ind i filen
hentetnavn:=navn; //Putter det hentede 'navn' ind i den angivne variabel
CloseFile(MinFil); //Lukker filen så vi ikke kommer til at skrive til den ved en fejl
end;

Med dette lille kodeeksempel håber jeg at du har fået et lille indblik i hvordan man, nemt og hurtigt, kan kreere sin helt egen fil og hente en simpel oplysning fra den. Hvis du er ny mht. filstrukturer eller programmering i det hele taget bør du nok læse koden igennem et par gange for at forstå den fuldstændigt, for nu begynder det sjove nemlig først…

Til dette eksempel vil der følge en meget mere detaljeret forklaring til, som jeg lige så godt kan springe ud i med det samme. Når man programmerer meget, vil man ofte få brug for at kunne lave nogle 'små' databaser i sin egen kode uden at bruge alt det andet bavl som fx Paradox (det siger jeg kun fordi jeg ikke kan finde ud af hvordan det virker). Og til en database skal man altid bruge records, som jeg også vil forklare lidt nærmere om. En record er en type, som indeholder nogle variabler, næsten ligesom en klasse - forskellen er bare, at en record ikke er nær så avanceret og at den kan gemmes i filer. Hvis man nu forestiller sig at ens record hedder firma og man skal bruge strengen der bestemmer firmaets navn, skriver man bare firma.firmanavn - præcis som en klasse (så er det på plads). Til vores eksempel skal vi lave en medarbejderdatabase til firmaet. Vi kalder recorden for Tmedarbejder og tilføjer variablerne: Navn: Shortstring; Efternavn: Shortstring;

Type

TMedarbejder = Record

	Navn:	ShortString;
	Efternavn:	ShortString;

End;

Koden tilføjes ovenover formklassen. Nu har vi så fået vores medarbejder ind men spørger os selv om ikke der er flere end en medarbejder - jo, det må der da være. Derfor tager vi og skriver (i public)

Medarbejder : Array[1..100] of TMedarbejder;

Nu har vi gjort det muligt at have 100 forskellige medarbejdere i firmaet - hvis vi så fx skal have fat i medarbejder 32´s navn skriver vi bare Medarbejder[32].Navn; Så langt så godt… for nu har vi jo stadigvæk problemet med at det skal gemmes i en fil. Før jeg vil vise følgende kode, vil jeg dog lige prøve at forklare hvordan opbygningen af en sådan fil ville komme til at se ud. Hvis du prøver at forestille dig 100 forskelligfarvede rektangler der står på rad og række op ad hinanden kunne hver enkel af dem symbolisere Medarbejder-recorderne - da der jo både er Navn og Efternavn hos en medarbejder kan man forestille sig at hver af de 100 rektangler er delt op i to dele. Nå, men nu skal vi vist have noget kode:

procedure Tform1.GemFil(filnavn:string);
var DataFil : file of shortstring;
    I: Integer;
begin
AssignFile(DataFil,filnavn);
ReWrite(DataFil);
Reset(DataFil);
for i := 1 to 100 do
    Write(DataFil,Medarbejder[i].Navn, Medarbejder[i].Efternavn);
CloseFile(DataFil);
end;

procedure Tform1.HentFil(filnavn:string);
var DataFil : file of shortstring;
    I: Integer;
begin
AssignFile(DataFil,filnavn);
Reset(DataFil);
for i := 1 to 100 do
    Read(DataFil,Medarbejder[i].Navn, Medarbejder[i].Efternavn);
CloseFile(DataFil);
end;

Med dette håber jeg du fik en lidt større indsigt i hvordan og til hvad datastrukturer og filbehandling kan bruges i dine egen applikationer. Jeg vil selvfølgelig ikke stå her og sige til hvilke og til hvad de skal bruges, men jeg mener dog stadig at dette er et stærkt alternativ til de mange forskellige databaser, da disse her KUN kan åbnes af programmet. Grunden er så simpel, at for at åbne dem og bruge variablerne skal man kende variablernes navne plus opbygningen af filen. Her til sidst vil jeg da også godt lige pointere at denne artikel absolut ikke er for 'børn', altså for unexperienced programmers.