Table Of ContentObject Pascal
Sprachreferenz
Borland®
™
Delphi 5
für Windows 95, Windows 98 & Windows NT
Inprise GmbH, Robert-Bosch-Straße 11, D-63225 Langen
Copyright © 1997, 1998 Inprise, Inc. Alle Rechte vorbehalten. Alle Produktnamen von Inprise sind eingetragene
Warenzeichen der Inprise, Inc.
Deutsche Ausgabe © 1999 Inprise GmbH, Robert-Bosch-Straße 11, D-63225 Langen, Telefon 06103/979-0,
Fax 06103/979-290
Update/Übertragung ins Deutsche: Krieger, Zander & Partner GmbH, München
Satz: Krieger, Zander & Partner GmbH, München
Hauptsitz: 100 Enterprise Way, P.O. Box 660001, Scotts Valley, CA 95067-0001, +1-(408)431-1000
Niederlassungen in: Australien, Deutschland, Frankreich, Großbritannien, Hong Kong, Japan, Kanada,
Lateinamerika, Mexiko, den Niederlanden und Taiwan
HDA1350GE21002
Inhalt
Kapitel 1 Qualifizierte Bezeichner. . . . . . . . . . .4-2
Einführung 1-1 Reservierte Wörter . . . . . . . . . . . . . . .4-3
Direktiven . . . . . . . . . . . . . . . . . . . .4-3
Inhalt dieses Handbuchs . . . . . . . . . . . . . 1-1
Ziffern . . . . . . . . . . . . . . . . . . . . . .4-4
Delphi und Object Pascal . . . . . . . . . . . 1-1
Label . . . . . . . . . . . . . . . . . . . . . . .4-4
Typografische Konventionen . . . . . . . . . 1-2
Zeichen-Strings . . . . . . . . . . . . . . . . .4-4
Weitere Informationsquellen . . . . . . . . . . . 1-2
Kommentare und Compiler-Direktiven . . . . .4-5
Software-Registrierung und technische
Ausdrücke. . . . . . . . . . . . . . . . . . . . . .4-6
Unterstützung . . . . . . . . . . . . . . . . . . 1-3
Operatoren. . . . . . . . . . . . . . . . . . . .4-6
Teil I Arithmetische Operatoren . . . . . . . . .4-7
Beschreibung der Sprachen Boolesche Operatoren. . . . . . . . . . . .4-8
Logische (bitweise) Operatoren . . . . . .4-9
String-Operatoren . . . . . . . . . . . . . .4-9
Kapitel 2
Zeiger-Operatoren. . . . . . . . . . . . . 4-10
Übersicht 2-1
Mengenoperatoren. . . . . . . . . . . . . 4-11
Programmorganisation . . . . . . . . . . . . . . 2-1 Relationale Operatoren . . . . . . . . . . 4-11
Pascal-Quelltextdateien . . . . . . . . . . . . 2-2 Klassen-Operatoren . . . . . . . . . . . . 4-12
Weitere Anwendungsdateien . . . . . . . . . 2-2 Der Operator @. . . . . . . . . . . . . . . 4-12
Vom Compiler generierte Dateien . . . . . . 2-3 Regeln für die Rangfolge von
Beispielprogramme . . . . . . . . . . . . . . . . 2-3 Operatoren . . . . . . . . . . . . . . . . 4-13
Eine einfache Konsolenanwendung . . . . . 2-3 Funktionsaufrufe . . . . . . . . . . . . . . . 4-14
Ein komplexeres Beispiel . . . . . . . . . . . 2-4 Mengenkonstruktoren . . . . . . . . . . . . 4-14
Eine Windows-Anwendung. . . . . . . . . . 2-5 Indizes . . . . . . . . . . . . . . . . . . . . . 4-15
Typumwandlungen . . . . . . . . . . . . . . 4-15
Kapitel 3 Wertumwandlungen . . . . . . . . . . . 4-15
Programme und Units 3-1 Variablenumwandlungen. . . . . . . . . 4-16
Programmstruktur und -syntax . . . . . . . . . 3-1 Deklarationen und Anweisungen. . . . . . . . 4-17
Der Programmkopf . . . . . . . . . . . . . . 3-2 Deklarationen . . . . . . . . . . . . . . . . . 4-17
Die uses-Klausel . . . . . . . . . . . . . . . . 3-3 Anweisungen . . . . . . . . . . . . . . . . . 4-18
Der Block . . . . . . . . . . . . . . . . . . . . 3-3 Einfache Anweisungen . . . . . . . . . . . . 4-18
Unit-Struktur und -Syntax . . . . . . . . . . . . 3-3 Zuweisungen. . . . . . . . . . . . . . . . 4-18
Der Unit-Kopf . . . . . . . . . . . . . . . . . 3-4 Prozedur- und Funktionsaufrufe. . . . . 4-19
Goto-Anweisungen . . . . . . . . . . . . 4-19
Der interface-Abschnitt . . . . . . . . . . . . 3-4
Der implementation-Abschnitt . . . . . . . . 3-4 Strukturierte Anweisungen . . . . . . . . . 4-21
Der initialization-Abschnitt . . . . . . . . . . 3-5 Verbundanweisungen. . . . . . . . . . . 4-21
Der finalization-Abschnitt. . . . . . . . . . . 3-5 with-Anweisungen . . . . . . . . . . . . 4-22
Unit-Referenzen und die uses-Klausel . . . . . 3-6 if-Anweisungen . . . . . . . . . . . . . . 4-23
Die Syntax der uses-Klausel. . . . . . . . . . 3-6 case-Anweisungen. . . . . . . . . . . . . 4-25
Mehrere und indirekte Unit-Referenzen. . . 3-7 Schleifen . . . . . . . . . . . . . . . . . . 4-26
Zirkuläre Unit-Referenzen . . . . . . . . . . 3-8 repeat-Anweisungen . . . . . . . . . . . 4-26
while-Anweisungen. . . . . . . . . . . . 4-27
Kapitel 4 for-Anweisungen . . . . . . . . . . . . . 4-27
Syntaktische Elemente 4-1 Blöcke und Gültigkeitsbereich. . . . . . . . . . 4-29
Blöcke. . . . . . . . . . . . . . . . . . . . . . 4-29
Grundlegende syntaktische Elemente. . . . . . 4-1
Gültigkeitsbereich. . . . . . . . . . . . . . . 4-30
Symbole . . . . . . . . . . . . . . . . . . . . . 4-2
Namenskonflikte. . . . . . . . . . . . . . 4-30
Bezeichner. . . . . . . . . . . . . . . . . . . . 4-2
i
Kapitel 5 Variablendeklarationen. . . . . . . . . . . . 5-40
Datentypen, Variablen und Absolute Adressen. . . . . . . . . . . . . 5-42
Dynamische Variablen . . . . . . . . . . 5-42
Konstanten 5-1
Thread-Variablen . . . . . . . . . . . . . 5-42
Typen . . . . . . . . . . . . . . . . . . . . . . . . 5-1 Deklarierte Konstanten. . . . . . . . . . . . . . 5-43
Einfache Typen. . . . . . . . . . . . . . . . . . . 5-3 Echte Konstanten . . . . . . . . . . . . . . . 5-43
Ordinale Typen . . . . . . . . . . . . . . . . . 5-3 Konstante Ausdrücke . . . . . . . . . . . 5-44
Integer-Typen . . . . . . . . . . . . . . . . 5-4 Ressourcen-Strings . . . . . . . . . . . . 5-45
Zeichentypen . . . . . . . . . . . . . . . . 5-5 Typisierte Konstanten. . . . . . . . . . . . . 5-45
Boolesche Typen . . . . . . . . . . . . . . 5-6 Array-Konstanten . . . . . . . . . . . . . 5-46
Aufzählungstypen . . . . . . . . . . . . . 5-7 Record-Konstanten . . . . . . . . . . . . 5-46
Teilbereichstypen . . . . . . . . . . . . . . 5-8 Prozedurale Konstanten . . . . . . . . . 5-47
Reelle Typen . . . . . . . . . . . . . . . . . . 5-9 Zeigerkonstanten . . . . . . . . . . . . . 5-47
String-Typen . . . . . . . . . . . . . . . . . . . .5-10
Kurze String-Typen . . . . . . . . . . . . . .5-12 Kapitel 6
Lange String-Typen . . . . . . . . . . . . . .5-12 Prozeduren und Funktionen 6-1
WideString-Typen . . . . . . . . . . . . . . .5-13
Prozeduren und Funktionen deklarieren. . . . .6-1
Erweiterte Zeichensätze . . . . . . . . . .5-13
Prozedurdeklarationen . . . . . . . . . . . . .6-2
Nullterminierte Strings . . . . . . . . . . . .5-14
Funktionsdeklarationen . . . . . . . . . . . .6-3
Zeiger, Arrays und String-Konstanten . .5-14
Aufrufkonventionen . . . . . . . . . . . . . .6-5
Kombination von Pascal-Strings und
forward- und interface-Deklarationen . . . .6-6
nullterminierten Strings . . . . . . . . .5-16
external-Deklarationen . . . . . . . . . . . . .6-7
Strukturierte Typen . . . . . . . . . . . . . . . .5-17
OBJ-Dateien linken . . . . . . . . . . . . .6-7
Mengentypen. . . . . . . . . . . . . . . . . .5-17
Funktionen aus DLLs importieren. . . . .6-7
Array-Typen . . . . . . . . . . . . . . . . . .5-18
Prozeduren und Funktionen überladen . . .6-8
Statische Arrays. . . . . . . . . . . . . . .5-19
Lokale Deklarationen . . . . . . . . . . . . . .6-9
Dynamische Arrays. . . . . . . . . . . . .5-20
Verschachtelte Routinen. . . . . . . . . . .6-9
Array-Typen und Zuweisungen . . . . .5-22
Parameter . . . . . . . . . . . . . . . . . . . . . 6-10
Record-Typen. . . . . . . . . . . . . . . . . .5-23
Parametersemantik . . . . . . . . . . . . . . 6-10
Variante Teile in Record-Typen . . . . . .5-24
Wert- und Variablenparameter. . . . . . 6-11
Dateitypen . . . . . . . . . . . . . . . . . . .5-26
Konstantenparameter . . . . . . . . . . . 6-12
Zeiger und Zeigertypen. . . . . . . . . . . . . .5-27
Ausgabeparameter. . . . . . . . . . . . . 6-12
Zeiger im Überblick . . . . . . . . . . . . . .5-27
Untypisierte Parameter . . . . . . . . . . 6-13
Zeigertypen. . . . . . . . . . . . . . . . . . .5-29
Array-Parameter. . . . . . . . . . . . . . . . 6-14
Zeiger auf Zeichen . . . . . . . . . . . . .5-29
Offene Array-Parameter . . . . . . . . . 6-14
Weitere Standardzeigertypen . . . . . . .5-29
Variante offene Array-Parameter. . . . . 6-15
Prozedurale Typen. . . . . . . . . . . . . . . . .5-30
Standardparameter . . . . . . . . . . . . . . 6-16
Prozedurale Typen in Anweisungen und
Standardparameter und überladene
Ausdrücken . . . . . . . . . . . . . . . . . .5-31
Routinen . . . . . . . . . . . . . . . . . 6-17
Variante Typen . . . . . . . . . . . . . . . . . . .5-33
Standardparameter in forward- und
Typkonvertierung bei Varianten . . . . . . .5-34
interface-Deklarationen . . . . . . . . . 6-18
Varianten in Ausdrücken . . . . . . . . . . .5-36
Prozeduren und Funktionen aufrufen . . . . . 6-18
Variante Arrays. . . . . . . . . . . . . . . . .5-36
Offene Array-Konstruktoren. . . . . . . . . 6-19
OleVariant . . . . . . . . . . . . . . . . . .5-37
Kompatibilität und Identität von Typen. . . . .5-37 Kapitel 7
Typidentität. . . . . . . . . . . . . . . . . . .5-37 Klassen und Objekte 7-1
Typkompatibilität . . . . . . . . . . . . . . .5-38
Klassentypen deklarieren . . . . . . . . . . . . .7-2
Zuweisungskompatibilität . . . . . . . . . .5-39
Vererbung und Gültigkeitsbereich . . . . . .7-3
Typdeklaration. . . . . . . . . . . . . . . . . . .5-40
TObject und TClass . . . . . . . . . . . . .7-3
Variablen . . . . . . . . . . . . . . . . . . . . . .5-40
ii
Kompatibilitätsregeln für Klassentypen . 7-3 Kapitel 8
Objekttypen . . . . . . . . . . . . . . . . . 7-4 Standardroutinen und E/A 8-1
Sichtbarkeit von Klassenelementen . . . . . 7-4
Dateiein und -ausgabe . . . . . . . . . . . . . . .8-1
private-, protected- und public-Elemente 7-5
Textdateien. . . . . . . . . . . . . . . . . . . .8-3
published-Elemente . . . . . . . . . . . . 7-5
Untypisierte Dateien . . . . . . . . . . . . . .8-4
automated-Elemente . . . . . . . . . . . . 7-6
Gerätetreiber für Textdateien . . . . . . . . . . .8-5
Vorwärtsdeklarationen und voneinander
Gerätetreiberfunktionen . . . . . . . . . . . .8-5
abhängige Klassen . . . . . . . . . . . . . . 7-7
Die Funktion Open . . . . . . . . . . . . .8-6
Felder . . . . . . . . . . . . . . . . . . . . . . . . 7-7
Die Funktion InOut . . . . . . . . . . . . .8-6
Methoden. . . . . . . . . . . . . . . . . . . . . . 7-8
Die Funktion Flush . . . . . . . . . . . . .8-6
Methodenimplementierungen . . . . . . . . 7-8
Die Funktion Close . . . . . . . . . . . . .8-6
inherited . . . . . . . . . . . . . . . . . . . 7-9
Nullterminierte Strings. . . . . . . . . . . . . . .8-7
Self . . . . . . . . . . . . . . . . . . . . . . 7-9
Wide-Strings . . . . . . . . . . . . . . . . . . .8-8
Methodenbindung . . . . . . . . . . . . . . .7-10
Weitere Standardroutinen . . . . . . . . . . . . .8-8
Statische Methoden. . . . . . . . . . . . .7-10
Virtuelle und dynamische Methoden. . .7-11 Teil II
Abstrakte Methoden . . . . . . . . . . . .7-13 Spezielle Themen
Methoden überladen. . . . . . . . . . . . . .7-13
Konstruktoren . . . . . . . . . . . . . . . . .7-14
Kapitel 9
Destruktoren . . . . . . . . . . . . . . . . . .7-15
Dynamische Link-Bibliotheken und
Botschaftsbehandlungsroutinen . . . . . . .7-16
Botschaftsbehandlungsroutinen Packages 9-1
implementieren . . . . . . . . . . . . . .7-16
DLLs aufrufen. . . . . . . . . . . . . . . . . . . .9-1
Botschaftsweiterleitung . . . . . . . . . .7-17
Statisches Laden . . . . . . . . . . . . . . .9-1
Eigenschaften. . . . . . . . . . . . . . . . . . . .7-17
Dynamisches Laden. . . . . . . . . . . . .9-2
Auf Eigenschaften zugreifen . . . . . . . . .7-18
DLLs schreiben . . . . . . . . . . . . . . . . . . .9-3
Array-Eigenschaften . . . . . . . . . . . . . .7-19
Die exports-Klausel . . . . . . . . . . . . . . .9-4
Indexangaben. . . . . . . . . . . . . . . . . .7-21
Code für die Initialisierung der Bibliothek. .9-4
Speicherangaben . . . . . . . . . . . . . . . .7-21
Globale Variablen in einer DLL . . . . . . . .9-5
Eigenschaften überschreiben und neu
DLLs und Systemvariablen . . . . . . . . . .9-5
deklarieren . . . . . . . . . . . . . . . . . .7-22
Exceptions und Laufzeitfehler in DLLs. . . .9-6
Klassenreferenzen . . . . . . . . . . . . . . . . .7-24
Der Shared-Memory-Manager. . . . . . . . .9-6
Klassenreferenztypen . . . . . . . . . . . . .7-24
Packages . . . . . . . . . . . . . . . . . . . . . . .9-7
Konstruktoren und Klassenreferenzen. .7-24
Package-Deklarationen und Quelltextdateien9-7
Klassenoperatoren . . . . . . . . . . . . . . .7-25
Packages benennen . . . . . . . . . . . . .9-8
Der Operator is . . . . . . . . . . . . . . .7-25
Die requires-Klausel. . . . . . . . . . . . .9-8
Der Operator as. . . . . . . . . . . . . . .7-25
Die contains-Klausel. . . . . . . . . . . . .9-9
Klassenmethoden . . . . . . . . . . . . . . .7-26
Packages compilieren. . . . . . . . . . . . . .9-9
Exceptions . . . . . . . . . . . . . . . . . . . . .7-27
Generierte Dateien. . . . . . . . . . . . . 9-10
Exception-Typen deklarieren . . . . . . . . .7-27
Package-spezifische Compiler-
Exceptions auslösen und behandeln . . . . .7-27
Direktiven. . . . . . . . . . . . . . . . . 9-10
Die Anweisung try...except . . . . . . . .7-28
Package-spezifische Befehlszeilen-
Exceptions erneut auslösen . . . . . . . .7-31
optionen. . . . . . . . . . . . . . . . . . 9-11
Verschachtelte Exceptions . . . . . . . . .7-31
Die Anweisung try...finally . . . . . . . .7-32 Kapitel 10
Exception-Standardklassen und - Objektschnittstellen 10-1
Standardroutinen. . . . . . . . . . . . . . .7-32
Schnittstellentypen deklarieren . . . . . . . . . 10-1
IUnknown und Vererbung . . . . . . . . . . 10-2
Identifikation einer Schnittstelle. . . . . . . 10-2
iii
Aufrufkonventionen . . . . . . . . . . . . . .10-3 Record-Typen . . . . . . . . . . . . . . . . . 11-8
Schnittstelleneigenschaften . . . . . . . . . .10-3 Dateitypen . . . . . . . . . . . . . . . . . . . 11-9
Vorwärtsdeklarationen . . . . . . . . . . . .10-4 Prozedurale Typen . . . . . . . . . . . . . .11-10
Schnittstellen implementieren . . . . . . . . . .10-4 Klassentypen. . . . . . . . . . . . . . . . . .11-10
Methodenzuordnung . . . . . . . . . . . . .10-5 Klassenreferenztypen. . . . . . . . . . . . .11-11
Geerbte Implementationen ändern. . . . . .10-6 Variante Typen. . . . . . . . . . . . . . . . .11-11
Schnittstellen delegieren. . . . . . . . . . . .10-6
Kapitel 12
Delegieren an eine Eigenschaft vom Typ
einer Schnittstelle . . . . . . . . . . . . .10-7 Ablaufsteuerung 12-1
Delegieren an eine Eigenschaft vom Typ Parameter und Funktionsergebnisse . . . . . . 12-1
einer Klasse . . . . . . . . . . . . . . . .10-7 Parameter . . . . . . . . . . . . . . . . . . . 12-1
Schnittstellenreferenzen. . . . . . . . . . . . . .10-8 Konventionen zur Speicherung in
Zuweisungskompatibilität von Registern . . . . . . . . . . . . . . . . . 12-3
Schnittstellen . . . . . . . . . . . . . . . . .10-9 Funktionsergebnisse . . . . . . . . . . . . . 12-3
Schnittstellenumwandlungen. . . . . . . . 10-10 Methoden . . . . . . . . . . . . . . . . . . . 12-3
Schnittstellenabfragen . . . . . . . . . . 10-10 Konstruktoren und Destruktoren . . . . 12-4
Automatisierungsobjekte . . . . . . . . . . . . 10-11 Exit-Prozeduren. . . . . . . . . . . . . . . . . . 12-4
Dispatch-Schnittstellen . . . . . . . . . . . 10-11
Methoden für Dispatch-Schnittstellen . 10-11 Kapitel 13
Eigenschaften für Dispatch- Der integrierte Assembler 13-1
Schnittstellen . . . . . . . . . . . . . . 10-12
Die Anweisung asm . . . . . . . . . . . . . . . 13-1
Zugriff auf Automatisierungsobjekte . . . 10-12
Register. . . . . . . . . . . . . . . . . . . . . 13-2
Syntax für Aufrufe von Automatisierungs-
Syntax für Assembler-Anweisungen . . . . . . 13-2
methoden . . . . . . . . . . . . . . . . 10-12
Label . . . . . . . . . . . . . . . . . . . . . . 13-2
Duale Schnittstellen . . . . . . . . . . . . . 10-13
Anweisungs-Opcodes. . . . . . . . . . . . . 13-3
Der Befehl RET. . . . . . . . . . . . . . . 13-5
Kapitel 11
Sprungbefehle . . . . . . . . . . . . . . . 13-5
Speicherverwaltung 11-1
Assembler-Direktiven. . . . . . . . . . . . . 13-6
Der Speichermanager von Delphi . . . . . . . .11-1 Operanden . . . . . . . . . . . . . . . . . . . 13-7
Variablen . . . . . . . . . . . . . . . . . . . .11-2 Ausdrücke. . . . . . . . . . . . . . . . . . . . . 13-8
Interne Datenformate . . . . . . . . . . . . . . .11-3 Unterschiede zwischen Ausdrücken in
Integer-Typen. . . . . . . . . . . . . . . . . .11-3 Object Pascal und Assembler. . . . . . . . 13-8
Zeichentypen . . . . . . . . . . . . . . . . . .11-3 Ausdruckselemente. . . . . . . . . . . . . . 13-9
Boolesche Typen . . . . . . . . . . . . . . . .11-3 Konstanten . . . . . . . . . . . . . . . . . 13-9
Aufzählungstypen . . . . . . . . . . . . . . .11-4 Register . . . . . . . . . . . . . . . . . . .13-11
Reelle Typen . . . . . . . . . . . . . . . . . .11-4 Symbole. . . . . . . . . . . . . . . . . . .13-11
Der Typ Real48 . . . . . . . . . . . . . . .11-4 Ausdrucksklassen. . . . . . . . . . . . . . 13-13
Der Typ Single. . . . . . . . . . . . . . . .11-4 Ausdruckstypen. . . . . . . . . . . . . . . 13-15
Der Typ Double. . . . . . . . . . . . . . .11-5 Ausdrucksoperatoren. . . . . . . . . . . . 13-16
Der Typ Extended. . . . . . . . . . . . . .11-5 Assembler-Prozeduren und -Funktionen . . 13-18
Der Typ Comp. . . . . . . . . . . . . . . .11-5
Der Typ Currency. . . . . . . . . . . . . .11-6 Anhang A
Zeigertypen. . . . . . . . . . . . . . . . . . .11-6 Die Grammatik von Object Pascal A-1
Kurze String-Typen . . . . . . . . . . . . . .11-6
Lange String-Typen . . . . . . . . . . . . . .11-6 Index
Wide-String-Typen . . . . . . . . . . . . . . .11-7
Mengentypen. . . . . . . . . . . . . . . . . .11-7
Statische Array-Typen . . . . . . . . . . . . .11-8
Dynamische Array-Typen. . . . . . . . . . .11-8
iv
Tabellen
4.1 Resrevierte Wörter . . . . . . . . . . . . . 4-3 13.7 Erläuterung der Ausdrucksoperatoren des
4.2 Direktiven . . . . . . . . . . . . . . . . . . 4-4 integrierten Assemblers . . . . . . . . 13-16
4.3 Binäre arithmetische Operatoren . . . . . 4-7
4.4 Unäre arithmetische Operatoren. . . . . . 4-7
4.5 Boolesche Operatoren. . . . . . . . . . . . 4-8
4.6 Logische (bitweise) Operatoren . . . . . . 4-9
4.7 String-Operatoren . . . . . . . . . . . . . . 4-9
4.8 Zeichenzeiger-Operatoren . . . . . . . . .4-10
4.9 Mengenoperatoren . . . . . . . . . . . . .4-11
4.10 Relationale Operatoren . . . . . . . . . .4-11
4.11 Wertigkeit der Operatoren . . . . . . . . .4-13
5.1 Generische Integer-Typen für 32-Bit-
Implementationen von Object Pascal . . . 5-4
5.2 Fundamentale Integer-Typen. . . . . . . . 5-4
5.3 Fundamentale reelle Typen. . . . . . . . . 5-9
5.4 Generische reelle Typen. . . . . . . . . . .5-10
5.5 String-Typen . . . . . . . . . . . . . . . . .5-10
5.6 Eine Auswahl der in System und SysUtils
deklarierten Zeigertypen . . . . . . . . .5-29
5.7 Regeln für die Typkonvertierung bei
Varianten . . . . . . . . . . . . . . . . . . .5-35
6.1 Aufrufkonventionen. . . . . . . . . . . . . 6-5
8.1 Ein- und Ausgaberoutinen . . . . . . . . 8-1
8.2 Funktionen für nullterminierte Strings . 8-7
8.3 Weitere Standardroutinen . . . . . . . . . 8-8
9.1 Dateien eines compilierten Package. . . .9-10
9.2 Compiler-Direktiven für Packages. . . . .9-10
9.3 Befehlszeilenoptionen für Packages . . .9-11
11.1 Aufbau des Speichers für einen langen
String . . . . . . . . . . . . . . . . . . . . .11-6
11.2 Aufbau des dynamischen Speichers für einen
Wide-String. . . . . . . . . . . . . . . . . .11-7
11.3 Aufbau des Speichers für ein
dynamischesaaA rrayaaaaaaaaaaaaaaaa a aaaaaa1 1-8
11.4 Ausrichtungsmasken für Typen . . . . . .11-8
11.5 Struktur der virtuellen Methodentabelle 11-11
13.1 Reservierte Wörter im integrierten
Assembler . . . . . . . . . . . . . . . . . .13-7
13.2 Beispiele für String-Konstanten und ihre
Werte . . . . . . . . . . . . . . . . . . . . 13-10
13.3 CPU-Register. . . . . . . . . . . . . . . . 13-11
13.4 Im integrierten Assembler verwendbare
Symbole. . . . . . . . . . . . . . . . . . . 13-12
13.5 Vordefinierte Typensymbole . . . . . . . 13-16
13.6 Rangfolge der Ausdrucksoperatoren des
integrierten Assemblers. . . . . . . . . . 13-16
v
K a p i t e l
1
Einführung
Chapter 1
Dieses Handbuch enthält Informationen zu der in Delphi verwendeten Program-
miersprache Object Pascal.
Inhalt dieses Handbuchs
Die ersten sieben Kapitel beschreiben die meisten der in der normalen Programmie-
rung verwendeten Sprachelemente. Kapitel 8 enthält einen Überblick über die Stan-
dardroutinen für E/A-Operationen und String-Bearbeitung.
Die nächsten beiden Kapitel enthalten Informationen über Spracherweiterungen,
DLLs und Delphi-Packages (Kapitel 9) und über Objektschnittstellen und COM (Ka-
pitel 10). In den letzten drei Kapiteln werden Themen für fortgeschrittene Program-
mierer behandelt: Speicherverwaltung (Kapitel 11), Programmsteuerung (Kapitel 12)
und Verwendung von Assembler-Routinen in Pascal-Programmen (Kapitel 13).
Delphi und Object Pascal
Die meisten Delphi-Entwickler schreiben und compilieren ihre Programme in der in-
tegrierten Entwicklungsumgebung (IDE). Hier kümmert sich Delphi um alle Details,
die beim Einrichten von Projekten und Quelltextdateien von Bedeutung sind (z.B.
Verwalten der Abhängigkeiten zwischen den Units). Delphi stellt dabei spezielle Re-
geln bezüglich der Programmorganisation auf, die aber nicht zur Sprachdefinition
von Object Pascal gehören. So werden beispielsweise bestimmte Namenskonventio-
nen 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 compilie-
ren.
Im allgemeinen geht dieses Handbuch davon aus, daß Sie in der Delphi-IDE arbeiten
und Anwendungen mit Hilfe der VCL (Visual Component Library) erstellen. In man-
Einführung 1-1
Weitere Informationsquellen
chen Abschnitten wird jedoch zwischen speziellen Delphi-Regeln und der normalen
Programmierung mit Object Pascal unterschieden.
Typografische Konventionen
Bezeichner (Konstanten, Variablen, Typen, Eigenschaften, Prozeduren, Funktionen,
Programme, Units, Bibliotheken und Packages) sind im Text kursiv gesetzt. Operato-
ren, reservierte Wörter und Direktiven der Sprache Object Pascal werden fett ge-
schrieben. Quelltextbeispiele und Text, der literal eingegeben werden muß (in eine
Datei oder in der Befehlszeile), erkennen Sie an einer Schrift mit fester Zeichenbreite.
Reservierte Wörter und Direktiven werden auch in Programmlistings fett geschrie-
ben:
function Calculate(X, Y: Integer): Integer;
begin
ƒ
end;
Auch im Quelltexteditor werden Direktiven und reservierte Wörter fett angezeigt,
wenn die Syntaxhervorhebung aktiviert ist.
In manchen Quelltextbeispielen (siehe oben) werden Fortsetzungszeichen (... oder ƒ)
verwendet. Sie stehen für weitere Programmzeilen, die in einer richtigen Quelltext-
datei an dieser Stelle vorhanden wären. Diese Zeichen dürfen nicht in den Quelltext
übernommen werden.
Kursive Angaben in Syntaxbeschreibungen sind Platzhalter, die im echten Quelltext
durch syntaktisch gültige Konstrukte ersetzt werden müssen. Die Syntax der Funkti-
on im vorhergehenden Beispiel könnte beispielsweise folgendermaßen angegeben
werden:
function Funktionsname(Argumente): Rückgabetyp;
In Syntaxangaben werden auch Fortsetzungszeichen (...) und Subskripte verwendet:
function Funktionsname(Arg1, ..., Argn): Rückgabetyp;
Weitere Informationsquellen
Die Online-Hilfe von Delphi enthält Informationen über die IDE und die Benutzer-
oberfläche. Außerdem finden Sie hier das aktuelle VCL-Referenzmaterial. Ausführli-
che Informationen zu vielen Programmierthemen (z.B. Entwickeln von Datenbank-
anwendungen) finden Sie im Entwicklerhandbuch. Einen Überblick über die Delphi-
Dokumentation finden Sie in der Einführung.
1-2 Object Pascal Sprachreferenz
Software-Registrierung und technische Unterstützung
Software-Registrierung und technische Unterstützung
Borland bietet einzelnen Entwicklern, EDV-Fachleuten und Firmen vielfältige Unter-
stützung an. Damit Sie diese Möglichkeiten nutzen können, senden Sie das Registrie-
rungsformular mit den für Sie zutreffenden Angaben zurück. Weitere Informationen
zur technischen Unterstützung und zu weiteren Borland-Diensten erhalten Sie bei Ih-
rem Händler oder auf der Borland-Homepage unter http://www.inprise.com/.
Einführung 1-3
