| Home | Computer | Pascal Kurs | Site Map |
Eine Funktion gibt einen Wert zurück, denn man z.B. in einer Zuweisung benutzen kann. Turbo Pascal verfügt zahlreiche Funktionen. Die sie nutzen können ohne Sie zu schreiben. So übergibt folgende Funktion den Sinus des Winkels:
Wert:=sin(Winkel);
Der Funktion sin wird ein Wert übergeben der in den Klammern steht. Es gibt auch Funktionen ohne Werte:
taste=Readkey;
liest ein Zeichen von der Tastatur ein und übergibt es als Ergebnis an die Variable Taste. Prozeduren unterscheiden sich formal von Funktionen nur dadurch das Sie keinen Rückgabewert haben. Sie haben schon die Prozeduren Readln und Writeln benutzt. Da Prozeduren etwas einfacher zu verstehen sind als Funktionen, beginnen wir mit Ihnen.
Wenn man im Hauptprogramm eine Variable × definiert und in einer Prozedur auch eine Variable x, so betreffen alle Änderungen nur die lokale Variable, nicht die des Hauptprogramms. Dies gilt allgemein: Eine lokal definierte Variable "verdeckt" eine globale Variable.
Jede Prozedur kann wiederum eigene Prozeduren und Funktionen enthalten, sie müssen nur von dem Codeblock erscheinen. Auch hier gilt: Diese Funktionen/Prozeduren sind nur innerhalb dieser Prozedur bekannt und nicht außerhalb. Dies ist ein wichtiger Unterschied zu C, welches nur global sichtbare Funktionen kennt.
Allgemeine Form einer Prozedur Definition:
Procedure namen(Parameterliste);
Const Konstanten;
Var Variablen;
type Typen;
... eigene Funktionen und Prozeduren...
begin
...Code;
end;
Vorgeschrieben sind nur der Name und der Codeblock, d.h. folgendes ist die einfachste Prozedur:
Procedure tue_nichts;
begin
end;
Für Variablen, Typen und Konstanten gilt: Ab der Definition sind sie bekannt, bis die Prozedur endet. Folgen weitere (Unter) Prozeduren so kennen diese auch die Variablen. Variablen können in Prozeduren gleiche Namen wie globale Variablen haben. Sie verdecken diese dann. D.H. man kann nicht auf die globalen Variablen zugreifen. Anders als globale Variablen verlieren sie aber den Wert, sobald man die Prozedur verlässt. Man kann sich also nicht sicher sein, das der Wert erhalten bleibt. Man kann dies durch konstante Variablenparameter umgehen, die sozusagen das Gegenstück zu den static Variablen in C sind. die man aber nicht so häufig wie in C braucht, da Pascal eine bessere Rückgabemöglichkeit für Parameter hat.
Ein Beispiel:
const MaxX=100;
MaxY=200;
type Feldtyp = Array [1..MaxX,1..MaxY] of word;
function Suche_Maximum(const Feld: Feldtyp): word;
Var i: 1..MaxY;
erg: Word;
function Suche_Maxx(const y: integer): word;
var erg: word;
i: 1..maxx;
begin
erg:=0;
for i:=1 to maxx do if feld[y,i]>erg then erg:=feld[y,i];
Suche_Maxx:=erg;
end;
begin
erg:=0;
for I:=1 to maxy do
if Suche_maxx(i)>erg then erg:=Suche_maxx(i);
Suche_maximum:=erg;
end;
Procedure Kreis(Integer x,y; Double radius);
ist eine Prozedur mit 3 Parametern: Zwei Ganzzahlen für die Koordinaten und einer Flieskommazahl. Man kann diese Prozedur so aufrufen:
Kreis(10,10,r);
Danach haben innerhalb der Prozedur Kreis × und y je den Wert 10 und Radius den Wert von r. Beim Aufruf muss man natürlich nicht den Typ angeben und kein Semikolon, sondern trennt alle Parametern mit Kommas. Die Typen der Parameter müssen aber stimmen. Man kann zwar Zahlen umwandeln, aber man könnte Kreis nicht mit 3 Variablen des Typs Char aufrufen.
Wichtig: Es gibt 3 Typen von Parametern! Pascal bietet anders als Java oder C drei Schnittstellen zur Übergabe von Parametern an:Pos('"',Zeile);
oder
a:=sin(pi/4);
Dies ist möglich weil die Prozedur eine Kopie erhält, denn ein Ausdruck hat keine Adresse wie sie bei Variablenparametern übergeben werden.
VAR eins: Integer;
zwei: Single;
Procedure Daemlich(Var Veraendern: Integer; Bleibt_so: Integer);
begin
veraendern:=2;
bleibt_so:=4;
end;
begin
eins:=1;
zwei:=2;
Daemlich(eins,zwei);
end.
Da man bei Variablenparametern keine Kopie sondern die Adresse übergibt sollte man große Strukturen (Arrays etc.). nur so übergeben, auch wenn man sie nicht verändert - der Code ist schneller und spart Speicherplatz. Zum Typ ist noch zu sagen, das Turbo Pascal es hier bei den Standardtypen locker nimmt: Definiert man eine Routine wie
Function Suche(VAR Ergebnis: LongInt): Boolean;
So kann der übergebene Parameter von jedem Integertyp sein, also auch Byte, Word... Klar ist natürlich, das der Wertebereich erhalten bleibt: Eine übergebene Byte Variable bekommt Probleme wenn man in dieser Function Suche schreibt:
Suche:=1234;
Da der Wertebereich von Byte bei 255 endet (Sie würden den Wert modulo 256 enthalten also hier 210 (210 + 4*256 = 1234). Bei Strings kann man durch Compilerschalter beeinflussen, ob nur gleich lange Strings erlaubt sind oder sie einfach abgeschnitten werden. Bei eignen Typen tragen Sie aber die Verantwortung:
Type
Zeichen1 = ['A'..'Z'];
Zeichen2 = ['A'..'Z'];
Var
a: Zeichen1;
b: Zeichen2;
procedure dummy(Var x: Zeichen1);
begin
end;
begin
dummy(a);
dummy(b); {Hier gibt es einen Compilerfehler}
end.
Var a: 'A'..'Z';
b: 'A'..'Z';
function Kleinbuchstabe(buchstabe : char): boolean;
begin
if (buchstabe>='a') and (buchstabe<='z') then kleinbuchstabe:=true
else kleinbuchstabe:=false;
end;
VAR zeichen : char;
begin
zeichen:='g';
writeln(kleinbuchstabe(zeichen));
end.
Hier sieht man alle Änderungen: Anstatt Procedure erscheint nun function als Schlüsselwort. Der Rückgabetyp wird mit einem Doppelpunkt an die Parameterliste angeschlossen. Der Rückgabewert wird zugewiesen indem man dem Funktionsnamen einen Wert zuweist. Man kann also den Funktionsnamen als eine Variable des Rückgabetyps betrachten, bei Kleinbuchstaben also als eine Boolean Variable. Anders als in C kann man beliebig oft einen Wert zuweisen, jeweils der letzte wird bei Funktionsende zurückgeben. Auch wird bei Zuweisung nicht die Funktion verlassen. Nur Vorsicht: Eine Abfrage des Wertes der Funktion bewirkt ein erneutes Aufrufen der Funktion. Man nennt dies Rekursion:
Function add100 : integer;
VAR c : integer;
begin
c:=add100;
ad100:=c+100;
end;
Eine Funktion nehmen Sie immer dann, wenn sie einen und zwar genau einen Rückgabewert brauchen. Paradebeispiel sind mathematische Funktionen. Mehrere Parameter verwirklichen sie mit Prozeduren mit mehreren VAR Parametern. Wenn ihre Funktion aber auch Probleme haben kann, dann macht man es oft so, das die Funktion nur einen Boolean Rückgabewert hat, der z.B. false ist wenn es Probleme gab und das eigentliche Ergebnis steckt dann in einem VAR Parameter.
VAR Editor = Array [1..1000] of String[80];
gibt Probleme, da das Array insgesamt 80 Kilobyte belegt (1000 × 80) und so die 64 K Grenze überschreitet. Auch wenn man auf eigene Routinen ausweicht und Speicher dynamisch holt (mehr dazu in den folgenden Teilen), bleibt diese Grenze bestehen. Sie können also nie eine Datenstruktur erzeugen die größer als 64 K ist z.B. um ein Bild darin zu speichern. Hier gibt es eigentlich nur einen Ausweg: Aufsteigen auf ein 32 Bit System (FPK, VP, Delphi 2 aufwärts).
NeuerTyp = Typart;
Sie können damit z.B. Typen umdefinieren:
Type Single = Double;
würde bewirken, dass sie auch dann mit Doppelter Genauigkeit rechnen wenn Sie eine Single Variable benutzen. Sie haben Single als Double umdefiniert. Wichtiger sind aber drei neue Typen:
Type
Aufzaehlungstyp = (Bube,Dame,Koenig,Ass);
Grussbuchstabentyp = 'A'..'Z';
Grossbuchstabenmenge = Set of Grussbuchstabentyp;
VAR
Karte: Aufzaehlungstyp;
Buchstabe: Grussbuchstabentyp;
zeichen = Grossbuchstabenmenge;
Karte: (Bube,Dame,Koenig,Ass);
Das hätte aber den Nachteil, das Sie bei einer zweiten Definition
Karte2: (Bube,Dame,Koenig,Ass);
zwar eine neue Variable haben, aber diese haben nicht denselben Typ, eine Zuweisung Karte:=Karte2 ergibt einen Fehler. Leider eine der wenigen Unstimmigkeiten in Pascal. So ist es sinnvoll alle benötigte Typen zu deklarieren und diese dann für die Variablen zu verwenden. Da eine Typdeklaration nur wichtig für den Compiler ist, keinen Speicher belegt und keine Prozessorzeit benötigt spricht nichts dagegen am Kopf des Programms alle Typen die man braucht zu deklarieren und dann nur noch mit dem Typnamen zu arbeiten. Wenn sie später auch wissen was Units sind bietet es sich an solche Typen und Konstanten in eine eigene Unit auszulagern. Dann stehen sie allen benötigten Programmteilen durch Einbinden zur Verfügung.
Der erste Typ ist ein Aufzählungstyp. Er erlaubt es der Variable Karte einer der 4 Werte die angegeben sind zuzuweisen. Das hat eine enorme Verbesserung der Lesbarkeit zur Folge z.B. im Programmtext:
if karte=Ass then...
Man kann mit der Funktion Ord(variable) herausfinden welche Nummer der Wert hat. Diese werden von 0 durchgezählt und Ass hätte so die Nummer 3.
Der Teilbereichstyp 'A'..'Z' ist eine Untermenge eines anderen Typs, z.B. hier Char. Wozu das werden Sie fragen? Nun zum einen macht es den Programmtext erklärender. Zeichen: 'a'..'z' zeigt, das es sich bei dieser Variable nicht nur um eine Char Variable handelt, sondern auch nur Kleinbuchstaben als Werte zulässig sind. Zudem kann der Compiler bei der Laufzeit Überschreitungen feststellen, wenn man dies wünscht - sehr geschickt für das Debuggen. Die Zuweisung von "#" an Zeichen ist möglich, denn es ist ja eine Char Variable, aber es sprengt den angegebenen Wertebereich und wenn man wünscht, sagt einem das der Compiler. (Und das auch noch zur Laufzeit)
Mit dem Wort SET OF definieren Sie eine Menge eines anderen Typs. Bislang konnte jeder Typ nur einen Wert annehmen: Großbuchstabe z.B. nur ein 'A', aber nicht gleichzeitig den Wert 'A' und 'F'. Bei dem Mengentyp ist dies nicht so. Die Großbuchstabenmenge kann die Summe aller Werte von 'A' bis 'Z' - also 26 Stück annehmen. Die Klammern kennzeichnen dies als eine Menge (Sie kommen auch noch als Array Klammern vor).
Man wird dies einsetzen wenn ein Wert nicht nur eine Option hat, sondern mehrere. Sie kennen das von den Kästchenbuttons in Windows, hier können Sie auch mehrere Optionen mit einem Kreuz markieren.
Für Mengen gibt es eigene Rechenoperationen: + für die Vereinigungsmenge und - für die Differenzmenge. Besonders häufig - auch ohne Mengendefinition - braucht man den Operator IN:
if (Menueoption in ['0'..'9','ä','ü','ö']) then
führt den THEN Zweig genau dann aus, wenn Menueoption einen der angegebenen Werte hat und erspart einem so einen ganzen Wust von CASE oder IF THEN Abfragen, die in C nötig wären. Da '+' und '-' nun mit Mengen arbeiten muss man nun auch einzelne Werte in den eckigen Klammern setzen.:
Menueoption:=Menueoption+ ['5'];
Menueoption:=Menueoption-['ä'..'ü'];
Fügt 5 zur Menge hinzu und entfernt die Elemente 'ä','ö' und 'ü' aus der Menge. Die beiden Punkte.. geben einen Teilbereich an, also von..bis (einschließlich). Man verwendet sie auch sonst bei Arrays für die Dimensionen,
VAR
String1 : String [80];
String2 : String;
CONST
vordef_string String[70] = 'Hallo!';
String1 ist eine Zeichenkette von maximal 80 Zeichen Länge - mehr wird abgeschnitten. String2
ist eine Zeichenkette mit der maximalen Länge von 255 Zeichen. Gibt man keine Längenangabe an so
wird die maximale Länge angenommen und das sind 255 Zeichen. Mehr geht unter Turbo Pascal 1-7
nicht. 32 Bit Systeme wie Delphi 2.., VP und FPK sprengen diese Grenze und erlauben bis zu 2
Gigabyte für einen String. Da diese genauso wie kurze Strings funktionieren, gehe ich darauf nicht
ein, alles was hier über die kleinen Strings gesagt wird ist auch auf die langen übertragbar. Diese
sind auch nicht solche Speicherfresser wie die hier vorgestellten statischen Strings. (Jeder String
belegt bei Turbo Pascal soviele Bytes wie hier angegeben, egal ob nur ein Teil belegt ist. Bei den
32 Bit Systemen belegt ein String nur soviele Bytes wie er lang ist).
Wichtig ist, das ein String immer ein Byte mehr als die angegebene Länge belegt. Der String1 also 81 Byte. Egal ob der String leer ist oder 80 Zeichen enthält, er belegt immer 80 Bytes, also wenn Sie wissen das sie nie mehr als 20 Byte benötigen so definieren Sie nur einen String[20]. Bei Variablenparametern kann man dem Compiler sagen ob er nur Strings zulässt die dieselbe Länge haben oder nicht. Es macht wenig String einer Prozedur die das 40.ste Zeichen eines Strings verändern will einen String mit 20 Zeichen Länge zu übergeben.... Es ist deswegen nicht dumm im Typenteil eigene Stringtypen zu definieren:
type
Zeilentyp String [80];
Worttyp String[20];
VAR
zeile : Zeilentyp;
wort : Worttyp;
Sie können, um auf ein bestimmtes Zeichen innerhalb eines Strings zuzugreifen, diesen als ein ARRAY of CHAR mit der angegebenen Maximallänge interpretieren:
Wort[9]:='c';
{interpretiert Worttyp als Array [1..20] of Char}
Jedes Zeichen hat einen Index der von 1 ausgeht und bis zur deklarierten Maximallänge geht. Im Zeichen 0 steht die Länge. Sie sollten jedoch verzichten diese direkt zu manipulieren (ich habe das auch so gemacht und dann unter Delphi sehr merkwürdige Probleme gehabt, da dort die Strings anders organisiert sind...). Strings sind zueinander zuweiskompatibel, d.h. sie können auch schreiben: Wort:=zeile. In diesem Fall enthält Wort aber nur die ersten 20 Zeichen von Zeile, ist ja klar, mehr geht nicht rein!.
Mehr über Stringfunktionen und weitere Funktionen und Prozeduren erfahren Sie in der Online Hilfe von ihrem Pascal Compiler.(Shift-F1). Insgesamt ist das String Handling in Pascal sehr viel komfortabler als in C. Vor allem können sie nicht andere Speicherbereiche überschreiben. Es ist also problemlos möglich einem String[4] den String 'Hallo'+'Du Da!' zuzuweisen. Es steht eben dann nur "Hall" da drinn. IN C/C++ hätten sie die darauf folgende Variable auch überschrieben. Es gibt eine Ausnahme bei 32 Bit Systemen. Wenn sie die Strings als Arrays dort bearbeiten, also z.B Zeile[5]:='4'; dann verlassen Sie den sicheren Boden der Stringfunktionen und müssen gewährleisten, das in diesem Fall der String auch mindestens 5 Zeichen lang ist. Dies macht man meistens über eine Wächterabfrage mitels Length.
type farben Karo,Pik,Herz,Kreuz)
VAR
Speicher : [Array [1000..2000] of Byte;
trumpf : Array [farben] of Aufzaehlungstyp;
Sie sehen das der Index nicht bei 0 anfangen muß und auch eine Teilbereich oder Aufzählungstyp als Index dienen kann. Das macht Pascalprogramme gut verständlich. Mit dieser Definition wäre z.B. folgendes möglich:
Trumpf[Herz]:=Koenig;
if Trump(Pik]=Ass then ...
- ist doch sofort verständlich oder?
Mehrere Dimensionen erreicht man durch mehrere Teilbereiche durch Kommas getrennt:
Wuerfel: [1..5,0..4,10..20] of Double;
legt ein Array mit 5 × 5 × 11 Elementen fest. Der Zugriff auf ein Element geht so:
Wuerfel[1,0,12]:=pi;
oder: Wuerfel[1][0][12]:=pi;
Beide Schreibweisen sind möglich. Will man ein Array als vorgelegte Variable unter CONST definieren so fasst man einen Indexbereich in klammern () zusammen und trennt Elemente mit Kommas, mehrdimensionale Arrays werden von vorne nach hinten definiert:
Const Tic-Tac-Toe = Array [1..3,'A'..'C'] of Byte =((0,0,0),(1,1,1),(0,1,0));
Das Element [1,'C'] hätte so den Wert 0. Es ist hier farblich hervorgehoben. Es werden also zuerst die Elemente 1..3 der Zeile 'A' gesetzt, dann dasselbe für 'B' und 'C'. In anderen Worten: Die Dimensionen werden von rechts nach links barbeitet.
Man kann dies umgehen indem man in der Deklaration folgendes schreibt
Procedure MachWas(var par: array of xy);
Hier fehlt die Angabe der Dimension, also Anzahl der Elemente ganz. In der Funktion wird par als ein Array mit der Untergrenze 0 und einer variablen Obergrenze angesehen. Die Funktion kann über zwei Funktionen die Anzahl der Elemente und die Größe ermitteln:
for I:=0 to high(par) do par[i]:=...
Eine Anwendung ist hier gezeigt, es handelt sich um den Quicksort Algorithmus, der durch die Verwendung von Prozedurtypen und offenen Arrays so angepasst wurde, das er generell ist:
type
Element = record
name: string;
Gehalt: Double;
Abteilung: string [3];
end;
{Vergleichsfunktion}
Comparefunc = function (var A,B: Element): Boolean;
{ Liefert True wenn a<b, sonst false}
function Vergleich(var A,B: Element): Boolean; far;
function Int2Str(Zahl: Integer ): string;
var Temp: string;
begin
Str(Zahl:5,Temp);
Int2Str:=Temp;
end;
begin
Vergleich:=A.Abteilung+Int2Str(Trunc(A.Gehalt))>B.Abteilung+Int2Str(Trunc(B.Gehalt));
end;
{Klassische Quicksort Implementierung}
procedure Quicksort(Compare: Comparefunc; var Keys: array of Element);
procedure Sort(L, R: Integer);
var
I, J: Word;
X, Y: Element;
begin
I:= L; J:= R; X:= Keys[(L+R) div 2];
repeat
while Compare(Keys[I],X) do Inc(I);
while Compare(X,Keys[J]) do Dec(J);
if I <= J then
begin
Y:= Keys[I]; Keys[I]:= Keys[J]; Keys[J]:= Y;
Inc(I); Dec(J);
end;
until I > J;
if L < J then Sort(L, J);
if I < R then Sort(I, R);
end;
begin
Sort(0,High(Keys));
end;
{Hauptpogramm}
var Abteilungen: array [1..100] of Element;
I : Integer;
begin
Randomize;
for I:=1 to 100 do
with Abteilungen[I] do
begin
name:=Chr(65+Random(26))+'XYZName';
Gehalt:=Random(10000);
Abteilung:=Chr(65+Random(26))+'BC';
end;
Quicksort(Vergleich,Abteilungen);
for I:=1 to 100 do
with Abteilungen[I] do WriteLn(Abteilung,' ',Gehalt:5:0,' ',name);
end.
Der Vorteil dieser Vorgehensweise ist die:
In einer Funktion muss man, wenn man etwas konkretes mit den untypisierten Variablen machen will sie "casten". Daher mal hier ein Einschub für das in Pascal selten gebrauchte Casten unterhalb dieses Absatzes. Man tut dann im Block so als wäre die Variable vom gewünschten Typ :
function Gethighest(Var par; n : integer): byte;;
type bytearray array [0..maxint] of byte;
var temp : Byte;
i : integer;
begin
temp:=0;
for i:=0 to n-1 do
if bytearay(par)[i]>temp then temp:=bytearay(par)[i];
gethighest:=temp;
end;
a:=GetHighest(3.14159);
Was da rauskommt hat keinerlei Sinn, denn Flieskommazahlen bestehen nicht aus einem Array von Byte Werten.
Variable:=Casttyp(Variable);
z.B:
var i : integer;
begin
i:=Integer('A'); {A ist ein char Wert!}
end.
var boolvar : Boolean;
temp : Byte;
begin
Writeln(datei,Byte(Boolvar));
readln(datei,temp);
boolvar:=boolean(Temp);
end;
Die trigonometrischen Funktionen sin(, cos( und arctan( arbeiten nur mit Bogenmaß (Periode 2 Pi), will man dagegen im Winkelmaß arbeiten so muß man umrechnen - das erledigt eine eigene Funktion besser als das 10 mal im Quelltext zu tun.
function sinus(winkel : extended): extended;
const umrechungsfaktor 360 / (2*Pi);
begin
sinus:=sin(winkel/Umrechnungsfaktor);
end;
Oft benötigt man auch eine Funktion die bei einer Eingabe Leezeichen entfernt, die vor der eigentlichen Eingabe stehen:
function Trim(eingabe : string): String;
begin
while (length(eingabe)>0) and (eingabe[1]=' ') do
delete(eingabe,1,1);
trim:=eingabe;
end;
Was sie jetzt auch schon machen können ist mit dem Computer zahlreiche Denksportaufgaben
lösen. Hier mal eine Aufgabe aus der ARD Sendung "Kopfball" vom 23.12.2001: "Eine
Bahnhofsuhr mit 7 Segment Anzeige (Wie bei Taschenrechnern) zeigt die Zeit an. Dabei hat sie
je zwei Ziffern für Stunden, Minuten und Sekunden, die erste Stundenziffer leuchtet aber erst
ab 10 Uhr (die
führende Null wird nicht dargestellt). Bei welcher Uhrzeit leuchten die meisten Segmente?
Klar man kann nachdenken oder den computer einfach mal von 0:00:00 bis 23:59:59 alle Uhrzeiten durchprobieren lassen. Das wäre doch eine nette kleine Aufgabe. Herauskommen sollte dann so was. Falls sie eine andere Lösung finden: Die korrekte Uhrzeit ist 20:08:08.
Dieser Text stammt von Bernd Leitenberger| Kontakt | Neues | Bücher vom Autor | Buchempfehlungen | Gästebuch |
|
|