Vom Anf�nger zum Entwickler, Programmieren lernen mit FreePascal

Hallo Leute,
in diesem Thread m�chte ich euch die Programmiersprache FreePascal n�her bringen, von Anfang an. Dieses Tutorial richtet sich vor allem an Einsteiger in die Programmierung, eignet sich allerdings auch f�r Umsteiger die sich FreePascal aneignen wollen.
Im verlauf der n�chsten Wochen/Monate werde ich den Thread mit neuen Teilen immer aktualisieren.

Aufgrund des Epvp Post Gr��en Limits werde ich die Einzelnen Kapitel auf meine Website auslagern. Neue Kapitel poste ich dennoch zu erst hier

Inhalt
0. Voraussetzungen
1. FreePascal
2. Erste Schritte & Variablen
3. Kontrollstrukturen
4. Arrays
5. Zeiger
6 Typen
7. Funktionen
8. Rekursive Funktionen und Datentypen
9. Bibliotheken
10. Dateien Lesen&Schreiben
11. Einf�hrung in die OOP
12. Lazarus & LCL
13. Klassen und Instanzen
...

Work in Progress Schon gemacht

[Only registered and activated users can see links. Click Here To Register...]

[Only registered and activated users can see links. Click Here To Register...]

[Only registered and activated users can see links. Click Here To Register...]

[Only registered and activated users can see links. Click Here To Register...]

Rekursive Funktionen und Typen

Spoiler

Bisher haben wir nur das Iterative Programmieren kennen gelernt, wobei der Code einfach linear Ausgef�hrt wird und durch Kontrollstrukturen und Schleifen beinflusst wird. Nun m�chte ich auf eine andere Technik eingehen, das rekursive Programmieren.
Bei rekursiven Funktionen definieren wir die Funktion �ber sich selbst. Das klingt jetzt vielleicht ein wenig Abenteurlich, aber ich erkl�re das mal an dem wohl bekanntesten Beispiel.
Fibonacci Zahlen
Die Fibonacci Zahlen ist eine Folge aus der Mathematik. Definiert ist das Element n der Folge als die Summe der Fibonacci Zahlen von n-1 und n-2. F�r 0 ist die Fibonacci Folge als 0 definiert und f�r 1 als 1.
Damit w�re die Fibonacci Zahl von 2: 0 + 1 = 1, die von 3: 1 + 1 = 2, 4: 2 + 1 = 3 und so weiter.
Die formale Schreibweise w�re:

Code:

Fib(n) = 0						| F�r n=0
       = 1						| F�r n=1
	   = Fib(n-1) + Fib(n-2)	| Sonst

Ein Paradebeispiel f�r eine Rekursive Funktion.
Wenn wir so etwas Programmieren wollen k�nnen wir direkt auf die Rekursive Definition zur�ckgreifen:

Code:

function FibRec(n: Integer): Integer;
begin
  if n = 0 then Result := 0
  else if n = 1 then Result := 1
  else Result := FibRec(n-1) + FibRec(n-2);
end;

Diese Funktion ruft zur L�sung sich selbst auf, so lange bis eine Abbruchbedingung erf�llt ist. Im Beispiel Fibonacci w�ren die Abbruchbedingungen n = 0 und n = 1.

Jedes Problem welches sich Rekursiv l�sen l�sst l�sst sich auch Iterativ l�sen und vice versa. Manchmal sind Rekursive funtkionen einfacher zu lesen, k�rzer und intuitiver. In einigen F�llen ist die Intuitive Kurze L�sung allerdings auch nicht unbedingt die Beste. Das Beispiel Fibonacci ist in dieser Form extrem ineffizient, da so gut wie alle Zahlen mehrfach ausgerechnet werden, was eine Kaskade an Berechnungen zur folge hat. Probiert es gerne mal mit gro�en Zahlen aus, ihr werdet schnell merken das die Berechnungen sehr schnell sehr lange dauern.

Eine spontane iterative L�sung w�re:

Code:

function FibIt(n: Integer): Integer;
var Fib: Array of Integer;
  i: Integer;
begin
  if n=0 then
  begin
    Result := 0;
	Exit;
  end;
  SetLength(Fib, n+1);
  Fib[0]:=0;
  Fib[1]:=1;
  for i := 2 to n do
    Fib[i] := Fib[i-1] + Fib[i-2];
  Result := Fib[n]
end;

Dieser Ansatz ist schon deutlich besser als der vorherige Rekursive, aber definitiv nicht so sch�n zu lesen.
Auch dieser L�sungsweg l�sst sich Rekursiv umsetzen, das w�re aber ein deutlich gr��erer Aufwand und lohnen tut es sich in diesem Fall nicht.

Allerdings kann es auch Anders rum sein, das der spontane iterative L�sungsweg nicht so effizient ist wie der spontane Rekursive.

Bemerkung: Ich schreibe bewusst spontan, da man mit etwas Nachdenken auch auf effiziente Rekursive oder effiziente Iterative wege kommen kann, diese sind allerdings nicht direkt erkennbar.

Wenn man viel Programmiert entwickelt man ein Gef�hl daf�r wann eine rekursive L�sung und wann eine Iterative besser ist.

Allgemeine Rekursive Funktionen
An dem obigen Beispiel habe ich eine typische rekursive Fuktion gezeigt. Nun m�chte ich allgemein auf rekursive Funktionen und ihre Eigenschaften eingehen.
Mit rekursiven Funktionen reduzieren wir Probleme durch erneutes Aufrufen mit ver�nderten Datensatz auf Basisf�lle, die Abbruchbedingungen.
Die Anzahl der Aufrufe nennt man die Rekursionstiefe. Die Rekursionstiefe ist allerdings beschr�nkt. Da jeder Funktionsaufruf seinen eigenen Stack hat auf den mindestens die R�cksprungaddresse geschrieben wird, wird mit jedem Rekursionsaufruf Speicher belegt. Somit ist unsere Rekursionstiefe durch den Speicher begrenzt. Endlosschleifen mit Rekursion sind daher nicht m�glich.
Das bedeutet nat�rlich auch das wir immer eine Abbruchbedingung ben�tigen. Diese kann wie in dem Beispiel Fibonacci explizit angegeben werden, oder auch Implizit erreicht werden, zum Beispiel bis wir keine Daten zum verarbeiten mehr haben. Ein Beispiel dazu folgt etwas sp�ter.

Oben habe ich geschrieben, jedes Problem welches sich iterativ l�sen l�sst l�sst sich auch rekursiv l�sen. Das stimmt zwar allerdings l�sst sich nicht zu jedem rekursiven Algorithmus auch ein �quivalenter iterativer Algorithmus finden. Oben der Iterative Fibonacci Algorithmus mag zwar die Fibonacci Zahlen ausrechnen, aber auf eine Komplett andere Art und Weise. Die Rekursiven Funktionen f�r die es eine �quivalente iterative L�sung gibt nennt man Primitive Rekursionen.
Ein Beispiel f�r eine Solche w�re:

Code:

function SumRec(n: Integer): Integer;
begin
  if n=0 then Result := 0
  else Result := SumRec(n-1);
end;

function SumIt(n: Integer): Integer;
var i: Integer
begin
  Result := 0;
  for i := n downto 0 do
    Result := Result + i;
end;

Bei diesen Rekursionen kann man einfach einen Aktuellen wert Zwischenspeichern und durch Schleifen die Rekursion simmulieren.

Da man nur Primitve Rekursionen einfach zu Iterativen Funktionen umformen kann gibt es auch keine allgemeing�ltige Methode um Rekursiv zu Iterativ und vice versa umzuformen.

Nun aber wieder zu etwas praktischeren Beispielen.

Dateien Auflisten
Nun m�chte ich mein Lieblingsbeispiel f�r rekursive Funktionen anf�hren, das Suchen von Dateien in Unterordnern. Dies ist ein rekursiver Algorithmus auf den ich immer wieder zur�ckgreife.
Die Idee dabei ist Rekursiv so Vorzugehen:

Code:

1. Iteriere durch alle Dateien in einem Verzeichnis
2. Wenn die Datei gesucht wird (z.B. die korrekte Dateiendung hat) liste sie auf
3. Iteriere durch alle Unterordner im Verzeichnis
4. Rufe f�r jeden Rekursiv diese Funktion erneut auf

Die Abbruchbedingung ist hier Impliziet das es irgendwann keine Unterordner mehr gibt, da ein Dateisystem nie Unendlich ist.

Um das nun umzusetzen muss ich zun�chst einmal die Funktion FindFirst, FindNext und FindClose.
Mit diesen Funktionen k�nnen wir Dateien und Ordner in einem Verzeichnis suchen.
Mit FindFirst beginnen wir die Suche, �bergeben das so genannte Searchpattern, die Art der Dateien die wir suchen (z.B. Ordner, versteckte Dateien, etc) und ein SearchRecord, eine Variable in die die alle n�tigen Informationen f�r die Suche und gefundenen Dateien geschrieben wird. Die R�ckgabe von FindFirst ist ein Integer. Wurden Dateien gefunden gibt die Funktion 0 zur�ck, sonst eine negative Zahl.
FindNext bekommt den SearchRecord �bergeben und Sucht nach der n�chsten Datei. FindNext gibt 0 zur�ck falls weitere Datei gefunden wurde, also die Suche noch nicht beendet ist.
FindClose gibt die Resourcen wieder frei. Das Dateisystem wird vom Betriebsystem gehandhabt, und ein Aufruf von FindFirst sagt dem Betriebsystem es soll die Dateisuche beginnen. Mit FindClose sagen wir dem Betriebsystem das die Suche beendet ist, und es den Suchprozess aus dem Speicher werfen kann. Das l�sst sich mit dem Dispose bei Zeigern vergleichen. �bergeben wird wieder das SearchRecord. Gibt FindFirst nicht 0 zur�ck so ist der Aufruf von FindClose nicht n�tig.

Also beginnen wir:

Code:

program ListFiles;
{$MODE ObjFPC}{$H+}

uses
  SysUtils; // FindFirst, FindNext, FindClose
 
// Directory: Das Verzeichnes zum Suchen
// ext: Die zu suchende Dateiendung
procedure ListFiles(Directory, ext: String); 
var
  sr: TSearchRec; //Searchrecord
begin
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faAnyFile, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) <> faDirectory) And (ExtractFileExt(sr.Name) = ext) then
          WriteLn(IncludeTrailingPathDelimiter(Directory) + sr.Name);
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
end;
end.

