Funktionen, Prozeduren und primitive Basistypen

Posted on 2026年7月13日 by

Ändere die dpr-Datei der vorherigen Lektion auf folgenden Inhalt

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;
function MyFunction(const S: string): string;
begin
  Result := S + 'strings are automatically managed';
end;
var
  X: Single;
begin
  WriteLn(MyFunction('Note: '));
  MyProcedure(5);
  // Division mit "/" ergibt immer Gleitkommazahl, für Ganzzahldivision nutze "div"
  X := 15 / 5;
  WriteLn('X is now: ', X); // wissenschaftliche Notation
  WriteLn('X is now: ', X:1:2); // 2 Nachkommastellen
end.Code-Sprache: PHP (php)
D:\fpcdemo>fpc mydemo.dpr
Free Pascal Compiler version 3.2.2 [2021/05/15] for i386
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Win32 for i386
Compiling mydemo.dpr
Linking mydemo.exe
20 Zeilen kompiliert, 0,0 Sek, 39248 Bytes Code, 2484 Bytes Daten

D:\fpcdemo>mydemo
Note: strings are automatically managed
A + 10 is: 15
X is now:  3.000000000E+00
X is now: 3.00

D:\fpcdemo>Code-Sprache: CSS (css)

Unten die Zeilenweise Kommentarerklärung. Nicht-englische Zeichen können Zeichenmüll erzeugen; konfiguriere die Konsole für korrekte chinesische Ausgabe.

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram; 
// Eigener Name des Programms. Pascal-Konsolenprogramme beginnen immer mit program Name; danach folgen Variablendeklarationen, Prozeduren und Hauptcode

// Kein Rückgabewert: procedure Prozedur. Prozeduren und Funktionen laufen nur bei Aufruf
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 =：', A + 10);
end;

// Mit Rückgabewert: function Funktion
function MyFunction(const S: string): string;
begin
  Result := S + 'Der Speicher von Strings wird automatisch vom System verwaltet';
end;

// Object Pascal hat keine main-Funktion, der äußerste begin...end.-Block ist Programmeinstiegspunkt. Unten der Hauptblock
var
  X: Single; // Einfachgenaue Gleitkomma-Basistyp
begin 
  // Alle auszuführende Logik steht hier
  WriteLn(MyFunction('Hinweis：'));
  MyProcedure(5);

  // "/" ergibt immer Gleitkommaergebnis, Ganzzahldivision mit div
  X := 15 / 5;
  WriteLn('X is now：', X); // Automatisch wissenschaftliche Schreibweise
  WriteLn('X is now：', X:1:2); // Auf 2 Nachkommastellen begrenzen
end. // end. mit Punkt kennzeichnet das Ende des gesamten ProgrammsCode-Sprache: PHP (php)

Jede Funktion und Prozedur hat ein Paar begin und end zur Markierung des Funktionskörpers, entspricht { } bei C, C++, Java u.ä.

WriteLn gibt Text in die Konsole aus, einfache Hochkommata ‚ ‚ umschließen Stringliterale. WriteLn('A + 10 =：', A + 10); gibt nacheinander den String A + 10 =： und das Ergebnis von A + 10 aus.

Ein Programm darf nur einen äußersten begin und end. Block besitzen, darin steht der Hauptcode, der weitere Funktionen und Prozeduren aufruft.

X := 15 / 5;
WriteLn(‚X is now: ‚, X); // wissenschaftliche Notation
WriteLn(‚X is now: ‚, X:1:2); // 2 Nachkommastellen

/ steht für Gleitkommadivision, Ergebnis ist immer eine Gleitkommazahl.

Die ersten zwei Zeilen sind Präprozessoranweisungen

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}Code-Sprache: PHP (php)

Dies ist eine FPC-spezifische bedingte Kompilieranweisung

  • {$ifdef FPC}: Die mittleren Einstellungen werden nur ausgeführt, wenn der Compiler Free Pascal ist
  • {$mode objfpc}: Wechsel in den ObjFpc-Syntaxmodus
  • {$H+}: Aktiviert Langstrings (moderne automatisch verwaltete String-Typen, zwingend erforderlich)
  • {$J-}: Deaktiviert veränderbare Konstanten (Konstanten können nicht zur Laufzeit geändert werden, sicherer)
  • {$endif}: Ende des bedingten Blocks

Zweck: Moderne Syntax nur aktivieren bei Kompilierung mit FPC; der Delphi-Compiler überspringt diesen gesamten Block.

{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}Code-Sprache: PHP (php)

Plattformübergreifende bedingte Kompilierung

  • MSWINDOWS: Gilt nur unter Windows-Betriebssystem
  • {$apptype CONSOLE}: Legt das Programm als Konsolenanwendung fest (schwarzes Terminalfenster statt GUI-Fenster). Unter Linux/macOS wird diese Zeile ignoriert.

