Object Pascal
Object Pascal, auch bekannt als Delphi, ist eine von der Firma Borland entwickelte objektorientierte Erweiterung der Programmiersprache Pascal.Zuerst eingeführt wurde sie mit Delphi, inzwischen ist sie mit Kylix auch für Linux verfügbar. Auch von Drittanbietern wurde diese Sprache eine Zeit lang angeboten, so von Speedsoft, einer deutschen Firma, unter dem Namen Speed Pascal bzw. Sibyl, als auch von der britischen Firma fPrint UK Ltd. unter dem Namen Virtual Pascal. Beide wurden ursprünglich für OS/2 entwickelt und später nach Windows und Linux portiert. Die Entwicklung von Sibyl wurde anscheinend eingestellt, Virtual Pascal ist inzwischen als Freeware erhältlich. Daneben gibt es noch das ebenfalls kostenlose FreePascal, welches unter der GPL steht und mit Lazarus als RAD-IDE ein freies Gegenstueck zu Borlands Implementierungen bietet.
Object Pascal ist nicht die erste objektorientierte Erweiterung von Pascal. Borland hatte bereits bei Version 5.5 von Turbo Pascal ein Objektmodell eingeführt, welches interessanterweise von den Delphi Compilern bis Version 7.0 immer noch unterstützt wird, wenn man auch nach einer Dokumentation vergeblich sucht. (Delphi 8 für .NET unterstützt sie nicht mehr.)
Object Pascal ist die Grundlage der visuellen Klassenbibliothek Visual Component Library (VCL), auf der Delphi basiert, sowie der neueren "Component Library for Cross Platform" (CLX), auf der Kylix basiert. Beide Bibliotheken sind stark miteinander verwandt, und es ist häufig einfach, eine für die VCL geschriebene Komponente nach CLX zu portieren. Auch das Handling von Variablen unterscheided sich in Kylix und Delphi.
Ein Unterschied zu z.B. C++ ist, dass es nicht möglich ist Objekte auf dem Stack anzulegen, d.h. alle Objekte werden auf dem Heap angelegt (mit Ausnahme der alten Objekte aus Turbo Pascal, die auch nur eingeschränkt genutzt werden können). Viele der Elemente und Ideen von Object Pascal sind in die neue Programmiersprache C# und das Microsoft .NET Framework übernommen worden. Einer der Gründe ist, dass Anders Heijlsberg, vormals Mitentwickler von Delphi bei Borland, zu Microsoft wechselte und maßgeblich an der Entwicklung von C# beteiligt war.
Table of contents |
2 Syntax 3 Weblinks |
TMyObject = class(TCommonObject)
private
FSomePrivateField: integer;
protected
function GetSomeCommonValue: integer; override;
procedure SomeProtectedMethod(Param1: integer; const Param2: string; out OutParam: string); virtual;
procedure SetSomeOtherProperty(Value: integer);
function GetSomeOtherProperty: integer;
public
constructor Create;
destructor Destroy; override;
procedure SomePublicMethod;
published
property SomePublishedProperty: integer read FSomePrivateField; // readonly
property SomeOtherProperty: integer read GetSomeOtherProperty write SetSomeOtherProperty;
end;
Wie im Beispiel zu erkennen, bestehen Klassen in Object Pascal aus höchstens vier Sichtbarkeitsbereichen, die man auch Sichtbarkeitsattribute nennt: private, protected, public und published. Sämtliche zu private gehörenden Elemente sind nur innerhalb des Objektes sichtbar. Selbst in direkten Nachfahren hat man keinen Zugriff auf diesen Bereich. protected bestimmt ebenfalls von außen nicht sichtbare Elemente, auf die man jedoch in Nachfahren zugreifen kann. Alles was im Bereich public definiert wird, unterliegt keiner Beschränkung. Hinzu kommt speziell in Delphi das published Attribut. published steuert die Sichtbarkeit im Object Inspector und bewirkt weitere Informationen für RTTI.
Die Sichtbarkeit kann in Nachfahren durch Redeklaration erhöht, allerdings nicht verringert werden.
Properties dienen zum Information hiding, indem ein direkter Zugriff auf die Variable verhindert wird und die Methode entscheiden kann, welchen Wert sie beim Lesen herausgibt und beim Ändern eines Wertes akzeptiert, was einen ADT (abstract data type) auszeichnet. Wird beispielsweise wie bei property SomePublishedProperty keine write-Methode angegeben, so handelt es sich um eine read-only Variable.
fSomePrivateField := 42;
// privates Feld mit 42 initialisieren
end;
destructor TMyObject.Destroy;
begin
inherited;
// Destruktor der Oberklasse aufrufen
end;
function TMyObject.GetSomeCommonValue: integer;
begin
Result := FSomeCommonValue*2
end;
procedure TMyObject.SomeProtectedMethod(Param1: integer; const Param2: string; out OutParam: string);
var
i: integer;
// Deklaration lokaler Variablen
begin
OutParam := '';
// Ausgabeparameter initialisieren
for i:=1 to Param1 do
OutParam := OutParam + Param2;
// Ausgabeparameter mit dem Eingabeparameter Param1-mal konkatenieren
end;
procedure TMyObject.SomePublicMethod;
begin
Inc(fSomePrivateField);
// privates Feld hochzählen
end;
procedure SetSomeOtherProperty(Value: integer);
begin
fSomePrivateField := Value * 5;
end;
function GetSomeOtherProperty: integer;
begin
Result := fSomePrivateField div 5;
end;
Beispiel einer Klassen-Deklaration
type
TCommonObject = class
private
FSomeCommonValue: integer;
protected
function GetSomeCommonValue: integer; virtual; abstract;
published
property SomeCommonProperty: integer read GetSomeCommonValue;
end;
Dieses Beispiel definiert die zwei Klassen TCommonObject und TMyObject. TCommonObject beschreibt eine abstrakte Klasse, zu deren Entwurfszeit noch nichts über die konkrete Implementierung der Methode GetSomeCommonValue bekannt ist. Jedoch kann es für die weitere Verarbeitung verschiedener Nachfahren von TCommonObject zwingend erforderlich sein, dass diese Methode vorhanden ist. TCommonObject enthält also all diejenigen Methoden und Eigenschaften, die allen Nachfahren gemein ist.
Hier im Beispiel wird GetSomeCommonValue erst in der Klasse TMyObject, die sämtliche Methoden und Eigenschaften von TCommonObject erbt, konkret implementiert.Die dazugehörige Implemementation
constructor TMyObject.Create;
// legt eine Objectinstanz an
begin
inherited;
// Konstruktor der Oberklasse rufen
Syntax
Elementare Datentypen
Name | Größe | Wertebereich | Beschreibung |
---|---|---|---|
ByteBool / Boolean | 1 Byte | true oder false | Boolscher Wert |
WordBool | 2 Byte | true oder false | Boolscher Wert |
LongBool | 4 Byte | true oder false | Boolscher Wert |
Byte | 1 Byte | 0 bis 255 | vorzeichenlose 8 bit-Ganzzahl |
Word | 2 Byte | 0 bis 65536 | vorzeichenlose 16 bit-Ganzzahl |
Cardinal | 4 Byte | 0 bis 4.294.967.295 | vorzeichenlose 32 bit-Ganzzahl |
ShortInt | 1 Byte | -128 bis 127 | vorzeichenbehaftete 8 bit-Ganzzahl |
SmallInt | 2 Byte | -32.768 bis 32.767 | vorzeichenbehaftete 16 bit-Ganzzahl |
LongInt | 4 Byte | -2.147.483.648 bis 2.147.483.647 | vorzeichenbehaftete 32 bit-Ganzzahl |
Int64 | 8 Byte | -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 | vorzeichenbehaftete 64 bit-Ganzzahl |
Real48 | 6 Byte | 2,9x10-39 bis 1,7x1038 | 48 bit-Gleitkommazahl |
Single | 4 Byte | 1,5x10-45 bis 3,4x1038 | 32 bit-Gleitkommazahl (IEEE 754;-float )
|
Double | 8 Byte | 5,0x10-324 bis 1,7x10308 | 64 bit-Gleitkommazahl (IEEE 754-double )
|
Extended | 10 Byte | 3,6x10-4951 bis 1,1x104932 | 80 bit-Gleitkommazahl |
Comp | 8 Byte | -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 | vorzeichenbehaftete 64 bit-Ganzzahl, mit der über die FPU gerechnet wird |
Currency | 8 Byte | -922.337.203.685.477,5808 bis 922.337.203.685.477,5807 | vorzeichenbehaftete 64 bit-Festkommazahl |
Char | 1 Byte | #0 bis #255 | 8 bit-Zeichen, z.B. ASCII-/ANSI-Zeichen |
WideChar | 2 Byte | #0 bis #65535 | 16 bit-Zeichen, z.B. Unicode-Zeichen |
ShortString | bis 256 Byte | Aneinanderrehung von bis zu 255 Chars | |
AnsiString | bis 2 GByte | Aneinanderreihung von bis zu 231 Chars | |
WideString | bis 2 GByte | Aneinanderreihung von bis zu 230 WideChars |
Der Datentyp Real
entspricht in Delphi standardmässig dem Double
. Zur Rückwärtskompatibilität kann man ihm mit dem Compilerschalter {$REALCOMPATIBILITY ON}
dem Real48
gleichsetzen.
Der Datentyp Integer
hängt von der jeweiligen Pascal-Implementation ab. In 16bit-Implementationen (z.B. Turbo Pascal) entsprach er einem SmallInt
, in 32bit-Implementationen einem LongInt
und in 64bit-Implementationen wird er einem Int64
entsprechen.
Der Datentyp String
entspricht standardmäßig einem AnsiString
. Mit {$LONGSTRINGS OFF}
entspricht er zur Rückwärtskompatibilität einem ShortString
.
Reservierte Symbole
and array as asm begin case class const constructor destructor dispinterface div do downto else end except exports file finalization finally for function goto if implementation in inherited initialization inline interface is label library mod nil not object of or out packed procedure program property raise record repeat resourcestring set shl shr string then threadvar to try type unit until uses var while with xor
Direktiven
Direktiven sind Symbole die nur in bestimmten Kontexten reserviert sind, sonst aber als Namen für Variablen, Funktionen, usw. benutzt werden können.absolute abstract assembler at automated cdecl default deprecated dispip dynamic export far implements index library near nodefault on overload override pascal platform private protected public published read register reintroduce safecall stdcall stored virtual write
Weblinks