Anzeigen: Object Pascal C++
Anzeigeeinstellungen

Sprach-Übersicht

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Object Pascal-Sprachreferenz - Index

Object Pascal ist eine höhere Compiler-Sprache mit strenger Typisierung, die eine strukturierte und objektorientierte Programmierung ermöglicht. Zu ihren Vorzügen gehören einfache Lesbarkeit, schnelle Compilierung und modulare Programmierung durch Verteilen des Quelltextes auf mehrere Unit-Dateien. Object Pascal verfügt über spezielle Leistungsmerkmale, die das Komponenten-Framework und die Entwicklungsumgebung von Appmethod unterstützen. In den Beschreibungen und Beispielen dieser Sprachreferenz wird davon ausgegangen, dass Sie die Embarcadero-Entwicklungstools verwenden.

Die meisten Entwickler, die mit Software-Entwicklungstools von Embarcadero arbeiten, schreiben und compilieren ihre Programme in der integrierten Entwicklungsumgebung (IDE). Die Embarcadero-Entwicklungstools regeln viele Details, die beim Einrichten von Projekten und Quelltextdateien von Bedeutung sind (z. B. Verwalten der Abhängigkeiten zwischen den Units). Dabei gelten Regeln bezüglich der Programmorganisation, die aber nicht zur Sprachdefinition von Object Pascal gehören. So werden beispielsweise bestimmte Namenskonventionen für Dateien und Programme verwendet, an die Sie aber nicht gebunden sind, wenn Sie Programme außerhalb der IDE schreiben und in der Befehlszeile compilieren.


Dieser Abschnitt enthält Informationen zu folgenden Themen:

  • Programmorganisation. Eine Beschreibung der grundlegenden Leistungsmerkmale der Sprache, die das Aufteilen einer Anwendung in Units und Namespaces ermöglichen.
  • Beispielprogramme. Kurze Beispiele für Konsolen- und GUI-Anwendungen veranschaulichen die Verwendung des Compilers.

Programmorganisation

Object Pascal-Programme werden normalerweise auf mehrere Quelltextmodule (so genannte Units) verteilt. Die meisten Programme beginnen mit einer program-Kopfzeile, in der der Programmname angegeben wird. Darauf folgt eine optionale uses-Klausel und ein Block von Deklarationen und Anweisungen. Mit der uses-Klausel geben Sie die Units an, die in das Programm eingebunden werden. Units können von mehreren Programmen gemeinsam benutzt werden und verfügen häufig über eigene uses-Klauseln.

Die uses-Klausel liefert dem Compiler Informationen über die Modulabhängigkeiten. Da diese Abhängigkeiten in den Modulen selbst gespeichert werden, benötigen die meisten Object Pascal-Programme keine Make-Dateien, Header-Dateien oder #include-Präprozessordirektiven.

Object Pascal-Quelltextdateien

Der Compiler erwartet Object Pascal-Quelltexte in einem der folgenden Dateitypen:

  • Unit-Quelltextdateien (mit der Namenserweiterung .PAS)
  • Projektdateien (mit der Namenserweiterung .DPR)
  • Package-Quelltextdateien (mit der Namenserweiterung .DPK)

In den Unit-Quelltextdateien befindet sich in der Regel der größte Teil des Programmcodes. Jede Anwendung besteht aus einer Projektdatei und mehreren Unit-Dateien. Die Projektdatei entspricht der Hauptprogrammdatei (program) im herkömmlichen Pascal und organisiert die Units der Anwendung. Embarcadero-Entwicklungstools verwalten für jede Anwendung automatisch eine Projektdatei.


Package-Quelltextdateien ähneln Projektdateien, werden aber für spezielle, dynamisch ladbare Bibliotheken (so genannte Packages) verwendet.

Weitere Anwendungsdateien

Embarcadero-Produkte verwenden neben den Quelltextmodulen auch die folgenden Dateitypen, die keinen Pascal-Code enthalten und ebenfalls automatisch von der IDE verwaltet werden:

  • Formulardateien (mit der Namenserweiterung .FMX)
  • Ressourcendateien (mit der Namenserweiterung .RES)
  • Projektoptionsdateien (mit der Namenserweiterung .DOF)

Eine Formulardatei enthält die Beschreibung der Eigenschaften des Formulars und seiner Komponenten. Sie repräsentiert ein Formular, das normalerweise einem Fenster oder Dialogfeld in einer Anwendung entspricht. Formulardateien können in der IDE als Text angezeigt und bearbeitet und danach entweder im Text- oder im Binärformat gespeichert werden. (Das Textformat eignet sich hervorragend zur Versionskontrolle.) Obwohl Formulardateien standardmäßig als Text gespeichert werden, ist eine manuelle Bearbeitung nicht üblich. Normalerweise werden dazu unsere visuellen Tools verwendet. Jedes Projekt hat mindestens ein Formular. Zu jedem Formular gehört eine Unit-Datei (.PAS), die standardmäßig denselben Namen wie die Formulardatei erhält.

Zusätzlich zu den Formulardateien verwendet jedes Projekt eine Ressourcendatei (.RES), in der das Anwendungssymbol und andere Ressourcen, wie Strings, gespeichert werden. Diese Datei erhält automatisch denselben Namen wie die Projektdatei (.DPR).

Die Projektoptionsdatei (.DOF) enthält Compiler- und Linker-Einstellungen, Suchpfadinformationen, Versionsinformationen usw. Diese Datei erhält automatisch denselben Namen wie die Projektdatei (.DPR). Die Einstellungen in dieser Datei können im Dialogfeld Projektoptionen festgelegt werden.

Verschiedene Tools in der IDE speichern Daten in speziellen Dateitypen. Desktop-Konfigurationsdateien (.DSK) enthalten Informationen über die Anordnung der Fenster und andere Konfigurationseinstellungen. Desktop-Einstellungen können projektspezifisch sein oder für die gesamte Umgebung gelten. Diese Desktop-Konfigurationsdateien haben keine direkten Auswirkungen auf die Compilierung.

Vom Compiler generierte Dateien

Wenn Sie eine Anwendung oder ein Package zum ersten Mal erstellen, generiert der Compiler für jede im Projekt verwendete Unit eine compilierte Unit-Datei (.DCU). Diese Dateien werden dann zu einer ausführbaren Datei bzw. zu einem gemeinsam genutzten Package gelinkt. Beim ersten Erzeugen (Build) eines Package generiert der Compiler für jede in dem Package enthaltene neue Unit ein Datei und anschließend eine .DCP- und eine Package-Datei.

Beim Erstellen eines Projekts wird eine Unit nur dann erneut compiliert, wenn ihre Quelltextdatei (.PAS) seit dem letzten Compilieren geändert wurde, die zugehörige .DCU/.DCP-Datei nicht gefunden werden kann, der Compiler explizit dazu angewiesen wird oder das Interface der Unit von einer anderen Unit abhängig ist, die geändert wurde. Wenn der Compiler auf die entsprechende compilierte Unit-Datei zugreifen kann und die Unit nicht von anderen Units abhängig ist, die geändert wurden, wird die Quelltextdatei der Unit nicht benötigt.

Beispielprogramme

Die folgenden Beispielprogramme zeigen die Grundzüge der Programmierung mit Object Pascal. Es handelt sich um einfache Anwendungen, die normalerweise nicht in der IDE compiliert werden.

Eine einfache Konsolenanwendung

Das folgende Beispiel zeigt eine einfache Konsolenanwendung, die Sie in der Befehlszeile compilieren und ausführen können:

 
  program Greeting;
  
  {$APPTYPE CONSOLE}
  
  var
    MyMessage: string;
  
  begin
    MyMessage := 'Hello world!';
    Writeln(MyMessage);
  end.