Kernwissen

  • string nativer Basistyp; FPC/Delphi verwaltet den Speicher automatisch, manuelles Freigeben entfällt
  • procedure Prozedur: kein Rückgabewert; function Funktion: mit Rückgabewert, gespeichert in eingebauter Variable Result
  • Unterschied Division: / Gleitkommadivision; div Ganzzahldivision (abschneiden)
  • Formatierte Ausgabe Variable:Gesamtbreite:Nachkommastellen zur Steuerung der Gleitkommadarstellung
  • Parameterlose rekursive Funktionen benötigen leere Klammern () zur Vermeidung von Mehrdeutigkeit
  • Exit(Wert) gibt direkt einen Rückgabewert an und beendet die Funktion vorzeitig
  • Funktionen können ohne Auswertung des Rückgabewerts aufgerufen werden, geeignet für Nebeneffekte wie Änderung globaler Variablen

Regeln für Funktionsrückgabewerte

  1. Die eingebaute Sondervariable Result speichert den Rückgabewert der Funktion, les- und schreibbar wie lokale Variablen
function MyFunction(const S: string): string;
begin
  Result := S + 'One';
  Result := Result + 'Two';
end;
Code-Sprache: PHP (php)
  1. Alte Schreibweise: Direkte Zuweisung an den Funktionsnamen (MyFunction := xxx), unleserlich und nicht empfohlen, nutze einheitlich Result.

C/C++/Java/C# nutzen = für Zuweisung und == für Gleichvergleich. Pascal arbeitet umgekehrt: := zur Variablenzuweisung, einfaches = zum Vergleich, passend zur mathematischen Notation.

Pascal kennt keinen Operator ==

Ersetze die alte MyFunction im Beispiel durch obige Version. Diese Funktion hängt zuerst „One“, dann „Two“ an den übergebenen String an.

Der zurückgegebene String lautet: Originalstring + One + Two

Rekursive Aufrufe

Parameterlose Funktionen benötigen bei Rekursion leere Klammern (), um „Funktion aufrufen“ von „aktuellen Rückgabewert lesen“ abzugrenzen:

function SumIntegersUntilZero: Integer;
var I: Integer;
begin
  ReadLn(I);
  Result := I;
  if I <> 0 then
    Result := Result + SumIntegersUntilZero(); // rekursiver Aufruf mit ()
end;
Code-Sprache: JavaScript (javascript)

Erläuterung zur parameterlosen Funktion SumIntegersUntilZero:

  1. SumIntegersUntilZero() → Funktion ausführen, rekursieren und Rückgabewert holen
  2. SumIntegersUntilZero → Zugriff auf interne Variable Result (eigener Rückgabewert der Funktion)

Code ohne Klammern:

Result := Result + SumIntegersUntilZero;

Der Compiler interpretiert es als:

Result := Result + Result;

Entspricht Result := Result * 2, die Rekursionslogik bricht vollständig ab, Endlosschleife und ständig verdoppelte Werte.

In diesem Beispiel ruft sich die Funktion solange selbst auf, bis die Eingabe 0 lautet; solange der Wert ungleich Null ist, läuft die Rekursion weiter.

Exit – vorzeitiges Verlassen

  1. Exit ohne Parameter: Sofortige Beendigung der Funktion, Rückgabe des bereits zugewiesenen Result-Werts
  2. Exit(Wert): Direkte Angabe des Rückgabewerts und Funktionsende, entspricht return x aus C
function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); // Direkt NewName zurückgeben und abbrechen
  Result := ExistingNames + ', ' + NewName;
end;
Code-Sprache: PHP (php)
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;

function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); 
  Result := ExistingNames + ', ' + NewName;
end;

var
  X: Single;
begin
  WriteLn(AddName('Tom','Jack'));
  WriteLn(AddName('Tom',''));
  WriteLn(AddName('','Jack'));
end.Code-Sprache: PHP (php)

Funktionen wie Prozeduren aufrufen (Rückgabewert ignorieren)

Funktionen mit Rückgabewert können nur zur Ausführung ihrer Logik aufgerufen werden, ohne das Ergebnis zu speichern; geeignet für Nebeneffekte wie Änderung globaler Variablen:

var
  Count, MyCount: Integer;
function CountMe: Integer;
begin
  Inc(Count); // Nebeneffekt: Globale Variable um 1 erhöhen
  Result := Count;
end;
begin
  Count := 10;
  CountMe;   // Rückgabewert verwerfen, nur Logik läuft, Count wird 11
  MyCount := CountMe; // Rückgabewert speichern, Count wird 12
end.
Code-Sprache: PHP (php)

Vollständiges lauffähiges Beispiel

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;

var
  Count, MyCount: Integer;

function CountMe: Integer;
begin
  Inc(Count); 
  Result := Count;
end;

begin
  Count := 10;
  WriteLn(CountMe);   
  MyCount := CountMe;
  WriteLn(MyCount);
end.Code-Sprache: PHP (php)

Inc ist eingebaute Standardfunktion von Pascal (FPC/Delphi), erhöht eine Variable um 1.

var ist das Variablendeklarationsschlüsselwort von Pascal, dient zur Definition von Variablen.

var
  Count, MyCount: Integer;Code-Sprache: JavaScript (javascript)

var: Beginnt den Variablendeklarationsbereich

Count, MyCount: Zwei Variablennamen

Integer: Ganzzahltyp

Die im var-Block dieses Beispiels deklarierten Variablen sind global, in allen Prozeduren und Funktionen des gesamten Programms nutzbar.

Funktionen, Prozeduren und primitive Basistypen

POSTED IN Free Pascal Tutorial

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert