Michael Neuhold Homepage
Startseite > Informatikunterricht > Weiterführung in Turbo Pascal

Weiterführung in Turbo Pascal

Prozeduren und Funktionen

Prozeduren

Prozeduren ruft man mit ihrem Namen auf:

ClrScr;
Writeln ('Hallo du da!');
Gotoxy (5,10);

Eigene Prozeduren deklariert man so:

PROCEDURE Name (Parameter: Typ);
{Deklarationsteil: CONST, TYPE, VAR}
BEGIN
  {Programmteil der Prozedur}
END;

Ohne Parameter:

PROCEDURE Ausgabe;
BEGIN
  WriteLn ('Ergebnis: ',wert); {wert muß eine globale Variable sein}
END;

Mit Werteparameter:

PROCEDURE Ausgabe2 (wert: Real; KommaStellen: Byte);
BEGIN
  DelLine;
  Write (wert:0:KommaStellen); {wert und KommaStellen sind jetzt die formalen Parameter}
                               {aus der Kopfzeile}
END;

Mit Variablenparameter:

PROCEDURE Eingabe (grenze: Integer; VAR wert: Integer);
BEGIN
  WriteLn ('Ganze Zahl (max ',grenze,'): ');
  REPEAT
    GotoXY (10, WhereY-1); ClrEol;
    ReadLn (wert);
  UNTIL wert <= grenze;
END;

Das Hauptprogramm dazu könnte etwa so aussehen:

PROGRAM QuadratBerechnung;
USES  crt;
VAR   zahl: Integer;

PROCEDURE Eingabe (grenze: Integer; VAR wert: Integer);
{s.o.}
PROCEDURE Ausgabe2 (wert: Real; KommaStellen: Byte);
{s.o.}

BEGIN  {Hauptprogramm}
  ClrScr; WriteLn ('Berechnung der Quadratzahl');
  Eingabe (1000,zahl);     {Aufruf der Prozedur Eingabe}
  Ausgabe2 (Sqr (zahl),0); {Aufruf der Prozedur Ausgabe2}
END.   {Hauptprogramm}

Funktionen

Funktionen liefern einen Wert. Funktionen verwendet man wie Variablen: (1) auf der rechten Seite einer Zuweisung, (2) als Parameter von Prozeduren und Funktionen, (3) in booleschen Ausdrücken.

Zuweisung Parameter Ausdruck
zeile:= WhereY;
wurzel:= SqRt (z);
taste:= ReadKey;		 WriteLn (SqRt (zahl));
WriteLn (Ord ('A'));
GotoXY (WhereX,10);		 IF Sqr (zahl) < 100 THEN BEGIN
WHILE Trunc (zahl1)*zahl2 > 100 DO;
REPEAT UNTIL KeyPressed;

Der Aufruf SqRt (100); ergibt so wenig Sinn wie 10;.

Eigene Funktionen deklariert man so:

FUNCTION Name (Parameter:Typ): ErgebnisTyp;
{Deklarationsteil: CONST, TYPE, VAR}
BEGIN
  {Programmteil der Funktion}
  Name:= Zuordnungsvorschrift;
END;

Ohne Parameter:

FUNCTION Fertig: Boolean;
VAR taste: Char;
BEGIN
  GotoXY (5,25);
  Write ('Wiederholen [Return]    Beenden [Escape]');
  REPEAT taste:= ReadKey UNTIL taste IN [#13,#27];
  IF taste=#27
    THEN Fertig:= TRUE
    ELSE Fertig:= FALSE;
END;

Mit Werteparameter:

FUNCTION Fahrenheit (celsius: Real): Real;
BEGIN
  Fahrenheit:= celsius *9/5+32;
END;

Das Hauptprogramm dazu könnte etwa so aussehen:

PROGRAM TemperaturUmrechnung;
USES  crt;
VAR   c: Real;

FUNCTION Fertig: Boolean;
{s.o.}

FUNCTION Fahrenheit (celsius: Real): Real;
{s.o.}

BEGIN  {Hauptprogramm}
  REPEAT
    ClrScr;
    Write ('Wieviel °C? '); ReadLn (c);
    WriteLn ('Das sind ',Fahrenheit (c),' F');  {Aufruf der Funktion Fahrenheit}
  UNTIL Fertig;                                 {Aufruf der Funktion Fertig}
END.   {Hauptprogramm}

Was macht die folgende Funktion?

FUNCTION ziffer (z: Char): Integer;
BEGIN
  ziffer:= Ord (z)-48;
END;

Definition von Datentypen

Benutzerdefinierte und strukturierte Datentypen werden durch TYPE = (Definitionszuweisung mit Gleichheitszeichen!) definiert. Dann muß mit VAR eine Variablendeklaration erfolgen:

TYPE NeuerTyp = Typendefinition;
VAR  Variable: NeuerTyp;

Man kann Datentypen auch bei der Variablendeklaration definieren (VAR Variable: NeuerTyp;), doch können solche Variablen nicht als Prozedur- und Funktionsparameter verwendet werden, da im Prozedurkopf als Parameter nur einfache und vordefinierte Variablentypen auftreten dürfen.

Benutzerdefinierte Datentypen

Teilbereichstyp

TYPE Teilbereichstyp = Bereichsanfang..Bereichsende;

Beispiel: TYPE Lottozahlen = 1..45;

Aufzählungstyp

TYPE Aufzählungstyp = (Wert1, Wert2, Wert3);

Beispiel: TYPE Wochentage = (so, mo, di, mi, do, fr, sa);

Array (indizierte Variable)

Typendefinition

Ein Array ist ein Feld gleichartiger Daten, bei dem das einzelne Datum durch seine Indexnummer angesprochen wird. Typendefinition:

TYPE ArrayTyp = ARRAY [FirstIndex..LastIndex] OF Datentyp;

Zugriff und Verarbeitung

Strings

Mehrdimensionale Arrays

Record (Verbund, Datensatz)

Ein Datensatz, dessen Datenkomponenten unterschiedlichen Datentyps sein können:

TYPE DatenSatz = RECORD
                   Komponentenname1: Datentyp;
                   Komponentenname2: Datentyp;
                   Komponentenname3: Datentyp;
                 END;

File (Datei)

Datentyp zum Übertragen von Daten von einem Gerät zum anderen (in erster Linie von und zu Disk).

Allen Filetypen gemeinsam ist, daß zuerst ihr "physikalischer" Name einer Dateivariablen zugeordnet werden muß: ASSIGN (Dateivariable, 'Dateiname'): ASSIGN (datenbank, 'C:\PASPROGS\DATABASE.DAT'). Dateiname ist ein String, der den Namen der Datei, (optional) den Pfad und (optional) das Laufwerk enthält. Fehlen die Angabe des Laufwerks und des Pfads, werden das aktuelle Laufwerk und das aktuelle Verzeichnis verwendet.

Typisierte Dateien

Files eines bestimmten Datentyps; auf die einzelnen Datenkomponenten kann wahlfrei zugegriffen werden (sog. Random Access Files). Typendefinition:

TYPE Dateityp = FILE OF Datensatztyp;

Textdateien

Werden zeilenweise gelesen und geschrieben. Da die Zeilen unterschiedlich lang sein können, ist nur sequentieller Zugriff möglich (Zeilenendekennung ist die Sequenz #13#10 [Carriage Return + Line Feed]). Der Dateityp Text ist bereits vordefiniert.

VAR  f: Text;
     s: String;
BEGIN
  WriteLn ('Name der Textdatei: '); ReadLn (s);
  Assign (f,s); Reset (f);
  WHILE NOT Eof (f) DO
  BEGIN
    ReadLn (f,s);    {Zeile von Datei einlesen}
    WriteLn (s);     {und auf Bildschirm ausgeben}
  END;
END.

Untypisierte Dateien

Dienen zum Übertragen von Daten ungeachtet ihres Inhaltes. Das Übertragen kann nur blockweise stattfinden. Typendefinition:

TYPE UntypisierteDatei = FILE;
PROGRAM CopyFile;
{Simple, fast file copy program with NO error-checking - aus der Online-Hilfe}
{Aufruf: CopyFile Quelldatei Zieldatei, die Kommandozeilenparameter werden mit der Funktion}
{ParamStr (n-terParameter) übernommen}
VAR  FromF, ToF: FILE;              {untypisierte Dateien}
     NumRead, NumWritten: Word;
     Buf: ARRAY [1..2048] of Char;  {Puffervariable}
BEGIN
  Assign(FromF, ParamStr(1));       {erster Parameter = Quelldatei, öffnen}
  Reset(FromF, 1);                  {Blockgröße = 1}
  Assign(ToF, ParamStr(2));         {zweiter Parameter = Zieldatei, öffnen}
  Rewrite(ToF, 1);                  {Blockgröße = 1 }
  WriteLn('Copying ', FileSize(FromF), ' bytes...');
  REPEAT
    BlockRead(FromF, Buf, SizeOf(Buf), NumRead);  {Lesen}
    BlockWrite(ToF, Buf, NumRead, NumWritten);    {Schreiben}
  UNTIL (NumRead = 0)                             {bis alle Blöcke gelesen}
    OR (NumWritten <> NumRead);             {oder Übertragungsfehler}
  Close(FromF); Close(ToF);                       {Schließen nicht vergessen!}
END.

Fehlerbehandlung

Wenn versucht wird, nicht vorhandene Dateien zu öffnen, Dateien in nicht vorhandenen Verzeichnissen anzulegen, über das Dateiende hinaus auf Datensätze zuzugreifen, vom Diskettenlaufwerk zu lesen, obwohl keine Diskette eingelegt ist, o.ä., kommt es zu einem Laufzeitfehler = Programmabbruch (und meist auch Datenverlust).

Diskhandling

Die Unit DOS stellt einige Prozeduren und Funktionen zum Umgang mit externen Dateien bereit.

Weitere Details dazu sehe man in der Online-Hilfe nach:

Autor: Michael Neuhold (E-Mail-Kontakt)
Letzte Aktualisierung: 10. Juni 2024