Hallo und guten Morgen, heute ist der 24.11.2009

Druckansicht
Dein aktueller Pfad auf Reneswebsite: Material / Programmieren / Delphi /

Delphi -- Ein Entwicklungswerkzeug für Anfänger

Delphi baut auf der Programmiersprache Pascal auf und stellt eine einfache und gut erlernbare objektorientierte Programmierumgebung dar. Delphi läuft nur auf Windows Systemen. Die Firma Borland stellte den Vertrieb und Support ein. Eine aktuelle Delphi-Version erhält man über www.codegear.com/education

Diese Materialseite stellt ein Sammelsurium meiner Programmiererfahrungen dar.

Inhaltsübersicht

Programmstrukturen
Dialoge für die Arbeit mit Dateien
Timeraktionen

Meldungen, Dialogboxen

Programmstrukturen

Case Of Anweisung

procedure auswertung;
var ergebnisprozent,wert1, wert2, wert3: integer;
begin
wert1:=StrToInt(LabelAnzahl.Caption);
wert2:=StrToInt(LabelRichtig.Caption);
wert3:=StrToInt(LabelFalsch.Caption);
LabelText.Caption:='Du hast '+IntToStr(wert1)+' Aufgaben ausgewählt.'
+#13+'Davon hast du '+IntToStr(wert2)+' Aufgabe(n) richtig'
+#13+'und '+IntToStr(wert3)+' Aufgabe(n) falsch gelöst.';
ergebnisprozent:=round(100*wert2/wert1);

Case ergebnisprozent of
96..100:LabelUrteil.Caption:='Ausgezeichnet';
80..95:LabelUrteil.Caption:='Gut';
60..79:LabelUrteil.Caption:='Befriedigend';
40..59:LabelUrteil.Caption:='Ausreichend';
25..39:LabelUrteil.Caption:='Mangelhaft';
else
LabelUrteil.Caption:='Unbefriedigend';
end;
end;

Diese Prozedur führt eine Fallunterscheidung durch und gibt ein Urteil
entsprechend der Bewertung mit einer Schulnote aus.

Zählschleife mit variabler Schrittweite

procedure zaehlen;
var i,anfang,ende,schrittweite,wert:double;
begin
anfang:=...;ende:=...;
i:=anfang;
repeat until i>ende begin
wert:=...;
inc(i,schrittweite);
end;
end;

Die Routine INC erhöht die Variable i um einen bestimmten Wert (hier schrittweite).

Dialoge für die Arbeit mit Dateien

Öffnen einer Datei

procedure TForm.OeffnenClick(Sender: TObject);
var tabelle: TStringList;
zeilen,i: integer;
begin
tabelle:=TStringList.Create;
try
with OpenDialog do
begin
OpenDialog.InitialDir:='C:\';
OpenDialog.Filter:='Textdatei (*.txt)|*.txt';
OpenDialog.Title:='Oeffnen...';
OpenDialog.DefaultExt:='.TXT';
end;
if not OpenDialog.Execute then
exit;
tabelle.LoadFromFile(OpenDialog.FileName);
zeilen:=StringGridTabelle.RowCount;
StringGridTabelle.RowCount:=StrToInt(tabelle[0]);
StringGridTabelle.ColCount:=StrToInt(tabelle[1]);
for i:=0 to (zeilen-1) do
StringGridTabelle.Rows[i].CommaText := tabelle[i+2];
finally
tabelle.Free;
i:=0;
end;
end;

Öffnet eine Textdatei und gibt sie in einem StringGrid aus. Dabei müssen die Zellinhalte kommasepariert sein. Als erstes Element steht die Zeilenanzahl und an zweiter Stelle steht die Spaltenanzahl. Danach folgt der Inhalt der Tabelle.

Speichern einer Datei

procedure TForm.SpeichernUnterClick(Sender: TObject);
var tabelle: TStringList;
zeilen,i: integer;
begin
tabelle:=TStringList.Create;
try
with SaveDialog do
begin
SaveDialog.InitialDir:='C:\';
SaveDialog.Filter:='Textdatei (*.txt)|*.txt';
SaveDialog.Title:='Speichern unter...';
SaveDialog.DefaultExt:='.TXT';
SaveDialog.Options:=[ofOverwritePrompt];
end;
if not SaveDialog.Execute then
exit;
zeilen:=StringGridTabelle.RowCount;
tabelle.Add(IntToStr(StringGridTabelle.RowCount));
tabelle.Add(IntToStr(StringGridTabelle.ColCount));
for i:=0 to (zeilen-1) do
begin
tabelle.Add(StringGridTabelle.Rows[i].CommaText);
tabelle.SaveToFile(SaveDialog.FileName);
end;
finally
tabelle.Free;
i:=0; zeilen:=0;
end;
end;