Das ist schon mal der Anfang. Directory+'*' als SearchPattern bedeutet jede Datei im Verzeichnis, ohne Einschr�nkungen. faAnyFile ist die Suche nach allen Dateien.
IncludeTrailingPathDelimiter ist eine Funktion die einen Pfad annimmt und diesen zur�ckgibt mit einem / bzw \ (Windows) am Ende falls dieses nicht vorhanden sein sollte. So wird aus /Pfad dann /Pfad/.
In der Repeat-Until Schleife iterieren wir nun durch alle Dateien die gefunden werden. Sr enth�lt bei jedem Durchlauf der Schleife die Informationen �ber die gefundene Datei, das ist zum einen der Name oder auch um was f�r eine Datei es sich handelt. Die Abfrage ((sr.attr and faDirectory) <> faDirectory) And (ExtractFileExt(sr.Name) = ext) ist die �berpr�fung ob es sich um ein Verzeichnis handelt, welche wir sp�ter behandeln wollen, und ob die Datei die gew�nschte Dateiendung hat. sr.attr enth�lt die Dateiattribute als Flags (siehe Einschub: Variante Records, With, Flags).

Ist die Bedingung erf�llt geben wir den Dateinamen aus. Wir k�nnten ihn auch in einem Array Speichern wenn wir die Dateien zwischenspeichern wollen.

Wichtig ist das Try-Finnaly, damit auf jeden Fall das FindClose aufgerufen wird

Nun kommen wir aber zu der Rekursion:

Code:

program ListFiles;
{$MODE ObjFPC}{$H+}

uses
  SysUtils; // FindFirst, FindNext, FindClose
 
// Directory: Das Verzeichnes zum Suchen
// ext: Die zu suchende Dateiendung
procedure ListFiles(Directory, ext: String); 
var
  sr: TSearchRec; //Searchrecord
begin
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faAnyFile, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) <> faDirectory) And (ExtractFileExt(sr.Name) = ext) then
          WriteLn(IncludeTrailingPathDelimiter(Directory) + sr.Name);
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faDirectory, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) = faDirectory) And (sr.Name <> '..')
          And (sr.Name <>'.') then
          ListFiles(IncludeTrailingPathDelimiter(Directory)+sr.Name, ext);
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
end;
end.

Bei der zweiten Datei Suche wird nur nach Verzeichnissen gesucht und f�r diese dann eine separate Suche ausgef�hrt. Die Abfrage (sr.Name <> '..') And (sr.Name <> '.') ist notwendig, da jedes Verzeichnis eine Referenz auf das vorhergehende Verzeichnis ('..') und auf das eigene Verzeichnis ('.') hat, was zu einer Endlosschleife f�hren w�rde.

Damit w�re das Programm komplett:

Code:

program ListFiles;
{$MODE ObjFPC}{$H+}

uses
  SysUtils; // FindFirst, FindNext, FindClose
 
// Directory: Das Verzeichnes zum Suchen
// ext: Die zu suchende Dateiendung
procedure ListFiles(Directory, ext: String); 
var
  sr: TSearchRec; //Searchrecord
begin
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faAnyFile, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) <> faDirectory) And (ExtractFileExt(sr.Name) = ext) then
          WriteLn(IncludeTrailingPathDelimiter(Directory) + sr.Name);
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faDirectory, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) = faDirectory) And (sr.Name <> '..')
          And (sr.Name <>'.') then
          ListFiles(IncludeTrailingPathDelimiter(Directory)+sr.Name, ext);
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
end;

begin
  ListFiles('Pfad', '.pas');
end.

Das w�rde alle Dateien in allen Unterordnern mit der Dateiendung .pas in Pfad auflisten.

W�llte man nun die Dateien in einen Array speichern w�rde die Anpassung recht simpel gehen:

Code:

program ListFiles;
{$MODE ObjFPC}{$H+}

uses
  SysUtils; // FindFirst, FindNext, FindClose
  
Type
  TStringArr = array of String;
 
// Directory: Das Verzeichnes zum Suchen
// ext: Die zu suchende Dateiendung
procedure ListFiles(Directory, ext: String; var arr: TStringArr); 
var
  sr: TSearchRec; //Searchrecord
begin
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faAnyFile, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) <> faDirectory) And (ExtractFileExt(sr.Name) = ext) then
        begin
          SetLength(arr, Length(arr)+1);
          arr[High(arr)] := IncludeTrailingPathDelimiter(Directory)+sr.Name;
        end;
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
  if FindFirst(IncludeTrailingPathDelimiter(Directory)+'*', faDirectory, sr) = 0 then
    try
      repeat
        if ((sr.attr and faDirectory) = faDirectory) And (sr.Name <> '..')
          And (sr.Name <>'.') then
          ListFiles(IncludeTrailingPathDelimiter(Directory)+sr.Name, ext, arr);
      until FindNext(sr) <> 0
    finally
      FindClose(sr);
    end;
end;

var a: TStringArr;
  s: String;
begin
  ListFiles('Pfad', '.pas', a);
  for s in a do
    WriteLn(s);
end.

Bemerkung: Diese M�glichkeit mit dem String Array ist nicht sehr gut, der h�ufige Aufruf von SetLength ist sehr langsam. Sp�ter nachdem wir Klassen kennengelernt haben lernen wir eine Klasse, TStringList kennen, welche das besser Implementiert.

Rekursive Datentypen

Wir hatten im 6. Kapitel gelernt wie wir eigene Datentypen schreiben. Wir k�nnen Datentypen Rekursiv verwenden. Das bedeutet im Sinne von Datentypen, dass es sich dabei um Zusammengesetzte Datentypen (Records oder Arrays) bei denen 1 oder mehr Elemente ein Zeiger auf den selben Datentyp ist.
Auf diesen Datentypen empfiehlt sich die Nutzung von Rekursiven Funktionen.
Diese Typen verwendet man f�r so genannte Verkettungen, wobei eine Variable auf andere Variablen des selben Typs verweisen.
F�r die Definition solcher Typen gibt es in Pascal eine Syntaktische besonderheit. Zeiger auf einen Typen lassen sich �ber dem Typen selbst im Quellcode Definieren:

Code:

type
  PMyRec = ^TMyRec;
  TMyRec = record
    //Elemente
  end;

Da Pascal von oben nach Unten den Code durchgeht k�nnen wir f�r Variablen oder Elemente nur Typen verwenden die im Source �ber unserer Deklaration stehen, au�er bei Zeigern. Das erlaubt uns nun eine solche Definition

Code:

type
   PMyRecursiveType = ^TMyRecursiveType;
   TMyRecursiveType = record
     Next: PMyRecursiveType;
   end;

Somit k�nne wir einfach einem Record einen Verweis auf einen anderen Record vom selben Typ hinzuf�gen.

Eine Einsatzm�glichkeit solcher Typen sind z.B. Verkettete Listen (engl. linked list). Diese geben uns die M�glichkeit, �hnlich zu dynamischen Arrays beliebig viele Elemente zu Speichern. Das Prinzip ist recht simpel, jedes element enth�lt einen Zeiger auf das N�chste. Das letzte Element hat einen Zeiger auf nil.
Um eine verkettete Integer Liste zu Implementieren w�re der Rekursive Typ:

Code:

type
  PListItem = ^TListItem;
  TListItem = record
    Value: Integer;
    NextItem: PListItem;
  end;

Jetzt k�nnen wir �ber new und dispose immer neue Elemente erstellen oder L�schen und diese dann an ein vorhandenes Element anh�ngen.

Schreiben wir uns daf�r mal ein paar Funktionen die das Realisieren.
Fangen wir an mit einer Funktion zur Berechnung der Anzahl der Elemente:

Code:

function GetListLength(List: PListItem): Integer;
begin
  if Assigned(List) then
    Result := 1 + GetListLength(List^.NextItem)
  else
  Result := 0;
end;

Diese geht Rekursiv durch die Liste und Addiert f�r jedes Item 1 hinzu.

Als n�chstes eine Funktion zum Hinzuf�gen am Anfang mit dem wert x

Code:

procedure AddElementAtStart(var List: PListItem; x: Integer);
var tmp: PListItem;
begin
  new(tmp);
  tmp^.Value := x;
  tmp^.NextItem := List;
  List := tmp;
end;

Hier erstelle ich zun�chst ein neues Element mit dem Wert x, dann gebe ich List, welches das erste Element unserer verketteten Liste ist, als NextItem, und �berschreibe List mit dem neuen ersten Item. Die �berschreibung ist m�glich dank der Parameter�bergabe als Referenz.

Jetzt k�nnen wir noch eine Funktion schreiben zum Hinzuf�gen eines Elements am Ende

Code:

procedure AddElementAtEnd(var List: PListItem; x: Integer);
begin
  if Assigned(List) then
    AddElementAtEnd(List^.NextItem, x)
  else
  begin
    new(List);
    List^.Value := x;
    List^.NextItem := nil;
  end;
end;

Diese Funktion geht Rekursiv durch alle Listenelemente bis wir beim Ende Angekommen sind, und erstellt dort das neue Element.

Nun kommen wir zu der n�chsten Funktion, zum l�schen eines Elements gegeben mit dem Index i:

Code:

procedure DeleteListItem(List: PListItem; i: Integer);
var tmp: PListItem;
begin
  if not Assigned(List) then
    exit; // List Item nicht vorhanden
  if i>1 then
    DeleteListItem(List^.NextItem, i-1)
  else if Assigned(List^.NextItem) then // Wenn das zu l�schende element exsistiert
  begin
    tmp:=List^.NextItem^.NextItem; //�bern�chstes Item
    dispose(List^.NextItem);
    List^.NextItem := tmp; // �bern�chstes ist jetzt n�chstes Item
  end;
end;

Das ist jetzt schon etwas mehr.
Wir gehen Rekursiv durch die gesammte Liste bis wir entweder nil bekommen (nach dem letzten Item) oder wir 1 Element vor dem zu l�schenden Element sind.
Dann �berpr�fen wir ob das zu l�schende Element �berhaupt exsistiert, wenn es exsistiert speichern wir dessen Nachfolger, l�schen das Element und setzen den gespeicherten Nachfolger als das nachvolge Element des Elements vor dem gel�schten.

Nat�rlich was auch noch Fehlt ist das Auslesen des Wertes eines bestimmten Elements mit Index i

Code:

function GetItemValue(List: PListItem; i: Integer): Integer;
begin
  Result := 0;
  if Assigned(List) then
    if i>0 then
      Result:=GetItemValue(List^.NextItem, i-1)
    else
      Result:=List^.Value;
end;

Diese Funktion geht Rekursiv durch die Liste reduziert bei jedem Aufruf i um 1. Wenn i = 0 erreicht, und die Liste noch nicht am Ende ist, so ist das Aktuell mit List �bergebene Element unser Element und wir geben den Wert zur�ck. Falls das Element nicht exsistiert wird Standardm��ig 0 zur�ckgegeben.

Nat�rlich ben�tigen wir auch noch eine Funktion um den Wert eines Elements mit Index i zu setzen

Code:

procedure SetItemValue(List: PListItem; i, x: Integer);
begin
  if Assigned(List) then
    if i>0 then
      SetItemValue(List^.NextItem, i-1, x)
    else
      List^.Value := x;
end;

Diese ist relativ �hnlich zum Auslesen, ich denke hier muss ich nicht weiter erkl�ren.

Als letztes fehlt uns nur noch eine Funktion um die gesammte Liste zu l�schen und den Speicher freizugeben

Code:

procedure ClearList(var List: PListItem);
begin
  if Assigned(List) then
  begin
    ClearList(List^.NextItem);
    dispose(List);
    List := nil;
  end;
end;

Hier wird zun�chst Rekursiv das n�chste Element gel�scht, danach wird das Aktuelle gel�scht. Damit wird die Liste von Hinten nach Vorne gel�scht und auf nil gesetzt.

Nat�rlich k�nnte man noch einen Haufen weiterer Funktionen definieren wie FindElementWithValue um ein bestimmtes Element zu finden oder InsertAt um ein Element an einer bestimmten Position einzuf�gen, aber ich begn�ge mich mit diesem Funktionsumfang.

Also bauen wir jetzt mal ein Projekt was diese Liste verwendet:

Code:

program Liste;

{$mode objfpc}{$H+}

type
  PListItem = ^TListItem;

  TListItem = record
    Value: integer;
    NextItem: PListItem;
  end;

function GetListLength(List: PListItem): integer;
begin
  if Assigned(List) then
    Result := 1 + GetListLength(List^.NextItem)
  else
    Result := 0;
end;

procedure AddElementAtStart(var List: PListItem; x: integer);
var
  tmp: PListItem;
begin
  new(tmp);
  tmp^.Value := x;
  tmp^.NextItem := List;
  List := tmp;
end;

procedure AddElementAtEnd(var List: PListItem; x: integer);
begin
  if Assigned(List) then
    AddElementAtEnd(List^.NextItem, x)
  else
  begin
    new(List);
    List^.Value := x;
    List^.NextItem := nil;
  end;
end;

procedure DeleteListItem(List: PListItem; i: integer);
var
  tmp: PListItem;
begin
  if not Assigned(List) then
    exit; // List Item nicht vorhanden
  if i > 1 then
    DeleteListItem(List^.NextItem, i - 1)
  else if Assigned(List^.NextItem) then // Wenn das zu l�schende element exsistiert
  begin
    tmp := List^.NextItem^.NextItem; //�bern�chstes Item
    dispose(List^.NextItem);
    List^.NextItem := tmp; // �bern�chstes ist jetzt n�chstes Item
  end;
end;

function GetItemValue(List: PListItem; i: integer): integer;
begin
  Result := 0;
  if Assigned(List) then
    if i > 0 then
      Result := GetItemValue(List^.NextItem, i - 1)
    else
      Result := List^.Value;
end;

procedure SetItemValue(List: PListItem; i, x: integer);
begin
  if Assigned(List) then
    if i > 0 then
      SetItemValue(List^.NextItem, i - 1, x)
    else
      List^.Value := x;
end;

procedure ClearList(var List: PListItem);
begin
  if Assigned(List) then
  begin
    ClearList(List^.NextItem);
    dispose(List);
    List := nil;
  end;
end;

var root: PListItem;
    i: Integer;
begin
  root:=nil; // Initialisierung leere liste
  AddElementAtStart(root, 10);
  AddElementAtEnd(root, 5);
  AddElementAtStart(root, 3);
  AddElementAtStart(root, 8);
  AddElementAtEnd(root, 15);
  for i:=0 to GetListLength(root) -1 do
    SetItemValue(root, i, GetItemValue(root, i)+2);
  for i:=GetListLength(root)-1 downto 0 do
    WriteLn(GetItemValue(root, i));
  ClearList(root);
end.

Dieses Programm f�llt zu erst die Liste mit 8, 3, 10, 5, 15. Erh�t danach jedes Element um 2 und gibt diese dann in umgekehrter Reihenfolge wieder aus. Am ende wird durch ClearList noch der Speicher bereinigt.

Bemerkung: Es gibt in der RTL vern�nftige Implementierungen solcher Datenstrukturen wie verkettete Listen, welche wir auch noch kennen lernen werden. Ich f�hre das hier nur als Beispiel zum lernen an, bei der Anwendung sollte man sich die Arbeit sparen und auf diese Implementierungen zur�ckgreifen.

Weitere typische Datenstrukturen f�r die rekursive Typen verwendet werden sind:
B�ume, z.B. ein Bin�rbaum, der aus verschiedenen Elementen besteht die jeweils genau 2 Nachfolger haben.
Doppelt verkettete Listen, Listen bei denen jedes Element einen Zeiger auf das n�chste und das vorhergehende Element haben.
Ringlisten, bei denen das letzte Element wieder auf das erste verweist, etc.

Solche verketteten Listen kann man statt dynamischer Arrays (so genannte Array Listen) benutzen, Arrays bieten einen deutlich schnelleren Zugriff auf einzelne Elemente, und brauchen auch weniger Speicher, allerdings ist das Hinzuf�gen oder Einf�gen von Elementen deutlich langsamer und aufw�ndiger.

Bibliotheken

Spoiler

Bibliotheken bezeichnen Sammlungen von Funktionen, Variablen, Typen, Konstanten oder Komponenten. Heutzutage sind Bibliotheken unerl�sslig, vor allem in form von Frameworks werden gro�e Bibliotheken von Unternehmen und Gruppen entwickelt, so dass der nutzer sich nicht um alle Implementierungen k�mmern muss, sondern sich auf die Programme selbst konzentrieren kann. Im letzten Kapitel hatten wir die Datenstruktur der verketteten Liste kennengelernt, dank Bibliotheken m�ssen wir so etwas nie mehr selbst programmieren, da wir immer auf Implementierungenen in Bibliotheken zur�ckgreifen k�nnen.

Die Hauptbibliotheken mit denen wir in FreePascal arbeiten, bzw. arbeiten werden sind die RTL und FCL, welche Teil des FPC sind, und die LCL welche Teil der Lazarus Entwicklungsumgebung ist.

Units
Essentiell f�r Bibliotheken sind die Unit Dateien. Unit Dateien bieten uns die M�glichkeit Pascal Code, egal ob Typen, Konstanten, Variablen oder Funktionen, in eine extra Datei auszulagern, und diese dann in Programmen oder anderen Units zu verwenden. Eine Unit die wir bereits schon recht h�ufig verwendet haben ist die Unit SysUtils aus der RTL. Wir haben vor allem Funktionen wie StrToInt verwendet, aber auch schon Typen wie die Exception EConvertError (siehe Einschub Kontrollstrukturen 2).

Die Verwendung von Units geschieht �ber die Uses Klausel, wie wir es bereits mit SysUtils gemacht haben. Zu den Besonderheiten der Uses Klausel komme ich sp�ter noch zur�ck, doch jetzt erst einmal zum aufbau einer Unit Datei.

Ein Unit Datei ist eine Pascal Datei, normalerweise mit Dateiendung .pas oder .pp. Der Aufbau ist wie folgt:

Code:

unit Name;

{$MODE ObjFpc}{$H+}
// Weitere Compileranweisungen z.B. Packrecords

interface // �ffentlicher Bereich, Zugriff aus allen anderen Dateien m�glich

{ Uses Klausel  }
{ Type Klausel  }
{ Var Klausel   }
{ Const Klausel }

{ �ffentliche Funktionsk�pfe }

implementation // Privater Bereich, nur lokale Definitionen und Programmcode

{ Uses Klausel  }
{ Type Klausel  }
{ Var Klausel   }
{ Const Klausel }

{ Funktionen }

initialization // optional
  // Dieser Bereich wird bei Programmstart ausgef�hrt

finalization // optional
  // Dieser Bereich wird bei Programmende ausgef�hrt

end.

Eine Unit Programmdatei beginnt mit dem Schl�sselwort unit gefolgt von dem Unit Name. Dieser Name ist der Bezeichner der in der Uses Klausel steht. Der Unit Name sollte mit dem Dateinamen �bereinstimmen. Die Unit MyUnit sollte also entsprechend in einer Datei MyUnit.pas oder MyUnit.pp stehen. Diese Kopfzeile wird, wie bei Programm Dateien mit einem Semikolon abgeschlossen.
Abgeschlossen wird die Datei mit einem end. welches, wie bei Programmen auch, das Dateiende Signalisiert.
Direkt unter dem Kopf kommen dann globale Compileranweisungen wie unser altbekanntes $Mode.
Darunter wird die Unit in 2 Bereiche eingeteilt, dem Interface und der Implementation.

Der Interface Teil enth�lt die allgemeine Uses Klausel der Datei sowie alle Informationen die nach au�en Sichtbar sein sollen, also die von anderen Units und Programmen verwendet werden k�nnen. Darunter fallen Typen, Funktionen, globale Variablen und Konstanten. Im Interface kann aber kein ausf�hrbarer Block stehen. Um Funktionen �ffentlich zu machen werden diese im Implementation Teil geschrieben, und im Interface steht ein Verweis darauf, der Funktionskopf.

Der Implementation Teil kann auch eine Uses Klausel enthalten, diese ist allerdings nur im Implementation Teil nutzbar. Dies hat den Grund, da man in Pascal keine Zirkul�ren Unit Referenzen schreiben kann, das hei�t wenn Unit1 im Interface �ber Uses Unit2 einbindet darf Unit2 im Interface Teil nicht Unit1 einbinden. Werden allerdings dennoch Elemente, z.B. eine Globale Variable aus Unit1 ben�tigt so kann man Unit1 im Implementation Teil �ber uses Einbinden. Allerdings sollte man auch m�glichst versuchen das zu vermeiden, und f�r die geteilten Informationen einfach eine extra Unit erstellen welche von Unit1 und Unit2 verwendet wird.
Darauf folgen im Implementation Teil Typen, Variablen und Konstanten die nur innerhalb der Unit verwendet werden. Hierbei gilt die Regel, es ist alles benutzbar was im Quelltext dr�ber steht.

Au�erdem lassen sich im Implementation Teil Funktionen schreiben. Dies ist eigentlich genau so wie das Funktionsschreiben in einem Programm. M�chte man nun diese Funktionen f�r anderen Dateien sichtbar machen, so muss man den Funktionskopf in den Implementation Teil kopieren.

Unter dem Implementation Teil kann noch ein initialization und ein finalization Block stehen. Der Initialization Block wird beim start der Anwendung ausgef�hrt und kann genutzt werden um z.B. Globale Variablen f�r die Unit zu setzen. Der Finalization Block wird bei Programmende Ausgef�hrt und kann z.B. zum Aufr�umen wie dem Freigeben von Zeigern verwendet werden.

Eine Beispiel Unit k�nnte wie folgt aussehen:

Code:

unit TestUnit;

{$Mode ObjFpc}{$H+}

interface

uses SysUtils;

type 
  PTestType = ^TTestType;
  TTestType = record
    i, x: Integer;
  end;
  
var 
  GlobaleVariable: PTestType;
const 
  GlobaleKonstante = 5;
  
function GlobaleFunktion(i: Integer): Integer;

implementation

var
  Aufrufe: Integer;
  
procedure LocalCounter;
begin
  inc(Aufrufe);
end;

function GlobaleFunktion(i: Integer): Integer;
begin
  Result := i * GlobaleKonstante;
  LocalCounter;
end;

initialization
  new(GlobaleVariable);
  Aufrufe := 0;

finalization
  dispose(GlobaleVariable);

end.

Diese Unit w�rde nun einem Programm oder anderen Units eine Globale Variable, eine Funktion, zwei Typen und eine Konstante bereitstellen. Gleichzeitig �bernimmt diese Unit noch das Erstellen und bereinigen eines Zeigers und verwendet intern noch eine Variable und eine Funktion welche von anderen Dateien nicht verwendet werden k�nnen.

Nun aber zu einem etwas praktischeren Beispiel, nehmen wir die Verkettete Liste aus dem Letzen Kapitel, diese eignet sich sehr gut zum Auslagern.
Also erstellen wir im ordner unseres Programms Liste aus dem letzen Kapitel eine neue Datei, linkedlist.pas und schreiben dort schonmal die Allgemeine Unit struktur hin:

Code:

unit LinkedList;

{$MODE ObjFpc}{$H+}

interface

implementation

end.

Bemerkung: In Lazarus gibt es die Schaltfl�che "Neue Unit" oder den Men�eintrag Datei->Neue Unit um eine solche Unit zu erstellen.

Nun gehen wir in unsere Programmdatei, alle Funktionen die wir f�r die Liste erstellt haben k�nnen wir nun in den Implementation Teil der neuen Unit kopieren, und dann aus der Programmdatei l�schen

Code:

function GetListLength(List: PListItem): integer;
begin
  if Assigned(List) then
    Result := 1 + GetListLength(List^.NextItem)
  else
    Result := 0;
end;

procedure AddElementAtStart(var List: PListItem; x: integer);
var
  tmp: PListItem;
begin
  new(tmp);
  tmp^.Value := x;
  tmp^.NextItem := List;
  List := tmp;
end;

procedure AddElementAtEnd(var List: PListItem; x: integer);
begin
  if Assigned(List) then
    AddElementAtEnd(List^.NextItem, x)
  else
  begin
    new(List);
    List^.Value := x;
    List^.NextItem := nil;
  end;
end;

procedure DeleteListItem(List: PListItem; i: integer);
var
  tmp: PListItem;
begin
  if not Assigned(List) then
    exit; // List Item nicht vorhanden
  if i > 1 then
    DeleteListItem(List^.NextItem, i - 1)
  else if Assigned(List^.NextItem) then // Wenn das zu l�schende element exsistiert
  begin
    tmp := List^.NextItem^.NextItem; //�bern�chstes Item
    dispose(List^.NextItem);
    List^.NextItem := tmp; // �bern�chstes ist jetzt n�chstes Item
  end;
end;

function GetItemValue(List: PListItem; i: integer): integer;
begin
  Result := 0;
  if Assigned(List) then
    if i > 0 then
      Result := GetItemValue(List^.NextItem, i - 1)
    else
      Result := List^.Value;
end;

procedure SetItemValue(List: PListItem; i, x: integer);
begin
  if Assigned(List) then
    if i > 0 then
      SetItemValue(List^.NextItem, i - 1, x)
    else
      List^.Value := x;
end;

procedure ClearList(var List: PListItem);
begin
  if Assigned(List) then
  begin
    ClearList(List^.NextItem);
    dispose(List);
    List := nil;
  end;
end;

Um diese nun �ffentlich nutzbar zu machen m�ssen wir noch die Funktionsk�pfe jeder Funktion in den Interface Teil der Unit schreiben:

Code:

function GetListLength(List: PListItem): integer;
procedure AddElementAtStart(var List: PListItem; x: integer);
procedure AddElementAtEnd(var List: PListItem; x: integer);
procedure DeleteListItem(List: PListItem; i: integer);
function GetItemValue(List: PListItem; i: integer): integer;
procedure SetItemValue(List: PListItem; i, x: integer);
procedure ClearList(var List: PListItem);

Nun m�ssen wir nur noch den Typ vom Programm in die Unit kopieren, und wir haben unsere Verkettete Liste komplett in eine Unit ausgelagert:

Code:

unit LinkedList;

{$MODE ObjFpc}{$H+}

interface

type
  PListItem = ^TListItem;

  TListItem = record
    Value: integer;
    NextItem: PListItem;
  end;
  
function GetListLength(List: PListItem): integer;
procedure AddElementAtStart(var List: PListItem; x: integer);
procedure AddElementAtEnd(var List: PListItem; x: integer);
procedure DeleteListItem(List: PListItem; i: integer);
function GetItemValue(List: PListItem; i: integer): integer;
procedure SetItemValue(List: PListItem; i, x: integer);
procedure ClearList(var List: PListItem);

implementation

function GetListLength(List: PListItem): integer;
begin
  if Assigned(List) then
    Result := 1 + GetListLength(List^.NextItem)
  else
    Result := 0;
end;

procedure AddElementAtStart(var List: PListItem; x: integer);
var
  tmp: PListItem;
begin
  new(tmp);
  tmp^.Value := x;
  tmp^.NextItem := List;
  List := tmp;
end;

procedure AddElementAtEnd(var List: PListItem; x: integer);
begin
  if Assigned(List) then
    AddElementAtEnd(List^.NextItem, x)
  else
  begin
    new(List);
    List^.Value := x;
    List^.NextItem := nil;
  end;
end;

procedure DeleteListItem(List: PListItem; i: integer);
var
  tmp: PListItem;
begin
  if not Assigned(List) then
    exit; // List Item nicht vorhanden
  if i > 1 then
    DeleteListItem(List^.NextItem, i - 1)
  else if Assigned(List^.NextItem) then // Wenn das zu l�schende element exsistiert
  begin
    tmp := List^.NextItem^.NextItem; //�bern�chstes Item
    dispose(List^.NextItem);
    List^.NextItem := tmp; // �bern�chstes ist jetzt n�chstes Item
  end;
end;

function GetItemValue(List: PListItem; i: integer): integer;
begin
  Result := 0;
  if Assigned(List) then
    if i > 0 then
      Result := GetItemValue(List^.NextItem, i - 1)
    else
      Result := List^.Value;
end;

procedure SetItemValue(List: PListItem; i, x: integer);
begin
  if Assigned(List) then
    if i > 0 then
      SetItemValue(List^.NextItem, i - 1, x)
    else
      List^.Value := x;
end;

procedure ClearList(var List: PListItem);
begin
  if Assigned(List) then
  begin
    ClearList(List^.NextItem);
    dispose(List);
    List := nil;
  end;
end;

end.

In unserem Programm f�gen wir dann noch ein uses LinkedList hinzu:

Code:

program Liste;

{$MODE ObjFpc}{$H+}

uses
  LinkedList;

var root: PListItem;
    i: Integer;
begin
  root:=nil; // Initialisierung leere liste
  AddElementAtStart(root, 10);
  AddElementAtEnd(root, 5);
  AddElementAtStart(root, 3);
  AddElementAtStart(root, 8);
  AddElementAtEnd(root, 15);
  for i:=0 to GetListLength(root) -1 do
    SetItemValue(root, i, GetItemValue(root, i)+2);
  for i:=GetListLength(root)-1 downto 0 do
    WriteLn(GetItemValue(root, i));
  ClearList(root);
end.

Und schon haben wir eine eigene kleine Bibliotheken f�r Verkettete Listen erstellt, die wir jetzt in anderen Units oder Programmen verwenden k�nnen.

Units geben uns die M�glichkeit unser Programm in kleine Programmdateien zu unterteilen, was zum einen eine bessere Struktur und Lesbarkeit gibt, wodurch es einfacher ist bestimmte dinge zu finden, und zu bearbeiten, zum anderen erlauben sie uns aber auch Programmcode ohne viel aufwand jederzeit wieder zu verwenden.

Nun m�chte ich nochmal auf Uses eingehen. Im Uses wird, �ber Komma getrennt, der name der Units angegeben die man in dieser Datei verwenden m�chte, dabei sucht der FPC zun�chst einmal in den Suchpfaden nach der Unit Datei, hei�t die Unit z.B. Unit1 so sucht der Compiler nach Unit1.pas oder Unit1.pp.
Die Suchpfade des FPC sind:
1. Das Programmverzeichnis
2. Das Compilerverzeichnis
3. Die Suchpfade aus der fpc.cfg
4. Die Suchpfade die �ber -Fu beim Compilieren angegeben werden.

Bei der Verwendung von Lazarus k�mmert sich die IDE um das verwalten der Suchpfade.

Liegt eine Datei nicht in den Suchpfaden, oder ist anders als der Unitname benannt, so kann man mit dem Schl�sselwort in auch den Pfad angeben:

Code:

uses
  Unit1 in 'Unit1.pas', // Im selben Ordner
  Unit2 in '../Unit2.pas', // Relative Pfadangaben mit ../ und ./ m�glich
  Unit3 in '/Pfad/Zur/Unit.pas'; // absoluze Pfadangaben

Bemerkung: Unter Windows sollte man nat�rlich \ statt / verwenden.

Die Reihenfolge in der man die Units einbindet spielt auch eine Rolle, hat man mehrere Dateien die gleichnamige Funktionen, Konstanten, etc. hat, so wird der FPC immer entweder aus der selben Datei nehemen oder aus der, die aus der Unit nehmen die als erste in der Uses Klausel steht. M�chte man dennoch z.B. eine Funktion aus einer anderen Unit verwenden kann man diese speziell angeben:

Code:

uses
  Unit1, Unit2;

...

procedure Foo;
begin

end;

begin
  Test; // Prozedur Test aus Unit1
  Unit2.Test; // Aus Unit2
  Foo; // Aus eigener datei;
  Unit1.Foo; // Aus Unit1
end;

Au�erdem werden die Initialization und Finalization Teile in der Reihenfolge ausgef�hrt wie sie in der Uses Klausel stehen. Hat man also eine Unit, welche eine z.B. eine Globale Variable im Initialization Teil setzt, welche von anderen Units im Initialization Teil verwendet wird, so muss diese vor den anderen Units im Uses stehen. Ein Beispiel dazu folgt sp�ter in diesem Kapitel.

Programmbibliotheken

Mit Units k�nnen wir Pascal Quelltext Bibliotheken erstellen. Eine weitere Form der Bibliotheken sind die Programmbibliotheken (engl. shared library). Programmbibliotheken sind Sammlungen von Funktionen in kompilierter Form. Programmbibliotheken erm�glichen das bereitstellen von Programmcode Programmiersprachenunabh�ngig. Das hei�t einfach, da diese Bibliotheken kompiliert sind, sind sie wie Programme von Betriebsystem verwaltet, und andere Programme k�nne diese einfach Aufrufen, dann wird der Programmcode der Bibliothek ausgef�hrt. Im gegensatz zu Programmen sind Programmbibliotheken keine eigenst�ndigen Programme und ben�tigen ein aufrufendes Programm welche sie aufruft.