Mit der ersten Anweisung wird das Programm "Greeting" deklariert. Die Direktive {$APPTYPE CONSOLE} teilt dem Compiler mit, dass es sich um eine Konsolenanwendung handelt, die in der Befehlszeile ausgeführt wird. In der nächsten Zeile wird die String-Variable "MyMessage" deklariert ((in Object Pascal gibt es echte String-Datentypen). Im Programmblock wird der Variable "MyMessage" der String "Hello world!" zugewiesen. Anschließend wird die Variable mit der Standardprozedur Writeln an die Standardausgabe gesendet. (Writeln ist implizit in der Unit System definiert, die automatisch in jede Anwendung eingebunden wird).


Nach der Compilierung gibt die resultierende ausführbare Datei die Meldung Hello world! auf dem Bildschirm aus.

Neben seiner Einfachheit unterscheidet sich dieses Beispiel noch in anderen wichtigen Punkten von den Anwendungen, die Sie normalerweise mit Embarcadero-Entwicklungstools erstellen. Zum einen handelt es sich bei dem Beispiel um eine Konsolenanwendung. Mit Embarcadero-Entwicklungstools werden hauptsächlich Anwendungen mit grafischen Benutzeroberflächen entwickelt, in denen keine Writeln-Aufrufe benötigt werden. Außerdem befindet sich das gesamte Beispielprogramm (Writeln) in einer einzigen Datei. Bei einer typischen GUI-Anwendung steht der Programmkopf und die erste Zeile des Beispiels in einer separaten Projektdatei, die mit Ausnahme einiger Routinenaufrufe keinerlei Programmlogik enthält.

Ein komplexeres Beispiel

Das Programm im nächsten Beispiel ist auf zwei Dateien verteilt, eine Projektdatei und eine Unit-Datei. Die Projektdatei, die Sie unter dem Namen greeting.dpr speichern können, hat folgenden Inhalt:

 
  program Greeting;
  
  {$APPTYPE CONSOLE}
  
  uses
    Unit1;
  
  begin
    PrintMessage('Hello World!');
  end.

In der ersten Zeile wird das Programm greeting deklariert, das wiederum eine Konsolenanwendung ist. Über die Klausel uses Unit1; wird dem Compiler mitgeteilt, dass das Programm greeting von einer Unit namens Unit1 abhängig ist. Zum Schluss wird die Prozedur PrintMessage mit dem String Hello World! aufgerufen. Die Prozedur PrintMessage ist in Unit1 definiert. Unit1 hat folgenden Inhalt (speichern Sie sie unter dem Namen Unit1.pas):

 
  unit Unit1;
  
  interface
  
  procedure PrintMessage(msg: string);
  
  implementation
  
  procedure PrintMessage(msg: string);
  begin
     Writeln(msg);
  end;
  
  end.

Unit1 definiert eine Prozedur namens PrintMessage, die einen String als Argument übernimmt und diesen String an die Standardausgabe sendet. (In Object Pascal heißen Routinen ohne Rückgabewert Prozeduren. Routinen, die einen Wert zurückgeben, heißen Funktionen.)

Beachten Sie, dass PrintMessage zweimal in Unit1 deklariert ist. Die erste Deklaration im interface-Abschnitt macht PrintMessage für andere Module verfügbar (z. B. für das Programm greeting), die Unit1 einbinden. Durch die zweite Deklaration (im implementation-Abschnitt) erfolgt die eigentliche Definition der Prozedur PrintMessage.


Unit1 braucht in der Befehlszeile nicht angegeben zu werden. --> Der Compiler liest beim Bearbeiten von greeting.dpr automatisch die Unit-Dateien ein, von denen greeting abhängig ist. Die neue ausführbare Datei führt dieselbe Operation wie im ersten Beispiel durch: sie gibt die Meldung Hello world! aus.

Eine FireMonkey-Anwendung

Das nächste Beispiel ist eine Anwendung, die mithilfe von FireMonkey-Komponenten in der IDE erstellt wird. Im Programm werden die automatisch generierten Formular- und Ressourcendateien verwendet. Es kann daher nicht allein aus dem Quelltext compiliert werden. Das Beispiel zeigt einige wichtige Merkmale von Object Pascal. Neben mehreren Units werden auch Klassen und Objekte verwendet.

Die Anwendung besteht aus einer Projektdatei und zwei neuen Unit-Dateien. Hier zuerst die Projektdatei:

 
  program Greeting;
  
  uses
    FMX.Forms, Unit1, Unit2;
  
  {$R *.res} { This directive links the project's resource file. }
  
  begin
     { Calls to global Application instance }
     Application.Initialize;
     Application.CreateForm(TForm1, Form1);
     Application.CreateForm(TForm2, Form2);
     Application.Run;
  end.

Das Programm heißt auch diesmal greeting. Es verwendet drei Units: FMX.Forms ist ein Bestandteil von FireMonkey; Unit1 gehört zum Hauptformular der Anwendung (Form1) und Unit2 zu einem weiteren Formular (Form2).

Im Programm finden mehrere Aufrufe des Objekts Application statt, das eine Instanz der in der Unit Forms deklarierten Klasse FMX.Forms.TApplication ist (für jedes Projekt wird automatisch ein Application-Objekt erstellt). Zwei dieser Aufrufe rufen die FMX.Forms.TApplication-Methode CreateForm auf. Mit dem ersten Aufruf von CreateForm wird Form1 erstellt, eine Instanz der in Unit1 deklarierten Klasse TForm1. Mit dem zweiten Aufruf von CreateForm wird Form2 erstellt, eine Instanz der in Unit2 deklarierten Klasse TForm2.

Unit1 hat folgenden Inhalt:

 
  unit Unit1;
  
  interface
  
  uses System.SysUtils, FMX.Types, FMX.Classes, FMX.Graphics, FMX.Controls, FMX.Forms, FMX.Dialogs;
  
  type
    TForm1 = class(TForm)
      Button1: TButton;
      procedure Button1Click(Sender: TObject);
    end;
  
  var
    Form1: TForm1;
  
  implementation
  
  uses Unit2;
  
  {$R *.dfm}
  
  procedure TForm1.Button1Click(Sender: TObject);
    begin
      Form2.ShowModal;
    end;
  
  end.

Unit1 erstellt eine Klasse namens TForm1 (abgeleitet von FMX.StdCtrls.TButton) und eine Instanz dieser Klasse (Form1). Die Klasse TForm1 enthält die Schaltfläche Button1 (eine Instanz von FMX.StdCtrls.TButton) und die Prozedur Button1Click, die aufgerufen wird, wenn der Benutzer auf Button1 klickt. Button1Click verbirgt Form1 und zeigt Form2 an (durch den Aufruf von Form2.ShowModal).

Hinweis: Im vorhergehenden Beispiel ist Form2.ShowModal von automatisch erstellten Formularen abhängig. Auch wenn sich solche Formulare gut für Beispielcode eignen, wird von ihrer Verwendung doch ausdrücklich abgeraten.

Das Objekt Form2 ist in Unit2 definiert:

 
  unit Unit2;
  
  interface
  
  uses System.SysUtils, FMX.Types, FMX.Classes, FMX.Graphics, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.StdCtrls;
  
  type
  TForm2 = class(TForm)
    Label1: TLabel;
    CancelButton: TButton;
    procedure CancelButtonClick(Sender: TObject);
  end;
  
  var
    Form2: TForm2;
  
  implementation
  
  uses Unit1;
  
  {$R *.dfm}
  
  procedure TForm2.CancelButtonClick(Sender: TObject);
    begin
      Form2.Close;
    end;
  
  end.

Unit2 erstellt eine Klasse namens TForm2 und eine Instanz dieser Klasse (Form2). Die Klasse TForm2 enthält eine Schaltfläche (CancelButton, eine Instanz von FMX.StdCtrls.TButton) und eine Beschriftung (Label1, eine Instanz von FMX.StdCtrls.TLabel). Obwohl aus dem Quelltext nicht ersichtlich, zeigt Label1 den Titel Hello world! an. Der Titel ist in der Formulardatei von Form2, Unit2.dfm, definiert.

TForm2 deklariert und definiert die Methode CancelButtonClick, die zur Laufzeit aufgerufen wird, wenn der Benutzer auf die Schaltfläche CancelButton klickt. Solche Prozeduren (wie auch TForm1.Button1Click in Unit1) nennt man Ereignisbehandlungsroutinen, weil sie auf Ereignisse reagieren, die zur Laufzeit der Anwendung auftreten. Ereignisbehandlungsroutinen werden durch die Formulardateien für Form1 und Form2 bestimmten Ereignissen zugewiesen.

Nach dem Starten der Anwendung greeting wird lediglich Form1 angezeigt, während Form2 nicht sichtbar ist (standardmäßig ist nur das erste in der Projektdatei erstellte Formular, das Hauptformular, zur Laufzeit sichtbar). Klickt der Benutzer auf die Schaltfläche in Form1, zeigt Form2 die Meldung Hello world! an. Wenn der Benutzer auf CancelButton oder auf das Schließen-Symbol in der Titelleiste klickt, wird Form2 geschlossen.

Siehe auch

Meine Werkzeuge
In anderen Sprachen