Speichert den Inhalt eines StringGrids in eine Textdatei. Dabei werden die Zellinhalte kommasepariert gesichert. Als erstes Element steht die Zeilenanzahl und an zweiter Stelle steht die Spaltenanzahl. Danach folgt der Inhalt der Tabelle.

Timeraktionen

Start-Stopp Button

procedure TForm.ButtonStartStoppClick(Sender: TObject);
begin
if ButtonStartStopp.Caption='Start' then
begin
ButtonStartStopp.Caption:='Stopp';
Timer1.Enabled:=True;
end
else
begin
ButtonStartStopp.Caption:='Start';
Timer1.Enabled:=False;
end;
end;

Diese Prozedur ändert die Beschriftung eines Buttons und löst ein Timer-Ereignis aus bzw. stoppt es wieder.

Meldungen, Dialogboxen

ShowMessage

procedure meldung1;
ShowMessage('Hier steht ein beliebiger Text, der in einem kleinen';
+#13+ 'Meldungsfenster angezeigt wird');
end;

Diese Prozedur erzeugt ein Meldungsfenster exakt in der Mitte des Bildschirmes.
In der Titelleiste wird der Projektname angezeigt. Die Zeilenlänge passt sich dem Text an.
Soll ein Zeilenumbruch erfolgen, damit das Ausgabefenster nicht zu breit wird,
dann muss das Zeichen #13 (=CR) eingefügt werden.

MessageBox

procedure meldung2;
var button:integer;
button:=Application.MessageBox('Klicke auf OK!','Meldungsfenster',49);
end;

Diese Prozedur erzeugt ein Meldungsfenster mit 2 Schaltflächen:
OK und Abbrechen. Der Wert 49 beinhaltet den Wert des Warnicons(hier 48)
und die Schaltflächen OK und Abbrechen (hier 1). MessageBox stellt eine Methode von
TApplication dar.

InputBox

procedure eingabe;
Label.Caption:=InputBox('InputBox','Ihre Antwort:','Vorgabewert');
end;

Diese Prozedur erzeugt eine einfache Eingabemöglichkeit mit den üblichen 2 Schaltflächen:
OK und Abbrechen. Nach dem Klick auf OK wird dem Label der Inhalt
der Eingabezeile zugewiesen.
Der Rückgabewert der InputBox ist stets ein String.

Fehlerbehandlung

Try-Except Konstruktion

procedure Dateioeffnen(filename:string);
var f: file;
begin
Try
AssignFile(f,filename);
Reset (f); // Hier kann ein Fehler auftreten!
Except
MessageBox(0,'Fehler beim Oeffnen','Achtung Hinweis!',16);
end;
end;

Wenn im oberen Bereich zwischen Try und Except ein Fehler entsteht,
dann werden alle Anweisungen zwischen Except und end ausgeführt.
Andernfalls wird der Except-Block niemals durchlaufen!

Try-Except Konstruktion und Fehlerausgabe

procedure Dateioeffnen(filename:string);
var f: file;
begin
Try
AssignFile(f,filename);
Reset (f); // Hier kann ein Fehler auftreten!
Except
on EInOutError do MessageBox(0,'Fehler beim Oeffnen','Achtung Hinweis!',16);
end;
end;

Wenn im oberen Bereich zwischen Try und Except ein Fehler entsteht,
dann werden alle Anweisungen zwischen Except und end ausgeführt.
Durch die Anweisung EInOutError do können einzelne Fehlerklassen unterschieden werden.

Try-Finally-Konstruktion

procedure Dateioeffnen(filename:string);
var bild:TImage;
begin
Try
bild.width:=width div divisor;
...
Finally
bild.free;
end;
end;

Wenn im oberen Bereich zwischen Try und Except ein Fehler entsteht,
dann wird das Programm nach Finally fortgesetzt.
Diese Fehlerkonstruktion verwendet man, wenn Speicherplatz
wieder freigegeben werden soll.

Basisalgorithmen

Euklidischer Algorithmus

procedure euklid;
var a,b,r: integer;
begin
a:=StrToInt(EditA.Text);
b:=StrToInt(EditB.Text);
repeat
r:=a mod b;
a:=b;
b:=r;
until r=0;
EditggT.Text:=IntToStr(a);
end;

Dieser Algorithmus dient zur Bestimmung und Ausgabe des größten gemeinsamen
Teilers (ggT(a,b)) zweier ganzer Zahlen a und b.
Der Wert für a aus dem letzten Schritt ist der ggT.

Minimum und Maximum

procedure Min_Max(d: TFeld; n:smallint; var min,max: smallint);
// Minimum-Maximum-Suche
var i: smallint;
begin
min:=d[1]; max:=d[1];
for i:=1 to n do
begin
if d[i] < min then min:=d[i] else
if d[i] > max then max:=d[i]
end;
end;

Mit dem Algorithmus ermittelt man das Maximum/Minimum
eines Zahlenfeldes (Array).
Aufruf der Prozedur z.B. so: Min_Max(Name des Feldes,n,min,max);

Rekursion

//Fakultät von n
function fak(n:Integer):Integer;
begin
if n = 1 then result := 1 else result := n * fak(n-1);
end;

Die Prozedur fak(n) ruft sich selbst so lange auf bis eine Abbruchbedingung erreicht wird. Der Parameter n wird hier bei jedem rekursiven Aufruf um 1 vermindert.

Datentypen

Statische Datentypen

Delphi verlangt eine starre Typdeklaration zur Abstraktion des Speicherbedarfs der im Programm verwendeten Variablen. Seit Delphi 2.0 gibt es als Ausweg hierzu den Varianten-Datentyp. Allerdings benötigt dieser Datentyp immer 16 Byte je Variable und verlangsamt ein Programm.

Dynamische Datentypen

//variabler Speicherbedarf der Variablen
Type TZeiger = ^TElement;
TElement= record
inhalt:string;
next:TZeiger;
end;

var hilf,anker: TZeiger;//als globale Variable vereinbaren;

procedure anlegen();
begin
new(hilf);
anker:=hilf;
hilf^.next:=nil;
hilf.inhalt:='erstes Listenelement';
end;

Diese Prozedur erzeugt eine einfach verkettete Liste mit einem Listenelement.
Hierbei erhält die Zeigervariable hilf die Adresse des ersten Listenelements.
Das Ende der einfach verketteten Liste hilf^.next wird auf den Wert 'nil' gelegt.

Sortierverfahren

Vertauschen

Procedure tausch(a,b:Integer);
VAR hilfe:feldtype;
BEGIN
hilfe:=zahlenfeld[a];
zahlenfeld[a]:=zahlenfeld[b];
zahlenfeld[b]:=hilfe;
END;

Grundprozedur zum Vertauschen von zwei Elementen einer Liste oder eines Feldes. Im Deklarationsteil müssen für alle Sortierverfahren diese Typen deklariert werden: type feldtype = integer; tzahlenfeld = array[1..max] of feldtype;

Quicksort

Procedure Quicksort(var feld:tzahlenfeld; links,rechts:Integer);
var l,r,pivo: Integer;
begin
l:=links; r:=rechts;
pivo:=zahlenfeld[(l+r)div 2];

repeat

while zahlenfeld[l] if l<=r then begin tausch(l,r);
l:=l+1; r:=r-1;
end;
until l>r;

if links <r then Quicksort(zahlenfeld,links,r);
if l <rechts then Quicksort(zahlenfeld,l,rechts);
End;

Das Sortierverfahren Quicksort zerlegt eine Liste (hier zahlenfeld) in zwei Teillisten und wendet anschließend den Algorithmus wieder auf die Teillisten an. Ein rekursives Sortierverfahren, das in vielen Fällen sehr schnell und somit effizent arbeitet.

Bubble Sort

Procedure Bubblesort(var feld:tzahlenfeld);
VAR i,j,k:Integer;
BEGIN
FOR i:=max-1 DOWNTO 1 DO
FOR j:=1 TO i DO BEGIN
IF feld[j] > feld[j+1] THEN BEGIN
k:=j+1;
tausch(j,k);
END;
END;
END;

Bei diesem Verfahren werden nacheinander immer zwei benachbarte Elemente verglichen. Das größte Listenelement steht nach einem Durchlauf rechts. Anschließend wird der Algorithmus solange wiederholt bis alle Elemente geordnet sind.

MinSort

PROCEDURE Sortieren_durch_Minimumssuche(var feld:tzahlenfeld);
VAR i,j:Integer;
BEGIN
FOR i:=1 TO max-1 DO
FOR j:=i+1 TO max DO BEGIN
IF feld[j] < feld[i] THEN BEGIN
tausch(i,j);
END;
END;
END;

Sortierverfahren durch Minimumsuche

Optimiert für höhere Bildschirmauflösungen und moderne Browser. Bestens geeignet sind Safari, Firefox und Chrome.