Au�erdem da Programmbibliotheken Kompiliert sind bieten sie die M�glichkeit Funktionen bereitzustellen, ohne dass der nutzer einblick in diesen erh�lt, oder darin was ver�ndern kann.

Typische Programmbibliotheken sind System API's, wie die Windows API. Diese API's (Application Programming Interface) bieten �ber Bibliotheken die m�glichkeit Systemfunktionen aufzurufen.

Programmbibliotheken sind je nach Betriebsystem unterschiedlich. Au�erdem gibt es Statische Bibliothek und Dynamische Bibliotheken.
Statische und Dynamische Bibliotheken werden durch die Dateiendung unterschieden:
Windows: Statisch .lib Dynamisch .dll
Linux: Statisch .a Dynamisch .so
Mac OS X: Statisch .a Dynamisch .dylib

Dynamische Bibliotheken werden nicht in die Executeable kompiliert, und m�ssen separat mitgeliefert werden als so genannte Abh�ngigkeiten (engl. dependency). Bei Statischen Bibliotheken f�llt dies weg. Solche Dateien sind euch daher vielleicht schon mal bei anderen Programmen aufgefallen.

Funktionen aus statische Bibliotheken werden von dem Linker w�hrend des Kompilierens im Programm verwiesen, sodass das Programm diese beim Ausf�hren �ber diese verweise aufgerufen.
Dynamische Bibliotheken k�nnen das selbe aber bieten auch die M�glichkeit w�hrend der Laufzeit Funktionen aus diesem Bibliotheken mit dem Funktionsnamen �ber Funktionszeiger aufzurufen. Damit l�sst sich zum Beispiel ein Plugin System schreiben, welches alle Bibliotheken in einem Ordner l�d und eine Funktion LoadPlugin aufruft.

Bei der Nutzung von Bibliotheken k�mmert sich das System um das laden der Bibliotheken. Dabei suchen die Systeme in verschiedenen Ordnern nach den gesuchten Bibliotheken. Zun�chst wird von den Systemen immer im Aktuellen Programmverzeichnis nach der Bibliothek gesucht. Wird sie dort nicht gefunden wird in den System Bibliotheksverzeichnis gesucht (Windows: Windows\System32, Linux/Unix: /lib/ und /usr/lib/). Wenn dort die Bibliothek nicht gefunden wird kennt das System noch Pfadvariablen (Windows PATH, Unix: /etc/ld.so.conf) welche weitere Suchpfade angeben k�nnen.

Au�erdem kann auch der absolute Pfad zu der Bibliotheksdatei angegeben werden.

Kommen wir zur Nutzung in Pascal.

Um Bibliotheken zu verwenden ben�tigen wir Schnittstellen f�r diese Bibliothek in einer Unit. Bei gr��eren Bibliothek mit vielen Funktionen empfiehlt es sich eine Unit pro Bibliothek zu schreiben, welche dann eine Schnittstelle zu allen Funktionen dieser Bibliothek darstellt. Diese Units nennt man Wrapper.

Befassen wir uns zun�chst mal mit dem Statischen Linken.
Um dem Linker zu sagen er soll eine bestimmte Bibliothek gegenlinken kann man die Compileranweisungen {$LinkLib Lib} global in einer Datei verwenden, wobei der Linker dann nach der Bibliothek Lib sucht und wenn Funktionen aus dieser angefordert werden diese gegenlinkt. Als Beispiel nehmen wir die Funktion strlen aus der Programmiersprache C:

Code:

unit libtest;

{$MODE ObjFpc}{$H+}

interface
{$LINKLIB c}

function strlen(P: pchar): longint; cdecl; external;

implementation

end.

Der Linklib Compilerschalter sagt dem Linker er soll die C Bibliothek gegenlinken. Um Pascal nun zu sagen das die Funktion strlen exsistiert m�ssen wir daf�r einen Funktionskopf angeben, welcher dem Funktionskopf der Bibliothek entspricht. Durch die cdecl Direktive sagen bestimmen wir f�r die Funktion die C Aufrufkonvention, da diese Funktion aus der C Lib stammt, und daher diese Aufrufkonvention verwendet. Das Schl�sselwort external sagt dem Linker er soll in den Bibliotheksdateien nach der Funktion strlen suchen und diese mit diesem Kopf verkn�pfen. Da dieser Funktion im Interface steht ist sie damit auch f�r alle anderen Dateien zug�nglich.

Damit lassen sich sowohl Dynamische als auch Statische Bibliotheken nutzen.

Funktionen aus dynamische Bibliotheken k�nnen mit einer Angabe bei der Funktionsdefinition verkn�pft werden.

Code:

unit libtest;
{$MODE ObjFpc}{$H+}

interface

const LibName = 'c';

function strlen(P: pchar): longint; cdecl; external 'c';
function GetStrLen(P: pchar): longint; cdecl; external LibName name 'strlen';

implementation

end.

Nach dem external �ber eine String Konstante, in diesem Fall 'c', kann angegeben werden in welcher Bibliothek die Funktion gesucht werden soll. Wird noch ein "name Stringkonstante" angegeben, so wird festgelegt wie die Funktion in der Bibliothek hei�t, das ist zum Beispiel m�glich um die Funktion in Pascal anders zu benennen als in der Bibliothek. W�rde man diese Unit so in einem Programm einbinden, so w�rde sowohl strlen als auch GetStrLen die selbe Funktion aus der C Bibliothek aufrufen.

Bemerkung: Name kann man auch mit der Linklib Methode verwenden.

Zuletzt gibt es noch die M�glichkeit Bibliotheken dynamisch in der Laufzeit zu laden, daf�r stellt die RTL die Unit dynlibs zur Verf�gung.

Code:

uses
  dynlibs;

type
  TMyProc = procedure(Argument: Integer); // Funktionszeiger

var
  Lib: TLibHandle;
  func: TMyProc;

begin
  Lib := LoadLibrary('MyLib.' + SharedSuffix); // Bibliothek laden
  if Lib = NilHandle then Exit; // Fehler beim laden -> Ende
  try
    func := TMyProc(GetProcedureAddress(Lib, 'Funktionsname'));
    if Assigned(func) then // Funkiton wurde gefunden
      func(12); // Funktion aufrufen
  finally
    UnloadLibrary(Lib); // Freigeben
  end;
end.

Mit der Funktion LoadLibrary k�nnen wir eine Bibliothek laden, diese Funktion gibt uns dann ein Handle zur�ck, eine art Zeiger f�r das Betriebsystem, damit das System weis um welche Bibliothek es sich handelt. SharedSuffix ist eine Konstante die je nach System die Dateiendung von Programmbibliotheken zur�ckgibt (Windows: 'dll'). Wird NilHandle (0) zur�ckgegeben so ist ein Fehler aufgetreten und die Bibliothek konnte nicht geladen werden. Danach �ffnen wir einen Try-Finally Block, um sicher zu gehen, dass die Bibliothek auch Freigegeben wird.
�ber GetProcedureAddress bekommen wir dann einen Funktionszeiger als untypisierten Zeiger �bergeben. Um diesen ausf�hren zu k�nnen m�ssen wir ihn in einen Funktionszeiger der Bibliotheksfunktion Casten. In diesem Fall w�re das eine Funktion ohne R�ckgabewert die einen Integer als Parameter an nimmt.
Das Freigeben der Bibliothek erfolgt am Ende �ber UnloadLibrary.

Unter Unix/Linux: Benutzt man Programmbibliotheken die nicht in Pascal geschrieben wurden welche Dynamischen Speicher (Zeiger, Strings, Dyn Arrays) �bergeben der in der Bibliothek als auch im Programm verwaltet (Freigeben oder Alloziieren) wird, so muss als erste Unit in der Uses Klausel der Program Datei die Unit cmem eingebunden werden, damit diese im Initialization und Finalization Teil den Memory Manager umstellen kann.

Bibliotheken schreiben

Nun nachdem wir gelernt haben wie Programmbibliotheken verwendet werden befassen wir uns mit dem schreiben solcher. FreePascal unterst�tzt nur das schreiben Dynamischer Bibliotheken, bei Statischen kann man die Object Files welche beim Kompilieren erzeugt werden selbst gegenlinken und als Statische Bibliothek verwenden.

Daf�r gibt es einen weiteren Typ von Pascal Quelltextdateien, die Library Datei.
Vom Aufbau ist dieser Dateityp sehr �hnlich zu dem Program Datentyp:

Code:

library Name;

{ Compilerschalter }

{ Uses }

{ Typen }
{ Variablen }
{ Konstanten }
{ Funktionen }

exports // optional
{ Funktionsnamen }

begin // Optional
{ Quelltext }
end.

Das Schl�sselwort f�r diese Dateien ist library, sonst unterscheiden sich Program und Library Dateien bei der exports Sektion. In dieser Sektion listet man alle Funktionsnamen mit Komma getrennt auf die durch die Programmbibliothek bereitgestellt werden sollen.
Wie man sieht haben Bibliotheken auch eine ausf�hrbaren Teil wie Programme, einen begin Block. Dieser wird beim Laden der Bibliothek ausgef�hrt. Sowohl die exports als auch begin Sektion sind optional, das hei�t es ist m�glich Bibliotheken zu schreiben die keine Funktionen bereitstellen, sondern nur Programmcode ausf�hren, aber auch m�glich Bibliotheken zu schreiben welche keinen Programmcode ausf�hren. Au�erdem ist es m�glich Bibliotheken zu schreiben welche weder Programmcode ausf�hren noch Funktionen bereitstellen, wie sinnreich das ist d�rft ihr selbst beurteilen.

Bemerkung: Der Initialization Teil einer der Units die von Bibliotheken verwendet werden wird beim Laden der Bibliothek ausgef�hrt und der Finalization Teil bei dem Freigeben.

Um nocheinmal unser Beispiel mit der Verketteten Liste zu verwenden schreiben wir nun f�r diese Liste eine eigene Programmbibliothek in der Datei linkedlist.pas:

Code:

library LinkedList;

{$MODE OBJFPC}{$H+}


type
  PListItem = ^TListItem;

  TListItem = record
    Value: integer;
    NextItem: PListItem;
  end;

function GetListLength(List: PListItem): integer;
begin
  if Assigned(List) then
    Result := 1 + GetListLength(List^.NextItem)
  else
    Result := 0;
end;

procedure AddElementAtStart(var List: PListItem; x: integer);
var
  tmp: PListItem;
begin
  new(tmp);
  tmp^.Value := x;
  tmp^.NextItem := List;
  List := tmp;
end;

procedure AddElementAtEnd(var List: PListItem; x: integer);
begin
  if Assigned(List) then
    AddElementAtEnd(List^.NextItem, x)
  else
  begin
    new(List);
    List^.Value := x;
    List^.NextItem := nil;
  end;
end;

procedure DeleteListItem(List: PListItem; i: integer);
var
  tmp: PListItem;
begin
  if not Assigned(List) then
    exit; // List Item nicht vorhanden
  if i > 1 then
    DeleteListItem(List^.NextItem, i - 1)
  else if Assigned(List^.NextItem) then // Wenn das zu l�schende element exsistiert
  begin
    tmp := List^.NextItem^.NextItem; //�bern�chstes Item
    dispose(List^.NextItem);
    List^.NextItem := tmp; // �bern�chstes ist jetzt n�chstes Item
  end;
end;

function GetItemValue(List: PListItem; i: integer): integer;
begin
  Result := 0;
  if Assigned(List) then
    if i > 0 then
      Result := GetItemValue(List^.NextItem, i - 1)
    else
      Result := List^.Value;
end;

procedure SetItemValue(List: PListItem; i, x: integer);
begin
  if Assigned(List) then
    if i > 0 then
      SetItemValue(List^.NextItem, i - 1, x)
    else
      List^.Value := x;
end;

procedure ClearList(var List: PListItem);
begin
  if Assigned(List) then
  begin
    ClearList(List^.NextItem);
    dispose(List);
    List := nil;
  end;
end;

exports
GetListLength,
AddElementAtStart,
AddElementAtEnd,
DeleteListItem,
GetItemValue,
SetItemValue,
ClearList;

end.

Diese kompilieren wir dann ganz normal �ber

Code:

fpc linkedlist.pas

Damit sollte der FPC eine Dynamisch Programmbibliothek erzeugen, nach den Nameskonventionen des betreffenden Betriebsystems (Unter Unix ist wird vor den Dateinamen ein lib geh�ngt).

Dann ben�tigen wir eine Wrapper Unit llist.pas f�r diese Bibliothek:

Code:

unit llist;

{$MODE OBJFPC}{$H+}

interface
type
  PListItem = ^TListItem;

  TListItem = record
    Value: integer;
    NextItem: PListItem;
  end;
  
const
{$ifdef win32}
  lllib = 'linkedlist.dll';
{$else}
  {$ifdef darwin}
    lllib = 'liblinkedlist.dylib';
    {$linklib liblinkedlist.dylib}
  {$else}
    lllib = 'liblinkedlist.so';
  {$endif}
{$endif}

function GetListLength(List: PListItem): integer; external lllib;
procedure AddElementAtStart(var List: PListItem; x: integer); external lllib;
procedure AddElementAtEnd(var List: PListItem; x: integer); external lllib;
procedure DeleteListItem(List: PListItem; i: integer); external lllib;
function GetItemValue(List: PListItem; i: integer): integer; external lllib;
procedure SetItemValue(List: PListItem; i, x: integer); external lllib;
procedure ClearList(var List: PListItem); external lllib;

implementation

end.

�ber die IFDEF Compileranweisungen bef�llen wir je nach Betriebsystem die Konstante lllib mit dem Namen der Bibliothek. Bei Mac OSX (Darwin) muss au�erdem noch eine $Linklib Compileranweisung gesetzt werden.

Dann k�nnen wir diese Wrapperunit ganz normal verwenden:

Code:

program LinkedListTest;
{$MODE OBJFPC}{$H+}

uses 
  llist;
  
var root: PListItem;
    i: Integer;
begin
  root:=nil; // Initialisierung leere liste
  AddElementAtStart(root, 10);
  AddElementAtEnd(root, 5);
  AddElementAtStart(root, 3);
  AddElementAtStart(root, 8);
  AddElementAtEnd(root, 15);
  for i:=0 to GetListLength(root) -1 do
    SetItemValue(root, i, GetItemValue(root, i)+2);
  for i:=GetListLength(root)-1 downto 0 do
    WriteLn(GetItemValue(root, i));
  ClearList(root);
end.

Konventionen f�r Programmbibliotheken

Programmbibliotheken bieten die M�glichkeit Funktionen bereitzustellen. Da sich jede Programmiersprache und auch einige Compiler bei Align von Records oder den Standardaufrufkonventionen von Funktionen unterscheiden muss man sich nat�rlich beim bereitstellen einer Programmbibliothek entsprechend richten.
FreePascal benutzt z.B. standardm��ig die Pascal Aufrufkonvention und ein eigenes Align f�r Recordelemente. Um nun die Bibliothek allgemein zug�nglich zu machen ist dies nicht die beste Wahl. Den allgemeinen Standard bietet dabei die Programmiersprache C, da diese sehr weit Verbreitet ist, und der Standard durch die ISO wohldefiniert und einfach zug�nglich ist.

Konkret bedeutet das:
Verwendung von Packed Records, oder C Record Align
Funktionsaufrufe mit cdecl Aufrufkonvention
Unter Unix/Linux: C Memory Management f�r Zeiger und Dynamischen Speicher (Strings und Arrays)

Um die Records anzupassen ist die einfachste M�glichkeit einfach Packed Records zu verwenden, diese sind zwar langsamer und umst�ndlicher f�r das System als Records mit Alignment, aber werden von jeder Sprache gleich unterst�tzt und genutzt.
Wenn man nun aber nicht mit Packed Records arbeiten m�chte tut es auch eine Zeile:

Code:

{$PackRecords C}

am Anfang jeder Datei in der Records Definiert werden, um das C Alignment zu verwenden.

Die Aufrufkonvention f�r Funkitonen kann man im Funktionskopf definieren:

Code:

procedure Foo(Arg: Typ); cdecl;

w�rde eine Funktion mit der C Aufrufkonvention definieren.
Unter Windows wird auch sehr oft, z.B. in der Windows System API, die stdcall Aufrufkonvention verwendet:

Code:

procedure Foo(Arg: Typ); stdcall;

Unter Unix/Linux:
Um das Memory Management umzustellen gibt es die Unit cmem, welche in ihrem Initialization und Finalization Teil darum k�mmert. Diese muss als erste Unit der Bibliothek �ber Uses eingebunden werden:

Code:

library Name;

{ Compilerschalter }

uses
  cmem, //Weitere Units
  
...

Den Memory Manager umzustellen ist unerl�sslig wenn man Dynamische Datentypen wie Zeiger, Strings oder Dynamische Arrays sowohl in der Bibliothek und einer Anwendung verwaltet wird. Aber es kommt sehr selten vor das Dynamischer Speicher sowohl von Bibliothek als auch Programm verwaltet werden muss.

Bemerkung: W�hrend das Record Align und das Memory Management wichtig sind, um die Funktionalit�t bei der Nutzung durch andere Sprachen und Compiler zu gew�hrleisten, ist die Wahl der Aufrufkonvention (Pascal, C, StdCall) jedem Entwickler selbst �berlassen, solange sie sauber dokumentiert ist.

Au�erdem gibt es bei Mac OSX (Darwin) noch ein paar kleinere eigenheiten was das Dynamische Laden �ber LoadLibrary angeht. �ber GetProcedureAddress(Lib, Name) k�nnen nur Funktionen geladen werden welche mit einem '_' vor dem Namen beginnen, das hei�t beim Publizieren einer .dylib f�r OSX welche Dynamisch geladen werden soll muss in der Bibliothek jede Funktion noch ein _ vor den Namen bekommen:

Code:

library Example;

{$ifdef darwin}
  procedure _Foo;
{$else}
  procedure Foo;
{$endif}
begin
...
end;

exports
  {$ifdef darwin}
  _Foo;
{$else}
  Foo;
{$endif}

end.

Bei Statischer Nutzung ist dies nicht notwendig.

Unsere Bibliothek w�rde mit diesen Konventionen dann so aussehen:

Code:

library LinkedList;

{$MODE OBJFPC}{$H+}
{$PackRecords C}

type
  PListItem = ^TListItem;

  TListItem = record
    Value: integer;
    NextItem: PListItem;
  end;

function GetListLength(List: PListItem): integer; cdecl;
begin
  if Assigned(List) then
    Result := 1 + GetListLength(List^.NextItem)
  else
    Result := 0;
end;

procedure AddElementAtStart(var List: PListItem; x: integer); cdecl;
var
  tmp: PListItem;
begin
  new(tmp);
  tmp^.Value := x;
  tmp^.NextItem := List;
  List := tmp;
end;

procedure AddElementAtEnd(var List: PListItem; x: integer); cdecl;
begin
  if Assigned(List) then
    AddElementAtEnd(List^.NextItem, x)
  else
  begin
    new(List);
    List^.Value := x;
    List^.NextItem := nil;
  end;
end;

procedure DeleteListItem(List: PListItem; i: integer); cdecl;
var
  tmp: PListItem;
begin
  if not Assigned(List) then
    exit; // List Item nicht vorhanden
  if i > 1 then
    DeleteListItem(List^.NextItem, i - 1)
  else if Assigned(List^.NextItem) then // Wenn das zu l�schende element exsistiert
  begin
    tmp := List^.NextItem^.NextItem; //�bern�chstes Item
    dispose(List^.NextItem);
    List^.NextItem := tmp; // �bern�chstes ist jetzt n�chstes Item
  end;
end;

function GetItemValue(List: PListItem; i: integer): integer; cdecl;
begin
  Result := 0;
  if Assigned(List) then
    if i > 0 then
      Result := GetItemValue(List^.NextItem, i - 1)
    else
      Result := List^.Value;
end;

procedure SetItemValue(List: PListItem; i, x: integer); cdecl;
begin
  if Assigned(List) then
    if i > 0 then
      SetItemValue(List^.NextItem, i - 1, x)
    else
      List^.Value := x;
end;

procedure ClearList(var List: PListItem); cdecl;
begin
  if Assigned(List) then
  begin
    ClearList(List^.NextItem);
    dispose(List);
    List := nil;
  end;
end;

exports
GetListLength,
AddElementAtStart,
AddElementAtEnd,
DeleteListItem,
GetItemValue,
SetItemValue,
ClearList;

end.

Und der Wrapper:

Code:

unit llist;

{$MODE OBJFPC}{$H+}
{$PackRecords C}

interface
type
  PListItem = ^TListItem;

  TListItem = record
    Value: integer;
    NextItem: PListItem;
  end;
  
const
{$ifdef win32}
  lllib = 'linkedlist.dll';
{$else}
  {$ifdef darwin}
    lllib = 'liblinkedlist.dylib';
    {$linklib liblinkedlist.dylib}
  {$else}
    lllib = 'liblinkedlist.so';
  {$endif}
{$endif}

function GetListLength(List: PListItem): integer; cdecl; external lllib;
procedure AddElementAtStart(var List: PListItem; x: integer); cdecl; external lllib;
procedure AddElementAtEnd(var List: PListItem; x: integer); cdecl; external lllib;
procedure DeleteListItem(List: PListItem; i: integer); cdecl; external lllib;
function GetItemValue(List: PListItem; i: integer): integer; cdecl; external lllib;
procedure SetItemValue(List: PListItem; i, x: integer); cdecl; external lllib;
procedure ClearList(var List: PListItem); cdecl; external lllib;

implementation

end.

Unsere Program Datei muss nicht bearbeitet werden.

Bemerkung: Da wir diese Bibliothek nur Statisch verwenden tritt das Problem unter OSX mit _ nicht auf.

Wrapper erstellen

F�r viele Programmbibliotheken gibt es Wrapper f�r viele verschiedene Sprachen, mei�t auch Pascal (oder Delphi). Ist dies aber nicht der Fall, so l�sst sich zwar aus einer sauberen Dokumentation der Bibliothek ein solcher Konstruieren, allerdings ist dies sehr m�hsam und in der Realit�t wird man schnell merken dass die mei�ten Bibliotheken recht unsauber dokumentiert sind.
Abhilfe verschafft uns dabei die Wrapper in anderen Programmiersprachen. F�r die mei�ten Bibliotheken gibt es einen Wrapper in C, als .h Datei, welcher alle Funktionen sauber implementiert. Wenn man nun nicht so gut C kann, oder es einem zu aufw�ndig ist den Wrapper zu �bersetzen gibt es ein kleines Programm als Teil der FPC Installation, h2pas, welches C Headerfiles weitestgehend in Pascal Units �bersetzt. Die Dokumentation zu diesem Programm findet ihr [Only registered and activated users can see links. Click Here To Register...].

Dateien Lesen & Schreiben

Spoiler

Das letzte Kapitel zum Klassischen Pascal geht um das Thema Dateien. Wie Bekannt sein sollte Speichert der Computer Informationen dauerhaft in Form von Dateien in einem Dateisystem. Dabei hat jede Datei einen Namen, und einen Pfad zu dem Ordner der die Datei enth�lt. Je nach Betriebsystem unterscheidet sich die Darstellung von Dateiname und Pfad. Windows z.B. stellt jedes Speichermedium als Laufwerk da, welches mit einem Buchstaben und einem Doppelpunkt gekennzeichnet ist (C:, E:, D:), und dann mit Backslashes getrennt die Ordnerstruktur des Pfades, und am Ende der Dateiname, z.B.

Code:

C:\Pfad\Zur\Datei.ext

Unix Systeme hingegen Haben ein so genanntes Root Directory, der Basispfad des Speichermediums auf dem das System Installiert ist, und weitere Speichermedien werden als Ordner in diese Struktur eingeh�ngt. Die Darstellung beginnt mit einem Slash, und darauf werden alle Ordner mit Slashes getrennt und am Ende folgt der Dateiname. Z.B:

Code:

/Pfad/Zur/Datei.ext

Zur Kategoriesierung der Dateien werden u.a. Dateiendungen verwendet, welche mit einem Punkt getrennt an den Dateinamen angeh�ngt werden (um Beispiel .ext). Es gibt keine wirklichen Vorgaben an die Dateiendungen, und die k�nnen auch theoretisch beliebig verwendet werden, allerdings wird mei�t eine aussagekr�ftige Abk�rzung f�r den Dateiinhalt verwendet. So steht z.B. .txt f�r Textdateien, .exe f�r Windows Executeables, und .bmp f�r Bitmap.

Konvention: Bei dem schreiben von eigenen Dateieformaten sollte man eine vern�nftige Dateiendung w�hlen, so beh�lt man selbst, oder andere die sich die Programme ansehen einen �berblick dar�ber was f�r ein Inhalt sich hinter einer Datei verbirgt. Mei�t werden zur nomenklatur 3-4 Buchstaben lange Abk�rzungen englischer W�rter verwendet wie .bin f�r bin�re Dateien, .lst f�r Listen, .cfg f�r Konfigurationsdateien. Man sollte auch versuchen keine Etablierten Dateiendungen zu verwenden (wie .jpg f�r Textdokumente).

Dateitypen und Aufbau

Grunds�tzlich unterscheiden wir zwischen zwei Typen von Dateien, Textdateien und Bin�rdateien, da diese sich im Umgang unterscheiden.
Textdateien sind Dateien mit f�r Menschen lesbaren Buchstaben. Textdateien werden entweder Zeilenweise, Wort f�r Wort, oder jeder Charakter einzeln gelesen.

Bin�rdateien hingegen werden Byteweise beschrieben. In Bin�rdateien werden die Werte in dem selben Byteformat wie die Pascal Datentypen gespeichert.
Da Bin�redatentypen im gegensatz zu Textdateien nicht �ber einen einfachen Syntaxcheck verifiziert werden k�nnen, und die Bytes in verschiedenen Datentypen komplett andere Werte hat, verwendet man einen Header, um Informationen �ber den Inhalt zu stellen. Als Teil dieses Headers verwendet man oftmals eine so genannte Magic Number, eine Zahl, die den Datentypen Beschreibt. Wenn die Magic Number nicht der erwartete Wert ist wei� man dass es nicht der richtige Datentyp ist. Im Umkehrschluss kann man, bei mehreren Dateien mit gleicher Dateiendung �ber die Magic Number feststellen was der Inhalt dieser Dateien ist.

Pascal kennt au�erdem noch Typisierte Bin�rdateien, das sind Bin�rdateien die nur einen Datentypen enthalten k�nnen, z.B. nur Integer Werte.

Dateien in Pascal

Um Dateien zu verwenden nutzt man in Pascal so genannte File Handles, das sind Betriebsystem interne Kennnummern f�r die ge�ffneten Dateien. Der Variablentyp f�r ein solches Dateihandle ist:
TextFile f�r Textdateien
File of Typ f�r typisierte Bin�rdateien
File f�r untypisierte Bin�rdateien.

Egal welcher Art, die Dateihandles bekommt man via AssignFile, muss sie mit CloseFile wieder Freigeben.
Genau wie bei Zeigern empfiehlt sich hier die Nutzung eines Try-Finally Blocks.

Code:

var F: TextFile;
begin
  AssignFile(F, 'Pfad/Zur/Datei.ext');
  try
  
  finally
    CloseFile(F);
  end;
end;

Mit dem AssignFile wird das Handle zugewiesen, danach muss die Datei allerdings noch ge�ffnet werden. Das �ffnen geschieht �ber Reset, Rewrite oder Append.
Append ist zum Schreiben am Ende von Textdateien, also zum Anh�ngen von Texten. Rewrite erstellt eine neue Datei, exsistiert die Datei bereits wird sie �berschrieben. Reset �ffnet Textdateien zum lesen, oder Bin�rdateien zum Lesen und/oder Schreiben.

Nun gehe ich n�her auf die einzelnen Typen ein.

Textdateien

Textdateien lie�t und schreibt man genau wie mit der Konsole. Man verwendet Read und ReadLn bzw Write und WriteLn:

Code:

Read(FileHandle, Variable); // Lese Inhalt von FileHandle in Variable
ReadLn(FileHandle, Variable); // Lese eine Zeile in Variable
Write(FileHandle, Wert); // Schreibt Wert in die Textdatei
WriteLn(FileHandle, Wert); // Schreibt Wert+Zeilenumbruch in Textdatei

Am besten erkl�rt das ein Beispiel Code:

Code:

program ReadText;

{$Mode ObjFPC}{$H+}

var
  F: TextFile;
  i: Integer;
  s: String;
  d: Double;
begin
  // Variablen �ber Konsole einlesen
  ReadLn(i);
  ReadLn(s);
  ReadLn(d);
  AssignFile(F, 'datei.txt');
  try
    Rewrite(F);
    // Zeilenweise Informationen Schreiben
    WriteLn(F, i);
    WriteLn(F, s);
    WriteLn(F, d);
  finally
    CloseFile(F);
  end;
  // Daten Lesen
  AssignFile(F, 'datei.txt');
  try
    Reset(F);
    // Zeilenweise auslesen
    ReadLn(F, i);
    ReadLn(F, s);
    ReadLn(F, d);
  finally
    CloseFile(F);
  end;
  // Daten Ausgeben
  WriteLn(i);
  WriteLn(s);
  WriteLn(d);
end.

Dieses Programm sichert einen String, einen Integer und einen Double Zeilenweise in einer Textdatei und lie�t diese anschlie�end wieder aus. Der Dateiinhalt ist mit 123 als Integer, String als String und 3.5 als Double dann:

Code:

123
String
 3.5000000000000000E+000

Viel zu beachten gibt es an dieser Stelle eher nicht, da wir diese Form des Lesen und Schreiben schon von der Konsole kennen.

Typisierte Bin�rdateien

Bei Typisierten Bin�rdateien gibt man bei der Definition der Handle Variable einen Datentypen an, je nach dem was der Inhalt der Datei sein soll.

Bin�re Dateien kann man mittels Reset in verschiedenen Modi �ffnen. Daf�r stellt Pascal die Globale Variable FileMode bereit. Diese kann man vor dem verwenden von Reset auf 3 verschiedene Werte setzen:

Code:

fmOpenRead = 0
fmOpenWrite = 1
fmOpenReadWrite = 2

Um die Datei entsprechend zum Lesen, Schreiben oder beidem zu �ffnen.
Wenn man eine Datei zum Schreiben �ffnet, ohne die entsprechende Berechtigung im System zu haben wirft dies einen Fehler.

Hinweis: Wenn man die Variable FileMode nicht setzt so wird die Datei mit dem Default Modus fmOpenReadWrite ge�ffnet.

Bei typisierten bin�ren Dateien werden Informationen via Read und Write geschrieben.
In dem folgenden Beispiel wird ein Record in eine Bin�rdatei geschrieben:

Code:

program BinFileTest;

{$MODE ObjFPC}{$H+}
uses SysUtils;

type
  // Record der gesichert werden soll
  TMyRec = record
		MyInt1, MyInt2: Integer;
		MyStr: ShortString;
    MyDouble: Double;
	end;

var
  // FileHandle
  F: File of TMyRec;
  // Record Variable
	Rec: TMyRec;

begin
  // Record bef�llen
  Rec.MyInt1 := 5;
	Rec.MyInt2 := 10;
	Rec.MyStr := 'Hallo Welt'; // ShortString statische zusammengesetze Struktur
	Rec.MyDouble := 3.5;

  // Datei �ffnen
	AssignFile(F, 'Test.bin');
  try
    Rewrite(F);
    // Record schreiben
    Write(F, Rec);
  finally
	 CloseFile(F);
  end;

  // Record L�schen
  FillChar(Rec, SizeOf(Rec), #00);

  // Datei wieder �ffnen
	AssignFile(F, 'Test.bin');
  try
    // FileMode setzen
    FileMode := fmOpenRead;
    Reset(F);
    // Daten Lesen
    Read(F, Rec);
  finally
	 CloseFile(F);
  end;

  // Daten Ausgeben
	WriteLn(Rec.MyInt1);
	WriteLn(Rec.MyInt2);
	WriteLn(Rec.MyStr);
	WriteLn(Rec.MyDouble);
end.

Bemerkung: In diesem Beispiel verwende ich ShortString, da ShortStrings als statisch zusammengesetze Datenstruktur sich einfach Byteweise sichern lassen. Bei Dynamischen Strings w�rde lediglich der Zeiger auf den String gesichert werden.

Als Typen f�r diese Dateien kann man letztlich alles nehmen, au�er Zeiger, Dynamische Arrays oder Dynamische Strings, da man damit nur den Zeiger Speichern w�rde, welcher beim n�chsten Durchlauf nat�rlich nicht unbedingt der Selbe sein muss. Statische Arrays, ShortStrings, Records oder andere Ordin�rypen lassen sich aber ohne Probleme speichern.

Untypisierte Bin�rdateien

Schlussendlich gibt es noch untypisierte Bin�rdateien. In diese kann man beliebige bin�re Daten sichern.
Daf�r �bergibt man der Funktion Reset bzw. Rewrite neben dem FileHandle noch einen weiteren Parameter, RecordSize. Diese gibt an in wie gro�en Bl�cken geschrieben bzw gelesen werden soll. Schreibt man z.B. nur Integer (4 Byte) und Double (8 Byte) in eine Datei kann man eine RecordSize von 4 Byte w�hlen. Will man z.B. Bytes, oder genaue Gr��en wie von Packed Records sichern sollte man eine RecordSize von 1 Byte w�hlen.

Gelesen und Geschrieben wird dann mit den Funktionen:

Code:

BlockRead(FileHandle, Buffer, Count, ReadCount);
BlockWrite(FileHandle, Buffer, Count, WriteCount);

Wobei WriteCount bzw. ReadCount Optionale Var Parameter sind. Buffer is auch ein Var Parameter, �ber welchen die Variable �bergeben wird deren Inhalt geschrieben werden soll, oder in die gelesen werden soll. Count gibt an wie viele Einheiten der �ber Reset bzw. Rewrite RecordSize gr��e gelesen werden soll. Wenn eine Optionale Variable ReadCount bzw. WriteCount �bergeben wird, wird dort gespeichert wie viele Einheiten tats�chlich gelesen wurden (im Fall dass man versucht mehr Bytes zu lesen als die Datei enth�lt).

Bemerkung: Will man gr��ere Datenmengen in einen Array oder String laden, so empfiehlt sich die Elemente in gr��eren Bl�cken (z.B. 1024 Bytes) zu lesen, und �ber ReadCount kann man dann �berpr�fen ob man am Ende der Datei angekommen ist.

Ein kleines Beispiel:

Code:

program BinFileTest;

{$MODE ObjFPC}{$H+}
uses SysUtils;

var
  F: File;
  i: Integer;
  s: ShortString;
  d: Double;

begin
  i := 4;
  s := 'Hallo Welt';
  d := 3.5;
	AssignFile(F, 'Test.bin');
	try
    Rewrite(F, 1); // 1 Byte RecordSize
    BlockWrite(F, i, SizeOf(Integer)); // Integer Schreiben
    BlockWrite(F, s, SizeOf(s)); // ShortString schreiben
    BlockWrite(F, d, SizeOf(d)); // Double schreiben
  finally
	  CloseFile(F);
	end;

	AssignFile(F, 'Test.bin');
	try
	  FileMode := fmOpenRead; // Lesen
    Reset(F, 1); // 1 Byte RecordSize
    BlockRead(F, i, SizeOf(Integer)); // Integer Schreiben
    BlockRead(F, s, SizeOf(s)); // ShortString schreiben
    BlockRead(F, d, SizeOf(d)); // Double schreiben
  finally
	  CloseFile(F);
	end;

	WriteLn(i);
	WriteLn(s);
	WriteLn(d);
end.

Dabei wird ein Integer, ein Double und ein ShortString in die Bin�rdatei geschrieben.

Generell l�sst sich �ber die Verschiedenen Dateien sagen, Bin�rdateien sind deutlich schneller zu lesen, daf�r aber nicht mit normalen Editoren ver�nderbar. Textdateien sind f�r jeden Nutzer gut Lesbar und Editierbar. Typisierte Bin�rdateien sind sehr einfach zu verwenden, und solange man nur einzelne Datentypen sichert eine sehr schnelle einfache M�glichkeit, die vor allem k�rzer ist als die untypisierte L�sung.

Weitere Dateioperationen

Zum arbeiten mit Dateien gibt es noch mehr Funktionen:

function Eof(FileHandle): Boolean;
Diese Funktion gibt True zur�ck wenn das FileHandle auf das Ende der Datei zeigt.

Code:

While not Eof(F) do
begin
  // Zeilenweise Auslesen und ausgeben
  ReadLn(F, s);
  WriteLn(s);
end;

procedure Seek(FileHandle; Pos);
Diese Funktion setzt die Position des FileHandle auf Pos. Pos gibt die Position als Einheiten in RecordSize an oder in Gr��e des Typs bei typisierten Dateien. Seek funktioniert nicht auf Textdateien, sondern nur auf Bin�ren Dateien.

Code:

Seek(F, 0);
Read(F, i); // Erstes Element auslesen
Seek(F, 2);
Read(F, i); // Drittes Element auslesen

function FilePos(FileHandle): Integer;
Diese Funktion gibt die aktuelle Position des FileHandles zur�ck. Wie bei Seek auch wird die Position als Einheiten in Record bzw. Typgr��en angegeben.

Code:

Seek(F, FilePos(F) - 1);
Read(F, i); // Vorheriges Element auslesen

Arrays, Strings und Zeiger schreiben
Zuletzt m�chte ich noch kurz darauf eingehen wie man Arrays und Strings in Bin�rdateien schreibt. Bei statischen Arrays und ShortStrings ist das absolut kein Problem, und die k�nnen genau so wie andere Variablen auch geschrieben werden. Dynamische Strings und Arrays allerdings sind letztlich Zeiger, und w�rde man diese einfach so schreiben w�rde das nur den Zeiger in die Datei schreiben, welcher beim n�chsten lesen wahrscheinlich nicht mehr g�ltig ist, oder vielleicht auf ein Komplett anderes Element zeigt. Daf�r sehen wir uns zun�chst einmal an wie wir Zeiger schreiben w�rden:

Code:

var PInt1: PInteger;
  F: File;
begin
  // Initialisierung von F und PInt1
  BlockWrite(F, PInt1^, SizeOf(Integer));
  //...
  BlockRead(F, PInt1^, SizeOf(Integer));
end;

Durch den Dereferenzierungsoperator ^ geben wir an dass wir den Inhalt auf den der Zeiger zeigt schreiben wollen, bzw. das Gelesene das Element hinter dem Zeiger schreiben wollen.

Bei Arrays oder Strings k�nnen wir es genauso machen, wir k�nnen diese einfach in einen Pointer Casten und dann �ber ^ Schreiben lassen. Da die L�nge allerdings Dynamisch ist m�ssen wir noch dazu speichern wie viele Elemente wir schreiben werden. Au�erdem m�ssen wir bei dem Count Parameter noch die Anzahl an Elementen und ihre Gr��e ber�cksichtigen:

Code:

var
  arr: Array of Integer;
  Str: AnsiString;
  Len: Integer;
  F: File;
begin
  // Initialisierung
  // Array schreiben
  Len := Length(arr);
  BlockWrite(F, Len, SizeOf(Len));
  BlockWrite(F, PInteger(arr)^, Len * SizeOf(Integer));
  // String Schreiben
  Len := Length(Str);
  BlockWrite(F, Len, SizeOf(Len));
  BlockWrite(F, PChar(Str)^, Len * SizeOf(Char));
end;

vor dem Lesen m�ssen wir dann die L�nge auslesen und den Array/String mit SetLength auf diese L�nge setzen:

Code:

var
  Arr: Array of Integer;
  Str: AnsiString;
  Len: Integer;
begin
  // Initialisierung
  // Array Lesen
  BlockRead(F, Len, SizeOf(Len));
  SetLength(arr, Len);
  BlockRead(F, PInteger(arr)^, Len * SizeOf(Integer));
  // String Lesen
  BlockRead(F, Len, SizeOf(Len));
  SetLength(Str, Len);
  BlockRead(F, PChar(Str)^, Len * SizeOf(Char));
end;

Eine andere M�glichkeit ist es statt Zeiger zu nehmen Arrayelemente zu Adressieren:

Code:

var
  arr: Array of Integer;
  Str: AnsiString;
  Len: Integer;
  F: File;
begin
  // Initialisierung
  // Array schreiben
  Len := Length(arr);
  BlockWrite(F, Len, SizeOf(Len));
  BlockWrite(F, arr[0], Len * SizeOf(Integer));
  // String Schreiben
  Len := Length(Str);
  BlockWrite(F, Len, SizeOf(Len));
  BlockWrite(F, Str[1], Len * SizeOf(Char));
  // Array Lesen
  BlockRead(F, Len, SizeOf(Len));
  SetLength(arr, Len);
  BlockRead(F, arr[0], Len * SizeOf(Integer));
  // String Lesen
  BlockRead(F, Len, SizeOf(Len));
  SetLength(Str, Len);
  BlockRead(F, Str[1], Len * SizeOf(Char));

Damit k�nnen auch sehr gut nur Teile eines Arrays oder Strings gelesen bzw. geschrieben werden. Allerdings hat das den Nachteil, wenn man mit einem Debugger arbeitet (z.B. dem GDB) welcher mit Array RangeChecks arbeitet kann es vorkommen, dass dieser Dabei Fehler wirft, weil man bei einem Leeren Array kein Element Adressieren sollte (auch wenn in diesem Fall eh kein Zugriff geschehen w�rde da Len = 0 w�re). Also ein Fehlarlam, welcher dennoch sehr nervig sein kann.

Hinweis: Dieses Beispiel bezieht sich auf AnsiStrings, seit FPC 3.0 werden UTF-8 Strings verwendet, aber mit zu den Unterschieden werde ich ein Sp�teres Kapitel noch F�llen.

Damit w�re auch das Kapitel Dateien abgeschlossen.

Nachwort

Solltet ihr fragen zu diesem Tutorial oder zu FreePascal oder Lazarus im allgemeinen haben, k�nnt ihr mich auch gerne hier im Thread Fragen.

Wie bereits erw�hnt werde ich immer neue Kapitel diesem Thread hinzuf�gen, allerdings dauert das schreiben eines Kapitels immer seine Zeit, und deshalb verzeiht mir bitte wenn es ein wenig dauern kann bis ich mit den geplanten 12 Kapiteln durch bin.

Au�er den bereits angek�ndigten 12 Kapiteln kann es sein dass ich noch welche Hinzuf�ge, zwischenschiebe oder die Reihenfolge der Kapitel im Nachhinein nochmal �ndern werde.