Pascal - Kurzanleitung

Pascal ist eine universelle Hochsprache, die ursprünglich von Niklaus Wirth in den frühen 1970er Jahren entwickelt wurde. Es wurde entwickelt, um Programmieren als systematische Disziplin zu unterrichten und zuverlässige und effiziente Programme zu entwickeln.

Pascal ist eine auf Algol basierende Sprache und enthält viele Konstrukte von Algol. Algol 60 ist eine Teilmenge von Pascal. Pascal bietet verschiedene Datentypen und Programmierstrukturen. Es ist leicht, die Pascal-Programme zu verstehen und zu pflegen.

Pascal erfreut sich im Lehr- und Wissenschaftsbereich aus verschiedenen Gründen wachsender Beliebtheit:

• Leicht zu lernen.
• Strukturierte Sprache.
• Es erzeugt transparente, effiziente und zuverlässige Programme.
• Es kann auf einer Vielzahl von Computerplattformen kompiliert werden.

Merkmale der Pascal-Sprache

Pascal hat die folgenden Funktionen -

• Pascal ist eine stark typisierte Sprache.
• Es bietet eine umfassende Fehlerprüfung.
• Es bietet verschiedene Datentypen wie Arrays, Datensätze, Dateien und Sets.
• Es bietet eine Vielzahl von Programmierstrukturen.
• Es unterstützt die strukturierte Programmierung durch Funktionen und Prozeduren.
• Es unterstützt die objektorientierte Programmierung.

Fakten über Pascal

• Die Pascal-Sprache wurde nach Blaise Pascal benannt, französischer Mathematiker und Pionier in der Computerentwicklung.

• Niklaus Wirth schloss 1970 die Entwicklung der ursprünglichen Programmiersprache Pascal ab.

• Pascal basiert auf dem blockstrukturierten Stil der Programmiersprache Algol.

• Pascal wurde als eine Sprache entwickelt, die für den Programmierunterricht als systematische Disziplin geeignet ist und deren Implementierung sowohl zuverlässig als auch effizient sein kann.

• Der ISO 7185 Pascal Standard wurde ursprünglich 1983 veröffentlicht.

• Pascal war die primäre Hochsprache, die für die Entwicklung in Apple Lisa und in den frühen Jahren des Mac verwendet wurde.

• 1986 veröffentlichte Apple Computer die erste Object Pascal-Implementierung, und 1993 veröffentlichte das Pascal Standards Committee eine objektorientierte Erweiterung für Pascal.

Warum Pascal verwenden?

Mit Pascal können die Programmierer komplexe strukturierte Datentypen definieren und dynamische und rekursive Datenstrukturen wie Listen, Bäume und Diagramme erstellen. Pascal bietet Funktionen wie Datensätze, Aufzählungen, Unterordnungen, dynamisch zugewiesene Variablen mit zugehörigen Zeigern und Mengen.

Pascal ermöglicht verschachtelte Prozedurdefinitionen in jeder Tiefe. Dies bietet wirklich eine großartige Programmierumgebung für das Erlernen des Programmierens als systematische Disziplin, die auf den grundlegenden Konzepten basiert.

Zu den erstaunlichsten Implementierungen von Pascal gehören -

• Skype
• Total Commander
• TeX
• Macromedia Captivate
• Apple Lisa
• Verschiedene PC-Spiele
• Eingebettete Systeme

Für den allgemeinen Gebrauch stehen mehrere Pascal-Compiler und -Interpreter zur Verfügung. Unter diesen sind -

• Turbo Pascal - bietet eine IDE und einen Compiler zum Ausführen von Pascal-Programmen unter CP / M, CP / M-86, DOS, Windows und Macintosh.

• Delphi- bietet Compiler zum Ausführen von Object Pascal und generiert nativen Code für 32- und 64-Bit-Windows-Betriebssysteme sowie 32-Bit-Mac OS X und iOS. Embarcadero plant, Unterstützung für das Linux- und Android-Betriebssystem zu entwickeln.

• Free Pascal- Es ist ein kostenloser Compiler zum Ausführen von Pascal- und Object Pascal-Programmen. Free Pascal Compiler ist ein 32- und 64-Bit-Turbo Pascal- und Delphi-kompatibler Pascal-Compiler für Linux, Windows, OS / 2, FreeBSD, Mac OS X, DOS und verschiedene andere Plattformen.

• Turbo51 - Es ist ein kostenloser Pascal-Compiler für die 8051-Familie von Mikrocontrollern mit Turbo Pascal 7-Syntax.

• Oxygene - Es ist ein Object Pascal-Compiler für die .NET- und Mono-Plattformen.

• GNU Pascal (GPC) - Es ist ein Pascal-Compiler, der aus einem Front-End der GNU Compiler Collection besteht.

In diesen Tutorials werden wir Free Pascal verwenden. Sie können Free Pascal für Ihr Betriebssystem über den folgenden Link herunterladen : Free Pascal herunterladen

Installation von Free Pascal unter Linux

Die Linux-Distribution von Free Pascal gibt es in drei Formen:

• ein tar.gz Version, auch als separate Dateien verfügbar.

• ein .rpm Version (Red Hat Package Manager).

• ein .deb (Debian) Version.

Installationscode für die RPM-Version ::

rpm -i fpc-X.Y.Z-N.ARCH.rpm

Dabei ist XYZ die Versionsnummer der RPM-Datei und ARCH eine der unterstützten Architekturen (i386, x86_64 usw.).

Installationscode für die Debian-Version (wie Ubuntu) -

dpkg -i fpc-XXX.deb

Wobei XXX die Versionsnummer der .deb-Datei ist.

Weitere Informationen finden Sie unter: Kostenloses Pascal-Installationshandbuch

Installieren von Free Pascal auf einem Mac

Wenn Sie Mac OS X verwenden, können Sie Free Pascal am einfachsten verwenden, indem Sie die Xcode-Entwicklungsumgebung von der Apple-Website herunterladen und die einfachen Installationsanweisungen befolgen. Sobald Sie Xcode eingerichtet haben, können Sie den Free Pascal-Compiler verwenden.

Installieren von Free Pascal unter Windows

Für Windows laden Sie das Windows-Installationsprogramm setup.exe herunter. Dies ist ein übliches Installationsprogramm. Für die Installation müssen Sie die folgenden Schritte ausführen:

• Wählen Sie ein Verzeichnis.

• Wählen Sie Teile des Pakets aus, die Sie installieren möchten.

• Optional können Sie die Erweiterungen .pp oder .pas der Free Pascal IDE zuordnen.

Weitere Informationen finden Sie unter: Kostenloses Pascal-Installationshandbuch

Texteditor

Dies wird verwendet, um Ihr Programm einzugeben. Beispiele für wenige Editoren sind Windows Notepad, OS Edit-Befehl, Brief, Epsilon, EMACS und vim oder vi.

Name und Version des Texteditors können auf verschiedenen Betriebssystemen variieren. Beispielsweise wird Notepad unter Windows verwendet, und vim oder vi können sowohl unter Windows als auch unter Linux oder UNIX verwendet werden.

Die Dateien, die Sie mit Ihrem Editor erstellen, werden als Quelldateien bezeichnet und enthalten Programmquellcode. Die Quelldateien für Pascal-Programme werden normalerweise mit der Erweiterung benannt.pas.

Stellen Sie vor Beginn der Programmierung sicher, dass Sie über einen Texteditor verfügen und über genügend Erfahrung verfügen, um ein Computerprogramm zu schreiben, in einer Datei zu speichern, zu kompilieren und schließlich auszuführen.

Bevor wir die Grundbausteine ​​der Programmiersprache Pascal studieren, wollen wir uns eine minimale Pascal-Programmstruktur ansehen, damit wir sie in den kommenden Kapiteln als Referenz verwenden können.

Pascal Programmstruktur

Ein Pascal-Programm besteht im Wesentlichen aus folgenden Teilen:

• Programmname
• Verwendet den Befehl
• Typdeklarationen
• Ständige Erklärungen
• Variablendeklarationen
• Funktionserklärungen
• Verfahrenserklärungen
• Hauptprogrammblock
• Anweisungen und Ausdrücke in jedem Block
• Comments

Jedes Pascal-Programm hat im Allgemeinen eine Überschriftenanweisung, eine Deklaration und einen Ausführungsteil genau in dieser Reihenfolge. Das folgende Format zeigt die grundlegende Syntax für ein Pascal-Programm -

program {name of the program}
uses {comma delimited names of libraries you use}
const {global constant declaration block}
var {global variable declaration block}

function {function declarations, if any}
{ local variables }
begin
...
end;

procedure { procedure declarations, if any}
{ local variables }
begin
...
end;

begin { main program block starts}
...
end. { the end of main program block }

Pascal Hallo Welt Beispiel

Es folgt ein einfacher Pascal-Code, der die Wörter "Hallo Welt!" - -

program HelloWorld;
uses crt;

(* Here the main program block starts *)
begin
   writeln('Hello, World!');
   readkey;
end.

Dies führt zu folgendem Ergebnis:

Hello, World!

Schauen wir uns verschiedene Teile des obigen Programms an -

• Die erste Zeile des Programms program HelloWorld; gibt den Namen des Programms an.

• Die zweite Zeile des Programms uses crt; ist ein Präprozessorbefehl, der den Compiler anweist, die CRT-Einheit einzuschließen, bevor er zur eigentlichen Kompilierung übergeht.

• Die nächsten Zeilen in den Anweisungen begin und end sind der Hauptprogrammblock. Jeder Block in Pascal ist in a eingeschlossenbegin Aussage und ein endErklärung. Auf die end-Anweisung, die das Ende des Hauptprogramms angibt, folgt jedoch ein Punkt (.) Anstelle eines Semikolons (;).

• Das begin In der Anweisung des Hauptprogrammblocks beginnt die Programmausführung.

• Die Linien innerhalb (*...*) wird vom Compiler ignoriert und es wurde hinzugefügt, um a hinzuzufügen comment im Programm.

• Die Aussage writeln('Hello, World!');verwendet die in Pascal verfügbare Schreibfunktion, die die Meldung "Hallo Welt!" auf dem Bildschirm angezeigt werden.

• Die Aussage readkey;Ermöglicht das Anhalten der Anzeige, bis der Benutzer eine Taste drückt. Es ist Teil der CRT-Einheit. Eine Einheit ist wie eine Bibliothek in Pascal.

• Die letzte Aussage end. beendet dein Programm.

Pascal-Programm kompilieren und ausführen

• Öffnen Sie einen Texteditor und fügen Sie den oben genannten Code hinzu.

• Speichern Sie die Datei als hello.pas

• Öffnen Sie eine Eingabeaufforderung und wechseln Sie in das Verzeichnis, in dem Sie die Datei gespeichert haben.

• Geben Sie an der Eingabeaufforderung fpc hello.pas ein und drücken Sie die Eingabetaste, um Ihren Code zu kompilieren.

• Wenn Ihr Code keine Fehler enthält, führt Sie die Eingabeaufforderung zur nächsten Zeile und generiert sie hello ausführbare Datei und hello.o Objektdatei.

• Geben Sie nun ein hello an der Eingabeaufforderung, um Ihr Programm auszuführen.

• Sie können "Hello World" auf dem Bildschirm sehen und das Programm wartet, bis Sie eine beliebige Taste drücken.

$ fpc hello.pas Free Pascal Compiler version 2.6.0 [2011/12/23] for x86_64 Copyright (c) 1993-2011 by Florian Klaempfl and others Target OS: Linux for x86-64 Compiling hello.pas Linking hello 8 lines compiled, 0.1 sec $ ./hello
Hello, World!

Stellen Sie sicher, dass der Pascal-Compiler frei ist fpc befindet sich in Ihrem Pfad und Sie führen es in dem Verzeichnis aus, das die Quelldatei hello.pas enthält.

Sie haben eine Grundstruktur des Pascal-Programms gesehen, sodass andere Grundbausteine ​​der Pascal-Programmiersprache leicht zu verstehen sind.

Variablen

Eine Variablendefinition wird in einen Block eingefügt, der mit a beginnt var Schlüsselwort, gefolgt von Definitionen der Variablen wie folgt:

var
A_Variable, B_Variable ... : Variable_Type;

Pascal-Variablen werden außerhalb des Code-Körpers der Funktion deklariert, was bedeutet, dass sie nicht innerhalb der deklariert werden begin und end Paare, aber sie werden nach der Definition der Prozedur / Funktion und vor dem deklariert beginStichwort. Für globale Variablen werden sie nach dem Programmkopf definiert.

Funktionen / Prozeduren

In Pascal, a procedure ist ein Satz von auszuführenden Anweisungen ohne Rückgabewert und a functionist eine Prozedur mit einem Rückgabewert. Die Definition der Funktion / Prozeduren lautet wie folgt:

Function Func_Name(params...) : Return_Value;
Procedure Proc_Name(params...);

Bemerkungen

Die mehrzeiligen Kommentare sind in geschweiften Klammern und Sternchen als (* ... *) eingeschlossen. Pascal erlaubt einzeilige Kommentare in geschweiften Klammern {...}.

(* This is a multi-line comments
   and it will span multiple lines. *)

{ This is a single line comment in pascal }

Groß- und Kleinschreibung

Pascal ist eine Sprache ohne Groß- und Kleinschreibung, dh Sie können in beiden Fällen Ihre Variablen, Funktionen und Prozeduren schreiben. Wie die Variablen A_Variable haben a_variable und A_VARIABLE in Pascal dieselbe Bedeutung.

Pascal-Anweisungen

Pascal-Programme bestehen aus Anweisungen. Jede Anweisung gibt einen bestimmten Job des Programms an. Diese Jobs können Deklaration, Zuweisung, Lesen von Daten, Schreiben von Daten, Treffen logischer Entscheidungen, Übertragen der Programmflusskontrolle usw. sein.

Zum Beispiel -

readln (a, b, c);
s := (a + b + c)/2.0;
area := sqrt(s * (s - a)*(s-b)*(s-c));
writeln(area);

Reservierte Wörter in Pascal

Die Anweisungen in Pascal bestehen aus bestimmten Pascal-Wörtern, die als reservierte Wörter bezeichnet werden. Zum Beispiel sind die Wörter, Programm, Eingabe, Ausgabe, var, real, begin, readline, writeline und end alle reservierte Wörter.

Im Folgenden finden Sie eine Liste der in Pascal verfügbaren reservierten Wörter.

und	Array	Start	Fall	const
div	tun	bis zu	sonst	Ende
Datei	zum	Funktion	gehe zu	wenn
im	Etikette	mod	Null	nicht
von	oder	verpackt	Verfahren	Programm
Aufzeichnung	wiederholen	einstellen	dann	zu
Art	bis um	var	während	mit

Zeichensatz und Bezeichner in Pascal

Der Pascal-Zeichensatz besteht aus -

• Alle Großbuchstaben (AZ)

• Alle Kleinbuchstaben (az)

• Alle Ziffern (0-9)

• Sonderzeichen - + * /: = ,. ;. () [] = {} `Leerraum

Die Entitäten in einem Pascal-Programm wie Variablen und Konstanten, Typen, Funktionen, Prozeduren und Datensätze usw. haben einen Namen oder eine Kennung. Ein Bezeichner ist eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnen. Spezielle Symbole und Leerzeichen dürfen nicht in einer Kennung verwendet werden.

Datentypen einer Entität geben die Bedeutung, Einschränkungen, möglichen Werte, Operationen, Funktionen und den damit verbundenen Speichermodus an.

Ganzzahlige, reelle, boolesche und Zeichentypen werden als Standarddatentypen bezeichnet. Datentypen können in skalare, Zeiger- und strukturierte Datentypen unterteilt werden. Beispiele für skalare Datentypen sind Integer, Real, Boolean, Character, Subrange und Enumerated. Strukturierte Datentypen bestehen aus den Skalartypen. Zum Beispiel Arrays, Datensätze, Dateien und Sets. Wir werden die Zeigerdatentypen später diskutieren.

Pascal-Datentypen

Pascal-Datentypen können im folgenden Diagramm wie folgt zusammengefasst werden:

Typdeklarationen

Die Typdeklaration wird verwendet, um den Datentyp eines Bezeichners zu deklarieren. Die Syntax der Typdeklaration lautet -

type-identifier-1, type-identfier-2 = type-specifier;

In der folgenden Deklaration werden beispielsweise die Variablen Tage und Alter als Ganzzahltyp definiert, Ja und Wahr als Boolescher Typ, Name und Stadt als Zeichenfolgentyp, Gebühren und Ausgaben als Realtyp.

type
days, age = integer;
yes, true = boolean;
name, city = string;
fees, expenses = real;

Ganzzahlige Typen

Die folgende Tabelle enthält Details zu Standard-Integer-Typen mit ihren in Object Pascal verwendeten Speichergrößen und Wertebereichen -

Art	Minimum	Maximal	Format
Ganze Zahl	-2147483648	2147483647	signiert 32-Bit
Kardinal	0	4294967295	vorzeichenloses 32-Bit
Shortint	-128	127	8-Bit signiert
Smallint	-32768	32767	16-Bit signiert
Longint	-2147483648	2147483647	signiert 32-Bit
Int64	-2 ^ 63	2 ^ 63 - 1	signiert 64-Bit
Byte	0	255	vorzeichenloses 8-Bit
Wort	0	65535	vorzeichenloses 16-Bit
Langwort	0	4294967295	vorzeichenloses 32-Bit

Konstanten

Die Verwendung von Konstanten macht ein Programm besser lesbar und hilft, spezielle Mengen am Anfang des Programms an einer Stelle zu halten. Pascal erlaubt numerische, logische, String- und Zeichenkonstanten . Konstanten können im Deklarationsteil des Programms durch Angabe von deklariert werdenconst Erklärung.

Die Syntax der konstanten Typdeklaration lautet wie folgt:

const
Identifier = contant_value;

Es folgen einige Beispiele für konstante Deklarationen -

VELOCITY_LIGHT = 3.0E=10;
PIE = 3.141592;
NAME = 'Stuart Little';
CHOICE = yes;
OPERATOR = '+';

Alle konstanten Deklarationen müssen vor der Variablendeklaration angegeben werden.

Aufzählungsarten

Aufzählungsdatentypen sind benutzerdefinierte Datentypen. Sie ermöglichen die Angabe von Werten in einer Liste. Für den aufgezählten Datentyp sind nur Zuweisungsoperatoren und Vergleichsoperatoren zulässig. Aufgezählte Datentypen können wie folgt deklariert werden:

type
enum-identifier = (item1, item2, item3, ... )

Im Folgenden finden Sie einige Beispiele für aufgezählte Typdeklarationen.

type
SUMMER = (April, May, June, July, September);
COLORS = (Red, Green, Blue, Yellow, Magenta, Cyan, Black, White);
TRANSPORT = (Bus, Train, Airplane, Ship);

Die Reihenfolge, in der die Elemente in der Domäne eines Aufzählungstyps aufgeführt sind, definiert die Reihenfolge der Elemente. Beispielsweise kommt im aufgezählten Typ SOMMER April vor Mai, Mai vor Juni und so weiter. Die Domäne der aufgezählten Typbezeichner darf nicht aus numerischen oder Zeichenkonstanten bestehen.

Unterbereichstypen

Mit Unterbereichstypen kann eine Variable Werte annehmen, die innerhalb eines bestimmten Bereichs liegen. Wenn beispielsweise das Alter der Wähler zwischen 18 und 100 Jahren liegen sollte, könnte eine Variable namens Alter wie folgt deklariert werden:

var
age: 18 ... 100;

Wir werden uns die Variablendeklaration im nächsten Abschnitt genauer ansehen. Sie können einen Unterbereichstyp auch mithilfe der Typdeklaration definieren. Die Syntax zum Deklarieren eines Unterbereichstyps lautet wie folgt:

type
subrange-identifier = lower-limit ... upper-limit;

Im Folgenden finden Sie einige Beispiele für Deklarationen von Subbereichstypen.

const
P = 18;
Q = 90;
type
Number = 1 ... 100;
Value = P ... Q;

Unterbereichstypen können aus einer Teilmenge eines bereits definierten Aufzählungstyps erstellt werden. Beispiel:

type
months = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
Summer = Apr ... Aug;
Winter = Oct ... Dec;

Eine Variable ist nichts anderes als ein Name für einen Speicherbereich, den unsere Programme bearbeiten können. Jede Variable in Pascal hat einen bestimmten Typ, der die Größe und das Layout des Speichers der Variablen bestimmt. den Wertebereich, der in diesem Speicher gespeichert werden kann; und die Menge von Operationen, die auf die Variable angewendet werden können.

Der Name einer Variablen kann aus Buchstaben, Ziffern und dem Unterstrich bestehen. Es muss entweder mit einem Buchstaben oder einem Unterstrich beginnen. Pascal istnot case-sensitiveDaher bedeuten Groß- und Kleinbuchstaben hier dasselbe. Basierend auf den im vorherigen Kapitel erläuterten Grundtypen gibt es folgende grundlegende Variablentypen:

Grundvariablen in Pascal

Sr.Nr.	Typ & Beschreibung
1	Character Normalerweise ein einzelnes Oktett (ein Byte). Dies ist ein ganzzahliger Typ.
2	Integer Die natürlichste Ganzzahlgröße für die Maschine.
3	Real Ein Gleitkommawert mit einfacher Genauigkeit.
4	Boolean Gibt wahre oder falsche logische Werte an. Dies ist auch ein ganzzahliger Typ.
5	Enumerated Gibt eine benutzerdefinierte Liste an.
6	Subrange Stellt Variablen dar, deren Werte innerhalb eines Bereichs liegen.
7	String Speichert eine Reihe von Zeichen.

Die Programmiersprache Pascal ermöglicht auch das Definieren verschiedener anderer Variablentypen, die in den folgenden Kapiteln behandelt werden, z. B. Zeiger, Array, Datensätze, Sätze und Dateien usw. In diesem Kapitel werden nur grundlegende Variablentypen untersucht.

Variable Deklaration in Pascal

Alle Variablen müssen deklariert werden, bevor wir sie im Pascal-Programm verwenden. Auf alle Variablendeklarationen folgt das Schlüsselwort var . Eine Deklaration gibt eine Liste von Variablen an, gefolgt von einem Doppelpunkt (:) und dem Typ. Die Syntax der Variablendeklaration lautet -

var
variable_list : type;

Hier muss type ein gültiger Pascal-Datentyp sein, einschließlich Zeichen, Ganzzahl, Real, Boolescher Wert oder eines benutzerdefinierten Datentyps usw., und variable_list kann aus einem oder mehreren durch Kommas getrennten Bezeichnernamen bestehen. Einige gültige Variablendeklarationen werden hier angezeigt -

var
age, weekdays : integer;
taxrate, net_income: real;
choice, isready: boolean;
initials, grade: char;
name, surname : string;

Im vorherigen Tutorial haben wir besprochen, dass Pascal das Deklarieren eines Typs erlaubt. Ein Typ kann durch einen Namen oder eine Kennung identifiziert werden. Dieser Typ kann verwendet werden, um Variablen dieses Typs zu definieren. Zum Beispiel,

type
days, age = integer;
yes, true = boolean;
name, city = string;
fees, expenses = real;

Jetzt können die so definierten Typen in Variablendeklarationen verwendet werden -

var
weekdays, holidays : days;
choice: yes;
student_name, emp_name : name;
capital: city;
cost: expenses;

Bitte beachten Sie den Unterschied zwischen Typ - Deklaration und var - Deklaration. Die Typdeklaration gibt die Kategorie oder Klasse der Typen wie Ganzzahl, Real usw. an, während die Variablenspezifikation den Wertetyp angibt, den eine Variable annehmen kann. Sie können vergleichen Typ Deklaration in Pascal mit typedef in C. Am wichtigsten ist , der Variablenname bezieht sich auf den Speicherplatz in dem der Wert der Variablen wird gespeichert werden. Dies ist bei der Typdeklaration nicht der Fall.

Variable Initialisierung in Pascal

Variablen wird ein Wert mit einem Doppelpunkt und dem Gleichheitszeichen zugewiesen, gefolgt von einem konstanten Ausdruck. Die allgemeine Form der Wertzuweisung lautet -

variable_name := value;

Standardmäßig werden Variablen in Pascal nicht mit Null initialisiert. Sie können Müllwerte enthalten. Es ist daher besser, Variablen in einem Programm zu initialisieren. Variablen können in ihrer Deklaration initialisiert (mit einem Anfangswert versehen) werden. Der Initialisierung folgt dasvar Schlüsselwort und die Syntax der Initialisierung lautet wie folgt:

var
variable_name : type = value;

Einige Beispiele sind -

age: integer = 15;
taxrate: real = 0.5;
grade: char = 'A';
name: string = 'John Smith';

Schauen wir uns ein Beispiel an, das verschiedene Arten von Variablen verwendet, die bisher diskutiert wurden -

program Greetings;
const
message = ' Welcome to the world of Pascal ';

type
name = string;
var
firstname, surname: name;

begin
   writeln('Please enter your first name: ');
   readln(firstname);
   
   writeln('Please enter your surname: ');
   readln(surname);
   
   writeln;
   writeln(message, ' ', firstname, ' ', surname);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Please enter your first name:
John
Please enter your surname:
Smith
Welcome to the world of Pascal John Smith

Aufgezählte Variablen

Sie haben gesehen, wie einfache Variablentypen wie Integer, Real und Boolean verwendet werden. Lassen Sie uns nun Variablen vom Aufzählungstyp sehen, die definiert werden können als -

var
var1, var2, ...  : enum-identifier;

Wenn Sie einen Aufzählungstyp deklariert haben, können Sie Variablen dieses Typs deklarieren. Zum Beispiel,

type
months = (January, February, March, April, May, June, July, August, September, October, November, December);
Var
m: months;
...
M := January;

Das folgende Beispiel veranschaulicht das Konzept -

program exEnumeration;
type
beverage = (coffee, tea, milk, water, coke, limejuice);

var
drink:beverage;

begin
   writeln('Which drink do you want?');
   drink := limejuice;
   
   writeln('You can drink ', drink);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Which drink do you want?
You can drink limejuice

Variablen unterordnen

Unterbereichsvariablen werden als - deklariert

var
subrange-name : lowerlim ... uperlim;

Beispiele für Unterbereichsvariablen sind -

var
marks: 1 ... 100;
grade: 'A' ... 'E';
age: 1 ... 25;

Das folgende Programm veranschaulicht das Konzept -

program exSubrange;
var
marks: 1 .. 100;
grade: 'A' .. 'E';

begin
   writeln( 'Enter your marks(1 - 100): ');
   readln(marks);
   
   writeln( 'Enter your grade(A - E): ');
   readln(grade);
   
   writeln('Marks: ' , marks, ' Grade: ', grade);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Enter your marks(1 - 100): 
100
Enter your grade(A - E):
A
Marks: 100 Grade: A

Eine Konstante ist eine Entität, die während der Programmausführung unverändert bleibt. Mit Pascal können nur Konstanten der folgenden Typen deklariert werden:

• Ordinaltypen
• Typen einstellen
• Zeigertypen (aber der einzige zulässige Wert ist Null).
• Echte Typen
• Char
• String

Konstanten deklarieren

Die Syntax zum Deklarieren von Konstanten lautet wie folgt:

const
identifier = constant_value;

Die folgende Tabelle enthält Beispiele für einige gültige Konstantendeklarationen.

Real type constant

Sr.Nr.	Konstanter Typ & Beispiele
1	Ordinal(Integer)type constant valid_age = 21;
2	Set type constant Vokale = Menge von (A, E, I, O, U);
3	Pointer type constant P = NIL;
4	e = 2,7182818; Velocity_light = 3.0E + 10;
5	Character type constant Operator = '+';
6	String type constant Präsident = 'Johnny Depp';

Das folgende Beispiel veranschaulicht das Konzept -

program const_circle (input,output);
const
PI = 3.141592654;

var
r, d, c : real;   {variable declaration: radius, dia, circumference}

begin
   writeln('Enter the radius of the circle');
   readln(r);
   
   d := 2 * r;
   c :=  PI * d;
   writeln('The circumference of the circle is ',c:7:2);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Enter the radius of the circle
23
The circumference of the circle is 144.51

Beachten Sie die Formatierung in der Ausgabeanweisung des Programms. Die Variable c ist mit der Gesamtzahl der Ziffern 7 und 2 nach dem Dezimalzeichen zu formatieren. Pascal erlaubt eine solche Ausgabeformatierung mit den numerischen Variablen.

Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. Pascal erlaubt die folgenden Arten von Operatoren:

• Rechenzeichen
• Vergleichsoperatoren
• boolesche Operatoren
• Bitoperatoren
• Operatoren festlegen
• String-Operatoren

Lassen Sie uns die arithmetischen, relationalen, booleschen und Bitoperatoren einzeln diskutieren. Wir werden die Set-Operatoren und String-Operationen später diskutieren.

Rechenzeichen

Die folgende Tabelle zeigt alle von Pascal unterstützten arithmetischen Operatoren. Variable annehmenA hält 10 und variabel B hält 20, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
+	Fügt zwei Operanden hinzu	A + B ergibt 30
- -	Subtrahiert den zweiten Operanden vom ersten	A - B ergibt -10
* *	Multipliziert beide Operanden	A * B ergibt 200
/.	Teilt den Zähler durch den Nenner	B / A ergibt 2
%.	Modul Operator und Rest nach einer ganzzahligen Division	B% A ergibt 0

Vergleichsoperatoren

Die folgende Tabelle zeigt alle von Pascal unterstützten Vergleichsoperatoren. Variable annehmenA hält 10 und variabel B hält 20, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
=	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr.	(A = B) ist nicht wahr.
<>	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(A B) ist wahr.
>	Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A> B) ist nicht wahr.
<	Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A <B) ist wahr.
> =	Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A> = B) ist nicht wahr.
<=	Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A <= B) ist wahr.

Boolesche Operatoren

Die folgende Tabelle zeigt alle von der Pascal-Sprache unterstützten Booleschen Operatoren. Alle diese Operatoren arbeiten mit booleschen Operanden und erzeugen boolesche Ergebnisse. Variable annehmenA gilt wahr und variabel B hält falsch, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
und	Wird als boolescher AND-Operator bezeichnet. Wenn beide Operanden wahr sind, wird die Bedingung wahr.	(A und B) ist falsch.
und dann	Es ähnelt dem AND-Operator, garantiert jedoch die Reihenfolge, in der der Compiler den logischen Ausdruck auswertet. Links nach rechts und die rechten Operanden werden nur bei Bedarf ausgewertet.	(A und dann B) ist falsch.
oder	Wird als boolescher ODER-Operator bezeichnet. Wenn einer der beiden Operanden wahr ist, wird die Bedingung wahr.	(A oder B) ist wahr.
oder aber	Es ähnelt dem Booleschen ODER, garantiert jedoch die Reihenfolge, in der der Compiler den logischen Ausdruck auswertet. Links nach rechts und die rechten Operanden werden nur bei Bedarf ausgewertet.	(A oder B) ist wahr.
nicht	Wird als boolescher NOT-Operator bezeichnet. Wird verwendet, um den logischen Zustand seines Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT sie falsch.	nicht (A und B) ist wahr.

Bitoperatoren

Bitweise Operatoren arbeiten an Bits und führen eine bitweise Operation durch. Alle diese Operatoren arbeiten mit ganzzahligen Operanden und erzeugen ganzzahlige Ergebnisse. Die Wahrheitstabelle für bitweise und (&), bitweise oder (|) und bitweise nicht (~) lautet wie folgt:

p	q	p & q	p | q	~ p	~ q
0	0	0	0	1	1
0	1	0	1	1	0
1	1	1	1	0	0
1	0	0	1	0	1

Angenommen, A = 60; und B = 13; jetzt im Binärformat werden sie wie folgt sein -

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A ^ B = 0011 0001

~ A = 1100 0011

Die von Pascal unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt. Angenommen, Variable A hält 60 und Variable B hält 13, dann:

Beispiele anzeigen

Operator	Beschreibung	Beispiel
&	Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist.	(A & B) ergibt 12, was 0000 1100 ist
|	Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist.	(A | B) ergibt 61, was 0011 1101 ist
!	Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist. Es ist dasselbe wie | Operator.	(A! B) ergibt 61, was 0011 1101 ist
~	Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits.	(~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist.
<<	Binärer Linksschaltoperator. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben.	Ein << 2 ergibt 240, was 1111 0000 ist
>>	Binärer Rechtsschieber. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach rechts verschoben.	Eine >> 2 ergibt 15, was 0000 1111 ist

Bitte beachten Sie, dass sich verschiedene Implementierungen von Pascal in bitweisen Operatoren unterscheiden. Free Pascal, der hier verwendete Compiler, unterstützt jedoch die folgenden bitweisen Operatoren:

Betreiber	Operationen
nicht	Bitweise NICHT
und	Bitweises UND
oder	Bitweises ODER
xor	Bitweises exklusives ODER
shl	Bitweise nach links verschieben
shr	Bitweise nach rechts verschieben
<<	Bitweise nach links verschieben
>>	Bitweise nach rechts verschieben

Vorrang der Operatoren in Pascal

Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator.

Zum Beispiel x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat. Daher wird er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert.

Hier werden Operatoren mit der höchsten Priorität oben in der Tabelle angezeigt, Operatoren mit der niedrigsten Priorität unten. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.

Beispiele anzeigen

Operator	Vorrang
~ nicht	Höchste
*, /, div, mod und, &
|,!, +, - oder,
=, <>, <, <=,>,> =, in
oder sonst und dann	Am niedrigsten

Entscheidungsstrukturen erfordern, dass der Programmierer eine oder mehrere Bedingungen angibt, die vom Programm bewertet oder getestet werden sollen, zusammen mit einer Anweisung oder Anweisungen, die ausgeführt werden sollen, wenn die Bedingung als wahr bestimmt wird, und optional anderen Anweisungen, die ausgeführt werden sollen, wenn die Bedingung ausgeführt wird wird als falsch bestimmt.

Es folgt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist:

Die Programmiersprache Pascal bietet die folgenden Arten von Entscheidungsaussagen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Aussage & Beschreibung
1	if - dann Aussage Ein if - then statement besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
2	Wenn-dann-sonst-Anweisung Ein if - then statement kann von einem optionalen gefolgt werden else statement, wird ausgeführt, wenn der boolesche Ausdruck false ist.
3	verschachtelte if-Anweisungen Sie können eine verwenden if oder else if Aussage in einem anderen if oder else if Aussage (n).
4	case Anweisung EIN case Mit der Anweisung kann eine Variable auf Gleichheit mit einer Liste von Werten getestet werden.
5	case - else-Anweisung Es ist ähnlich wie beim if-then-else Erklärung. Hier einelse Begriff folgt dem case statement.
6	verschachtelte case-Anweisungen Sie können eine verwenden case Aussage in einem anderen case Aussage (n).

Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.

Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.

Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Im Folgenden wird die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen beschrieben:

Die Programmiersprache Pascal bietet die folgenden Arten von Schleifenkonstrukten, um die Schleifenanforderungen zu erfüllen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Schleifentyp & Beschreibung
1	while-do-Schleife Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird.
2	For-Do-Schleife Führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet.
3	Wiederholungsschleife Wie eine while-Anweisung, nur dass sie die Bedingung am Ende des Schleifenkörpers testet.
4	verschachtelte Schleifen Sie können eine oder mehrere Schleifen in einer anderen verwenden, während oder bis zur Schleife wiederholen.

Schleifensteuerungsanweisungen

Schleifensteueranweisungen ändern die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört.

Pascal unterstützt die folgenden Steueranweisungen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Steueranweisung & Beschreibung
1	break-Anweisung Beendet die loop oder case Anweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleifen- oder case-Anweisung.
2	Aussage fortsetzen Bewirkt, dass die Schleife den Rest ihres Körpers überspringt und ihren Zustand sofort erneut testet, bevor sie wiederholt wird.
3	gehe zu Aussage Überträgt die Kontrolle auf die beschriftete Anweisung. Es wird jedoch nicht empfohlen, die goto-Anweisung in Ihrem Programm zu verwenden.

Unterprogramme

Ein Unterprogramm ist eine Programmeinheit / ein Modul, die eine bestimmte Aufgabe ausführt. Diese Unterprogramme werden zu größeren Programmen zusammengefasst. Dies wird im Grunde als "modularer Aufbau" bezeichnet. Ein Unterprogramm kann von einem Unterprogramm / Programm aufgerufen werden, das als aufrufendes Programm bezeichnet wird.

Pascal bietet zwei Arten von Unterprogrammen -

• Functions - Diese Unterprogramme geben einen einzelnen Wert zurück.

• Procedures - Diese Unterprogramme geben keinen Wert direkt zurück.

Funktionen

EIN functionist eine Gruppe von Anweisungen, die zusammen eine Aufgabe ausführen. Jedes Pascal-Programm hat mindestens eine Funktion, nämlich das Programm selbst, und alle trivialsten Programme können zusätzliche Funktionen definieren.

Eine Funktion declarationinformiert den Compiler über den Namen, den Rückgabetyp und die Parameter einer Funktion. Eine Funktiondefinition liefert den eigentlichen Körper der Funktion.

Die Pascal-Standardbibliothek bietet zahlreiche integrierte Funktionen, die Ihr Programm aufrufen kann. Zum Beispiel FunktionAppendStr() Hängt zwei Zeichenfolgen an, Funktion New() Ordnet Variablen und vielen weiteren Funktionen dynamisch Speicher zu.

Funktion definieren

In Pascal, a functionwird mit dem Funktionsschlüsselwort definiert. Die allgemeine Form einer Funktionsdefinition lautet wie folgt:

function name(argument(s): type1; argument(s): type2; ...): function_type;
local declarations;

begin
   ...
   < statements >
   ...
   name:= expression;
end;

Eine Funktionsdefinition in Pascal besteht aus einer Funktion header, lokal declarations und eine Funktion body. Der Funktionsheader besteht aus der Schlüsselwortfunktion und anameder Funktion gegeben. Hier sind alle Teile einer Funktion -

• Arguments- Die Argumente stellen die Verknüpfung zwischen dem aufrufenden Programm und den Funktionskennungen her und rufen auch die formalen Parameter auf. Ein Parameter ist wie ein Platzhalter. Wenn eine Funktion aufgerufen wird, übergeben Sie einen Wert an den Parameter. Dieser Wert wird als tatsächlicher Parameter oder Argument bezeichnet. Die Parameterliste bezieht sich auf den Typ, die Reihenfolge und die Anzahl der Parameter einer Funktion. Die Verwendung solcher formalen Parameter ist optional. Diese Parameter können einen Standarddatentyp, einen benutzerdefinierten Datentyp oder einen Unterbereichsdatentyp haben.

  Die Liste der formalen Parameter in der Funktionsanweisung kann aus einfachen oder tiefgestellten Variablen, Arrays oder strukturierten Variablen oder Unterprogrammen bestehen.

• Return Type- Alle Funktionen müssen einen Wert zurückgeben, daher muss allen Funktionen ein Typ zugewiesen werden. Dasfunction-typeist der Datentyp des Werts, den die Funktion zurückgibt. Es kann sich um einen standardmäßigen, benutzerdefinierten Skalar- oder Unterbereichstyp handeln, es kann sich jedoch nicht um einen strukturierten Typ handeln.

• Local declarations - Lokale Deklarationen beziehen sich auf die Deklarationen für Bezeichnungen, Konstanten, Variablen, Funktionen und Prozeduren, die nur für den Funktionskörper gelten.

• Function Body- Der Funktionskörper enthält eine Sammlung von Anweisungen, die definieren, was die Funktion tut. Es sollte immer zwischen den reservierten Wörtern Anfang und Ende stehen. Es ist der Teil einer Funktion, in dem alle Berechnungen durchgeführt werden. Es muss eine Zuweisungsanweisung vom Typ -name := expression;im Funktionskörper, der dem Funktionsnamen einen Wert zuweist. Dieser Wert wird zurückgegeben, wenn die Funktion ausgeführt wird. Die letzte Anweisung im Body muss eine Endanweisung sein.

Das folgende Beispiel zeigt, wie eine Funktion in pascal definiert wird -

(* function returning the max between two numbers *)
function max(num1, num2: integer): integer;

var
   (* local variable declaration *)
   result: integer;

begin
   if (num1 > num2) then
      result := num1
   
   else
      result := num2;
   max := result;
end;

Funktionserklärungen

Eine Funktion declarationinformiert den Compiler über einen Funktionsnamen und wie die Funktion aufgerufen wird. Der eigentliche Funktionskörper kann separat definiert werden.

Eine Funktionsdeklaration besteht aus folgenden Teilen:

function name(argument(s): type1; argument(s): type2; ...): function_type;

Für die oben definierte Funktion max () folgt die Funktionsdeklaration -

function max(num1, num2: integer): integer;

Eine Funktionsdeklaration ist erforderlich, wenn Sie eine Funktion in einer Quelldatei definieren und diese Funktion in einer anderen Datei aufrufen. In diesem Fall sollten Sie die Funktion oben in der Datei deklarieren, die die Funktion aufruft.

Eine Funktion aufrufen

Beim Erstellen einer Funktion definieren Sie, was die Funktion zu tun hat. Um eine Funktion zu verwenden, müssen Sie diese Funktion aufrufen, um die definierte Aufgabe auszuführen. Wenn ein Programm eine Funktion aufruft, wird die Programmsteuerung auf die aufgerufene Funktion übertragen. Eine aufgerufene Funktion führt eine definierte Aufgabe aus. Wenn ihre return-Anweisung ausgeführt wird oder wenn ihre letzte end-Anweisung erreicht ist, gibt sie die Programmsteuerung an das Hauptprogramm zurück.

Um eine Funktion aufzurufen, müssen Sie lediglich die erforderlichen Parameter zusammen mit dem Funktionsnamen übergeben. Wenn die Funktion einen Wert zurückgibt, können Sie den zurückgegebenen Wert speichern. Das Folgende ist ein einfaches Beispiel, um die Verwendung zu zeigen -

program exFunction;
var
   a, b, ret : integer;

(*function definition *)
function max(num1, num2: integer): integer;
var
   (* local variable declaration *)
   result: integer;

begin
   if (num1 > num2) then
      result := num1
   
   else
      result := num2;
   max := result;
end;

begin
   a := 100;
   b := 200;
   (* calling a function to get max value *)
   ret := max(a, b);
   
   writeln( 'Max value is : ', ret );
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Max value is : 200

Procedures sind Unterprogramme, die es ermöglichen, eine Gruppe von Ergebnissen zu erhalten, anstatt einen einzelnen Wert zurückzugeben.

Prozedur definieren

In Pascal wird eine Prozedur mit dem definiert procedureStichwort. Die allgemeine Form einer Prozedurdefinition lautet wie folgt:

procedure name(argument(s): type1, argument(s): type 2, ... );
   < local declarations >
begin
   < procedure body >
end;

Eine Prozedur definition in Pascal besteht aus a header, lokal declarations und ein bodydes Verfahrens. Der Prozedurheader besteht aus dem Schlüsselwortprocedureund einen Namen für die Prozedur. Hier sind alle Teile einer Prozedur -

• Arguments- Die Argumente stellen die Verknüpfung zwischen dem aufrufenden Programm und den Prozedurkennungen her und rufen auch die formalen Parameter auf. Die Regeln für Argumente in Prozeduren sind dieselben wie für die Funktionen.

• Local declarations - Lokale Deklarationen beziehen sich auf die Deklarationen für Bezeichnungen, Konstanten, Variablen, Funktionen und Prozeduren, die nur für den Hauptteil der Prozedur gelten.

• Procedure Body- Der Prozedurkörper enthält eine Sammlung von Anweisungen, die definieren, was die Prozedur tut. Es sollte immer zwischen den reservierten Wörtern Anfang und Ende stehen. Es ist der Teil einer Prozedur, in dem alle Berechnungen durchgeführt werden.

Es folgt der Quellcode für eine Prozedur namens findMin () . Diese Prozedur verwendet 4 Parameter x, y, z und m und speichert das Minimum unter den ersten drei Variablen in der Variablen mit dem Namen m. Die Variable m wird übergebenreference (Wir werden die Übergabe von Argumenten etwas später durch Bezugnahme diskutieren) -

procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m := x
   else
      m := y;
   
   if z <m then
      m := z;
end; { end of procedure findMin }

Verfahrenserklärungen

Eine Prozedur declarationinformiert den Compiler über einen Prozedurnamen und wie die Prozedur aufgerufen wird. Der tatsächliche Hauptteil des Verfahrens kann separat definiert werden.

Eine Prozedurdeklaration hat die folgende Syntax:

procedure name(argument(s): type1, argument(s): type 2, ... );

Bitte beachten Sie, dass die name of the procedure is not associated with any type. Für die oben definierte Prozedur findMin () folgt die Deklaration -

procedure findMin(x, y, z: integer; var m: integer);

Prozedur aufrufen

Beim Erstellen einer Prozedur definieren Sie, was die Prozedur zu tun hat. Um die Prozedur zu verwenden, müssen Sie diese Prozedur aufrufen, um die definierte Aufgabe auszuführen. Wenn ein Programm eine Prozedur aufruft, wird die Programmsteuerung auf die aufgerufene Prozedur übertragen. Eine aufgerufene Prozedur führt die definierte Aufgabe aus und gibt die Steuerung an das aufrufende Programm zurück, wenn ihre letzte end-Anweisung erreicht ist.

Um eine Prozedur aufzurufen, müssen Sie lediglich die erforderlichen Parameter zusammen mit dem Prozedurnamen übergeben, wie unten gezeigt -

program exProcedure;
var
   a, b, c,  min: integer;
procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m:= x
   else
      m:= y;
   
   if z < m then
      m:= z;
end; { end of procedure findMin }  

begin
   writeln(' Enter three numbers: ');
   readln( a, b, c);
   findMin(a, b, c, min); (* Procedure call *)
   
   writeln(' Minimum: ', min);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Enter three numbers:
89 45 67
Minimum: 45

Rekursive Unterprogramme

Wir haben gesehen, dass ein Programm oder Unterprogramm ein anderes Unterprogramm aufrufen kann. Wenn sich ein Unterprogramm selbst aufruft, wird es als rekursiver Aufruf bezeichnet, und der Prozess wird als Rekursion bezeichnet.

Um das Konzept zu veranschaulichen, berechnen wir die Fakultät einer Zahl. Faktor einer Zahl n ist definiert als -

n! = n*(n-1)!
   = n*(n-1)*(n-2)!
      ...
   = n*(n-1)*(n-2)*(n-3)... 1

Das folgende Programm berechnet die Fakultät einer bestimmten Zahl, indem es sich selbst rekursiv aufruft.

program exRecursion;
var
   num, f: integer;
function fact(x: integer): integer; (* calculates factorial of x - x! *)

begin
   if x=0 then
      fact := 1
   else
      fact := x * fact(x-1); (* recursive call *)
end; { end of function fact}

begin
   writeln(' Enter a number: ');
   readln(num);
   f := fact(num);
   
   writeln(' Factorial ', num, ' is: ' , f);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Enter a number:
5
Factorial 5 is: 120

Es folgt ein weiteres Beispiel, das das generiert Fibonacci Series für eine gegebene Zahl mit a recursive Funktion -

program recursiveFibonacci;
var
   i: integer;
function fibonacci(n: integer): integer;

begin
   if n=1 then
      fibonacci := 0
   
   else if n=2 then
      fibonacci := 1
   
   else
      fibonacci := fibonacci(n-1) + fibonacci(n-2);
end; 

begin
   for i:= 1 to 10 do
   
   write(fibonacci (i), '  ');
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

0 1 1 2	3 5 8 13 21 34

Argumente eines Unterprogramms

Wenn ein Unterprogramm (function or procedure) Um Argumente zu verwenden, muss es Variablen deklarieren, die die Werte der Argumente akzeptieren. Diese Variablen werden als bezeichnetformal parameters des Unterprogramms.

Die formalen Parameter verhalten sich wie andere lokale Variablen innerhalb des Unterprogramms und werden beim Eintritt in das Unterprogramm erstellt und beim Beenden zerstört.

Beim Aufrufen eines Unterprogramms gibt es zwei Möglichkeiten, wie Argumente an das Unterprogramm übergeben werden können:

Sr.Nr.	Anruftyp & Beschreibung
1	Call by value Diese Methode kopiert den tatsächlichen Wert eines Arguments in den formalen Parameter des Unterprogramms. In diesem Fall haben Änderungen am Parameter im Unterprogramm keine Auswirkung auf das Argument.
2	Rufen Sie als Referenz an Diese Methode kopiert die Adresse eines Arguments in den formalen Parameter. Innerhalb des Unterprogramms wird die Adresse verwendet, um auf das tatsächliche Argument zuzugreifen, das im Aufruf verwendet wird. Dies bedeutet, dass Änderungen am Parameter das Argument beeinflussen.

Standardmäßig verwendet Pascal call by valueArgumente übergeben. Im Allgemeinen bedeutet dies, dass Code in einem Unterprogramm die zum Aufrufen des Unterprogramms verwendeten Argumente nicht ändern kann. Das Beispielprogramm, das wir im Kapitel 'Pascal - Funktionen' verwendet haben, hat die Funktion max () using verwendetcall by value.

Während das hier bereitgestellte Beispielprogramm ( exProcedure ) die Prozedur findMin () mit aufruftcall by reference.

Ein Bereich in jeder Programmierung ist ein Bereich des Programms, in dem eine definierte Variable vorhanden sein kann und auf den darüber hinaus nicht zugegriffen werden kann. Es gibt drei Stellen, an denen Variablen in der Programmiersprache Pascal deklariert werden können:

• Innerhalb eines Unterprogramms oder eines Blocks, der als lokale Variablen bezeichnet wird

• Außerhalb aller Unterprogramme, die als globale Variablen bezeichnet werden

• Bei der Definition von Unterprogrammparametern werden die formalen Parameter genannt

Lassen Sie uns erklären, was sind local und global Variablen und formale Parameter.

Lokale Variablen

Variablen, die in einem Unterprogramm oder Block deklariert sind, werden als lokale Variablen bezeichnet. Sie können nur von Anweisungen verwendet werden, die sich in diesem Unterprogramm oder Codeblock befinden. Lokale Variablen sind Unterprogrammen außerhalb ihrer eigenen nicht bekannt. Es folgt das Beispiel mit lokalen Variablen. Hier sind alle Variablen a , b und c lokal für das Programm mit dem Namen exLocal .

program exLocal; 
var
   a, b, c: integer;

begin
   (* actual initialization *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

value of a = 10 b = 20 c = 30

Lassen Sie uns nun das Programm etwas erweitern, eine Prozedur mit dem Namen display erstellen, die über einen eigenen Satz von Variablen a , b und c verfügt und deren Werte direkt aus dem Programm exLocal anzeigt .

program exLocal;
var
   a, b, c: integer;
procedure display;

var
   a, b, c: integer;
begin
   (* local variables *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln('Winthin the procedure display');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
end;

begin
   a:= 100;
   b:= 200;
   c:= a + b;
   
   writeln('Winthin the program exlocal');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   display();
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
value of a = 10 b = 20 c = 30

Globale Variablen

Globale Variablen werden außerhalb einer Funktion definiert, normalerweise über dem Programm. Die globalen Variablen behalten ihren Wert während der gesamten Lebensdauer Ihres Programms und können in allen für das Programm definierten Funktionen aufgerufen werden.

EIN globalAuf die Variable kann von jeder Funktion zugegriffen werden. Das heißt, eine globale Variable kann nach ihrer Deklaration im gesamten Programm verwendet werden. Es folgt ein Beispiel mitglobal und local Variablen -

program exGlobal;
var
   a, b, c: integer;
procedure display;
var
   x, y, z: integer;

begin
   (* local variables *)
   x := 10;
   y := 20;
   z := x + y;
   
   (*global variables *)
   a := 30;
   b:= 40;
   c:= a + b;
   
   writeln('Winthin the procedure display');
   writeln(' Displaying the global variables a, b, and c');
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   writeln('Displaying the local variables x, y, and z');
   
   writeln('value of x = ', x , ' y =  ',  y, ' and z = ', z);
end;

begin
   a:= 100;
   b:= 200;
   c:= 300;
   
   writeln('Winthin the program exlocal');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   
   display();
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
Displaying the global variables a, b, and c
value of a = 30 b = 40 c = 70
Displaying the local variables x, y, and z
value of x = 10 y = 20 z = 30

Bitte beachten Sie, dass die Prozeduranzeige Zugriff auf die Variablen a, b und c hat, die globale Variablen in Bezug auf die Anzeige sind, sowie auf ihre eigenen lokalen Variablen. Ein Programm kann für lokale und globale Variablen denselben Namen haben, der Wert der lokalen Variablen innerhalb einer Funktion wird jedoch bevorzugt.

Lassen Sie uns das vorherige Beispiel ein wenig ändern, jetzt haben die lokalen Variablen für die Prozeduranzeige dieselben Namen wie a , b , c -

program exGlobal;
var
   a, b, c: integer;
procedure display;

var
   a, b, c: integer;

begin
   (* local variables *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln('Winthin the procedure display');
   writeln(' Displaying the global variables a, b, and c');
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   writeln('Displaying the local variables a, b, and c');
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
end;

begin
   a:= 100;
   b:= 200;
   c:= 300;
   
   writeln('Winthin the program exlocal');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);   
   
   display();
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
Displaying the global variables a, b, and c
value of a = 10 b = 20 c = 30
Displaying the local variables a, b, and c
value of a = 10 b = 20 c = 30

Die Zeichenfolge in Pascal ist eine Folge von Zeichen mit einer optionalen Größenangabe. Die Zeichen können numerisch, Buchstaben, Leerzeichen, Sonderzeichen oder eine Kombination aus allen sein. Extended Pascal bietet je nach System und Implementierung zahlreiche Arten von Zeichenfolgenobjekten. Wir werden häufigere Arten von Zeichenfolgen diskutieren, die in Programmen verwendet werden.

Sie können eine Zeichenfolge auf viele Arten definieren -

• Character arrays - Dies ist eine Zeichenfolge, bei der es sich um eine Folge von Zeichen mit einer Größe von null oder mehr Byte in einfachen Anführungszeichen handelt.

• String variables - Die Variable vom Typ String, wie in Turbo Pascal definiert.

• Short strings - Die Variable vom Typ String mit Größenangabe.

• Null terminated strings - Die Variable von pchar Art.

• AnsiStrings - Ansistrings sind Zeichenfolgen ohne Längenbeschränkung.

Pascal bietet nur einen Zeichenfolgenoperator, den Zeichenfolgenverkettungsoperator (+).

Beispiele

Das folgende Programm druckt die ersten vier Arten von Zeichenfolgen. Wir werden AnsiStrings im nächsten Beispiel verwenden.

program exString;
var
   greetings: string;
   name: packed array [1..10] of char;
   organisation: string[10];
   message: pchar;

begin
   greetings := 'Hello ';
   message := 'Good Day!';
   
   writeln('Please Enter your Name');
   readln(name);
   
   writeln('Please Enter the name of your Organisation');
   readln(organisation);
   
   writeln(greetings, name, ' from ', organisation);
   writeln(message); 
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Please Enter your Name
John Smith
Please Enter the name of your Organisation
Infotech
Hello John Smith from Infotech

Das folgende Beispiel verwendet einige weitere Funktionen.

program exString;
uses sysutils;
var
   str1, str2, str3 : ansistring;
   str4: string;
   len: integer;

begin
   str1 := 'Hello ';
   str2 := 'There!';
   
   (* copy str1 into str3 *)
   str3 := str1;
   writeln('appendstr( str3, str1) :  ', str3 );
   
   (* concatenates str1 and str2 *)
   appendstr( str1, str2);
   writeln( 'appendstr( str1, str2) ' , str1 );
   str4 := str1 + str2;
   writeln('Now str4 is: ', str4);
   
   (* total lenghth of str4 after concatenation  *)
   len := byte(str4[0]);
   writeln('Length of the final string str4: ', len); 
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

appendstr( str3, str1) : Hello
appendstr( str1, str2) : Hello There!
Now str4 is: Hello There! There!
Length of the final string str4: 18

Pascal String Funktionen und Prozeduren

Pascal unterstützt eine Vielzahl von Funktionen und Prozeduren, mit denen Zeichenfolgen bearbeitet werden. Diese Unterprogramme variieren implementierungsmäßig. Hier listen wir verschiedene Unterprogramme zur Manipulation von Zeichenfolgen auf, die von Free Pascal bereitgestellt werden -

Sr.Nr.	Funktion & Zweck
1	function AnsiCompareStr(const S1: ; const S2:):Integer; Vergleicht zwei Zeichenfolgen
2	function AnsiCompareText(const S1: ; const S2:):Integer; Vergleicht zwei Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung
3	function AnsiExtractQuotedStr(var Src: PChar; Quote: Char):; Entfernt Anführungszeichen aus der Zeichenfolge
4	function AnsiLastChar(const S:):PChar; Ruft das letzte Zeichen der Zeichenfolge ab
5	function AnsiLowerCase(const s:): Konvertiert Zeichenfolge in Kleinbuchstaben
6	function AnsiQuotedStr(const S: ; Quote: Char):; Zitiert eine Zeichenfolge
7	function AnsiStrComp(S1: PChar;S2: PChar):Integer; Vergleicht Zeichenfolgen zwischen Groß- und Kleinschreibung
8	function AnsiStrIComp(S1: PChar; S2: PChar):Integer; Vergleicht Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung
9	function AnsiStrLComp(S1: PChar; S2: PChar; MaxLen: Cardinal):Integer; Vergleicht L-Zeichen von Zeichenfolgen, bei denen zwischen Groß- und Kleinschreibung unterschieden wird
10	function AnsiStrLIComp(S1: PChar; S2: PChar; MaxLen: Cardinal):Integer; Vergleicht L Zeichen von Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung
11	function AnsiStrLastChar(Str: PChar):PChar; Ruft das letzte Zeichen der Zeichenfolge ab
12	function AnsiStrLower(Str: PChar):PChar; Konvertiert Zeichenfolge in Kleinbuchstaben
13	function AnsiStrUpper(Str: PChar):PChar; Konvertiert Zeichenfolge in Großbuchstaben
14	function AnsiUpperCase(const s:):; Konvertiert Zeichenfolge in Großbuchstaben
15	procedure AppendStr(var Dest: ; const S:); Hängt 2 Zeichenfolgen an
16	procedure AssignStr(var P: PString; const S:); Weist den Wert der Zeichenfolgen auf dem Heap zu
17	function CompareStr(const S1: ; const S2:):Integer; overload; Vergleicht zwei Zeichenfolgen, bei denen zwischen Groß- und Kleinschreibung unterschieden wird
18	function CompareText(const S1: ; const S2:):Integer; Vergleicht zwei Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung
19	procedure DisposeStr(S: PString); overload; Entfernt die Zeichenfolge vom Heap
20	procedure DisposeStr(S: PShortString); overload; Entfernt die Zeichenfolge vom Heap
21	function IsValidIdent( const Ident:):Boolean; Ist string eine gültige Pascal-ID?
22	function LastDelimiter(const Delimiters: ; const S:):Integer; Letztes Vorkommen eines Zeichens in einer Zeichenfolge
23	function LeftStr(const S: ; Count: Integer):; Ruft die ersten N Zeichen einer Zeichenfolge ab
24	function LoadStr(Ident: Integer):; Lädt einen String aus Ressourcen
25	function LowerCase(const s: ):; overload; Konvertiert Zeichenfolge in Kleinbuchstaben
26	function LowerCase(const V: variant ):; overload; Konvertiert Zeichenfolge in Kleinbuchstaben
27	function NewStr(const S:):PString; overload; Weist dem Heap eine neue Zeichenfolge zu
28	function RightStr(const S: ; Count: Integer):; Ruft die letzten N Zeichen einer Zeichenfolge ab
29	function StrAlloc(Size: Cardinal):PChar; Ordnet Speicher für Zeichenfolge zu
30	function StrBufSize(Str: PChar):SizeUInt; Reserviert Speicher für eine Zeichenfolge
31	procedure StrDispose(Str: PChar); Entfernt die Zeichenfolge vom Heap
32	function StrPas(Str: PChar):; Konvertiert PChar in Pascal-String
33	function StrPCopy(Dest: PChar; Source:):PChar; Kopiert die Pascal-Zeichenfolge
34	function StrPLCopy(Dest: PChar; Source: ; MaxLen: SizeUInt):PChar; Kopiert N Bytes der Pascal-Zeichenfolge
35	function UpperCase(const s:):; Konvertiert Zeichenfolge in Großbuchstaben

Pascal bietet den Datentyp Boolean, mit dem die Programmierer logische Entitäten wie Konstanten, Variablen, Funktionen und Ausdrücke usw. definieren, speichern und bearbeiten können.

Boolesche Werte sind grundsätzlich ganzzahlige Werte. Boolesche Variablen haben zwei vordefinierte mögliche WerteTrue und False. Die Ausdrücke, die in einen Booleschen Wert aufgelöst werden, können auch einem Booleschen Typ zugewiesen werden.

Free Pascal unterstützt auch die ByteBool, WordBool und LongBoolTypen. Diese sind vom Typ Byte, Word bzw. Longint.

Der Wert False entspricht 0 (Null) und jeder Wert ungleich Null wird bei der Konvertierung in einen Booleschen Wert als True betrachtet. Ein boolescher Wert von True wird in -1 konvertiert, falls er einer Variablen vom Typ LongBool zugewiesen wird.

Es ist zu beachten, dass logische Operatoren and, or und not sind für boolesche Datentypen definiert.

Deklaration von Booleschen Datentypen

Eine Variable vom Typ Boolean wird mit dem Schlüsselwort var deklariert.

var
boolean-identifier: boolean;

zum Beispiel,

var
choice: boolean;

Beispiel

program exBoolean;
var
exit: boolean;

choice: char;
   begin
   writeln('Do you want to continue? ');
   writeln('Enter Y/y for yes, and N/n for no');
   readln(choice);

if(choice = 'n') then
   exit := true
else
   exit := false;

if (exit) then
   writeln(' Good Bye!')
else
   writeln('Please Continue');

readln;
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Do you want to continue?
Enter Y/y for yes, and N/n for no
N
Good Bye!
Y
Please Continue

Die Programmiersprache Pascal bietet eine Datenstruktur namens Array, in der eine sequentielle Sammlung von Elementen desselben Typs mit fester Größe gespeichert werden kann. Ein Array wird zum Speichern einer Sammlung von Daten verwendet. Oft ist es jedoch sinnvoller, sich ein Array als eine Sammlung von Variablen desselben Typs vorzustellen.

Anstatt einzelne Variablen wie Nummer1, Nummer2, ... und Nummer100 zu deklarieren, deklarieren Sie eine Array-Variable wie Zahlen und verwenden Zahlen [1], Zahlen [2] und ..., Zahlen [100] zur Darstellung einzelne Variablen. Auf ein bestimmtes Element in einem Array wird über einen Index zugegriffen.

Alle Arrays bestehen aus zusammenhängenden Speicherstellen. Die niedrigste Adresse entspricht dem ersten Element und die höchste Adresse dem letzten Element.

Beachten Sie, dass Sie, wenn Sie ein Array im C-Stil ab Index 0 möchten, den Index nur mit 0 anstelle von 1 starten müssen.

Arrays deklarieren

Um ein Array in Pascal zu deklarieren, kann ein Programmierer entweder den Typ deklarieren und dann Variablen dieses Arrays erstellen oder die Arrayvariable direkt deklarieren.

Die allgemeine Form der Typdeklaration eines eindimensionalen Arrays ist -

type
   array-identifier = array[index-type] of element-type;

Wo,

• array-identifier - gibt den Namen des Array-Typs an.

• index-type- gibt den Index des Arrays an; Es kann sich um einen beliebigen skalaren Datentyp handeln, außer um real

• element-type - Gibt die Arten von Werten an, die gespeichert werden sollen

Zum Beispiel,

type
   vector = array [ 1..25] of real;
var
   velocity: vector;

Geschwindigkeit ist nun ein variables Array vom Vektortyp, das ausreicht, um bis zu 25 reelle Zahlen aufzunehmen.

Um das Array mit dem Index 0 zu starten, lautet die Deklaration -

type
   vector = array [ 0..24] of real;
var
   velocity: vector;

Arten von Array-Indizes

In Pascal kann ein Array-Index von einem beliebigen Skalartyp wie Integer, Boolean, Enumerated oder Subrange sein, außer real. Array-Indizes können auch negative Werte haben.

Zum Beispiel,

type
   temperature = array [-10 .. 50] of real;
var
   day_temp, night_temp: temperature;

Nehmen wir ein anderes Beispiel, bei dem der Index vom Zeichentyp ist -

type
   ch_array = array[char] of 1..26;
var
   alphabet: ch_array;

Der Index kann vom Aufzählungstyp sein -

type
   color = ( red, black, blue, silver, beige);
   car_color = array of [color] of boolean;
var
   car_body: car_color;

Arrays initialisieren

In Pascal werden Arrays durch Zuweisung initialisiert, entweder durch Angabe eines bestimmten Index oder durch Verwendung einer For-Do-Schleife.

Zum Beispiel -

type
   ch_array = array[char] of 1..26;
var
   alphabet: ch_array;
   c: char;

begin
   ...
   for c:= 'A' to 'Z' do
   alphabet[c] := ord[m];  
   (* the ord() function returns the ordinal values *)

Zugriff auf Array-Elemente

Auf ein Element wird zugegriffen, indem der Arrayname indiziert wird. Dazu wird der Index des Elements in eckige Klammern nach dem Namen des Arrays gesetzt. Zum Beispiel -

a: integer;
a: = alphabet['A'];

Die obige Anweisung nimmt das erste Element aus dem Array mit dem Namen alphabet und weist der Variablen a den Wert zu.

Es folgt ein Beispiel, in dem alle oben genannten drei Konzepte verwendet werden. Deklaration, Zuweisung und Zugriff auf Arrays -

program exArrays;
var
   n: array [1..10] of integer;   (* n is an array of 10 integers *)
   i, j: integer;

begin
   (* initialize elements of array n to 0 *)        
   for i := 1 to 10 do
       n[ i ] := i + 100;   (* set element at location i to i + 100 *)
    (* output each array element's value *)
   
   for j:= 1 to 10 do
      writeln('Element[', j, '] = ', n[j] );
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
Element[10] = 110

Pascal-Arrays im Detail

Arrays sind für Pascal wichtig und sollten viele weitere Details benötigen. Es gibt einige wichtige Konzepte im Zusammenhang mit Arrays, die einem Pascal-Programmierer klar sein sollten:

Sr.Nr.	Konzept & Beschreibung
1	Mehrdimensionale Arrays Pascal unterstützt mehrdimensionale Arrays. Die einfachste Form des mehrdimensionalen Arrays ist das zweidimensionale Array.
2	Dynamisches Array Bei dieser Art von Arrays ist die Anfangslänge Null. Die tatsächliche Länge des Arrays muss mit dem Standard festgelegt werdenSetLength Funktion.
3	Gepacktes Array Diese Arrays sind bitgepackt, dh jedes Zeichen oder jeder Wahrheitswert wird in aufeinanderfolgenden Bytes gespeichert, anstatt eine Speichereinheit zu verwenden, normalerweise ein Wort (4 Bytes oder mehr).
4	Übergeben von Arrays an Unterprogramme Sie können einen Zeiger auf ein Array an ein Unterprogramm übergeben, indem Sie den Namen des Arrays ohne Index angeben.

Zeiger in Pascal sind einfach und machen Spaß zu lernen. Einige Pascal-Programmieraufgaben können einfacher mit Zeigern ausgeführt werden, und andere Aufgaben, wie z. B. die dynamische Speicherzuweisung, können nicht ohne Verwendung von Zeigern ausgeführt werden. Es wird also notwendig, Zeiger zu lernen, um ein perfekter Pascal-Programmierer zu werden. Beginnen wir damit, sie in einfachen Schritten zu lernen.

Wie Sie wissen, ist jede Variable ein Speicherort, und für jeden Speicherort ist eine Adresse definiert, auf die über den Namen der Zeigervariable zugegriffen werden kann, die eine Adresse im Speicher angibt.

Was sind Zeiger?

Ein Zeiger ist eine dynamische Variable, deren Wert die Adresse einer anderen Variablen ist, dh die direkte Adresse des Speicherorts. Wie bei jeder Variablen oder Konstante müssen Sie einen Zeiger deklarieren, bevor Sie ihn zum Speichern einer Variablenadresse verwenden können. Die allgemeine Form einer Zeigervariablendeklaration lautet -

type
   ptr-identifier = ^base-variable-type;

Der Zeigertyp wird definiert, indem dem Aufwärtspfeil des Caret-Symbols (^) der Basistyp vorangestellt wird. Der Basistyp definiert die Typen der Datenelemente. Sobald eine Zeigervariable als von einem bestimmten Typ definiert ist, kann sie nur auf Datenelemente dieses Typs verweisen. Sobald ein Zeigertyp definiert wurde, können wir den verwendenvar Deklaration zum Deklarieren von Zeigervariablen.

var
   p1, p2, ... : ptr-identifier;

Es folgen einige gültige Zeigerdeklarationen -

type
   Rptr = ^real;
   Cptr = ^char;
   Bptr = ^ Boolean;
   Aptr = ^array[1..5] of real;
   date-ptr = ^ date;
      Date = record
         Day: 1..31;
         Month: 1..12;
         Year: 1900..3000;
      End;
var
   a, b : Rptr;
   d: date-ptr;

Die Zeigervariablen werden unter Verwendung des gleichen Caret-Symbols (^) dereferenziert. Beispielsweise ist die zugehörige Variable, auf die durch einen Zeiger rptr verwiesen wird , rptr ^ . Es kann als - zugegriffen werden

rptr^ := 234.56;

Das folgende Beispiel veranschaulicht dieses Konzept -

program exPointers;
var
   number: integer;
   iptr: ^integer;

begin
   number := 100;
   writeln('Number is: ', number);
   
   iptr := @number;
   writeln('iptr points to a value: ', iptr^);
   
   iptr^ := 200;
   writeln('Number is: ', number);
   writeln('iptr points to a value: ', iptr^);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Number is: 100
iptr points to a value: 100
Number is: 200
iptr points to a value: 200

Drucken einer Speicheradresse in Pascal

In Pascal können wir die Adresse einer Variablen mit dem Adressoperator (@) einer Zeigervariable zuweisen. Wir verwenden diesen Zeiger, um das Datenelement zu bearbeiten und darauf zuzugreifen. Wenn wir jedoch aus irgendeinem Grund mit der Speicheradresse selbst arbeiten müssen, müssen wir sie in einer Worttypvariablen speichern.

Erweitern wir das obige Beispiel, um die im Zeiger iptr - gespeicherte Speicheradresse zu drucken.

program exPointers;
var
   number: integer;
   iptr: ^integer;
   y: ^word;

begin
   number := 100;
   writeln('Number is: ', number);
   iptr := @number;
   writeln('iptr points to a value: ', iptr^);
   
   iptr^ := 200;
   writeln('Number is: ', number);
   writeln('iptr points to a value: ', iptr^);
   y := addr(iptr);
   writeln(y^); 
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Number is: 100
iptr points to a value: 100
Number is: 200
iptr points to a value: 200
45504

NIL Zeiger

Es ist immer eine gute Praxis, a zuzuweisen NILWert für eine Zeigervariable, falls Ihnen keine genaue Adresse zugewiesen werden muss. Dies erfolgt zum Zeitpunkt der Variablendeklaration. Ein Zeiger, der zugewiesen istNILzeigt ins Nirgendwo. Betrachten Sie das folgende Programm -

program exPointers;
var
   number: integer;
   iptr: ^integer;
   y: ^word;

begin
   iptr := nil;
   y := addr(iptr);
   
   writeln('the vaule of iptr is ', y^);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

The value of ptr is 0

Um nach a zu suchen nil Zeiger Sie können eine if-Anweisung wie folgt verwenden:

if(ptr <> nill )then     (* succeeds if p is not null *)
if(ptr = nill)then    (* succeeds if p is null *)

Pascal Zeiger im Detail

Zeiger haben viele, aber einfache Konzepte und sind für die Pascal-Programmierung sehr wichtig. Es gibt einige wichtige Zeigerkonzepte, die einem Pascal-Programmierer klar sein sollten:

Sr.Nr.	Konzept & Beschreibung
1	Pascal - Zeigerarithmetik Es gibt vier arithmetische Operatoren, die für Zeiger verwendet werden können: Inkrementieren, Dekrementieren, +, -
2	Pascal - Array von Zeigern Sie können Arrays definieren, die eine Reihe von Zeigern enthalten.
3	Pascal - Zeiger auf Zeiger Mit Pascal können Sie einen Zeiger auf einen Zeiger usw. setzen.
4	Übergeben von Zeigern an Unterprogramme in Pascal Durch Übergeben eines Arguments als Referenz oder als Adresse kann das übergebene Argument im aufrufenden Unterprogramm durch das aufgerufene Unterprogramm geändert werden.
5	Zeiger aus Unterprogrammen in Pascal zurückgeben Mit Pascal kann ein Unterprogramm einen Zeiger zurückgeben.

Mit Pascal-Arrays können Sie Variablentypen definieren, die mehrere Datenelemente derselben Art enthalten können. Ein Datensatz ist jedoch ein weiterer in Pascal verfügbarer benutzerdefinierter Datentyp, mit dem Sie Datenelemente verschiedener Arten kombinieren können.

Datensätze bestehen aus verschiedenen Feldern. Angenommen, Sie möchten Ihre Bücher in einer Bibliothek verfolgen, möchten Sie möglicherweise die folgenden Attribute für jedes Buch verfolgen:

• Title
• Author
• Subject
• Buch-ID

Datensatz definieren

Um einen Datensatztyp zu definieren, können Sie die Typdeklarationsanweisung verwenden. Der Datensatztyp ist definiert als -

type
record-name = record
   field-1: field-type1;
   field-2: field-type2;
   ...
   field-n: field-typen;
end;

Hier ist die Art und Weise, wie Sie den Buchdatensatz deklarieren würden -

type 
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: integer;
end;

Die Datensatzvariablen werden wie gewohnt definiert als

var
   r1, r2, ... : record-name;

Alternativ können Sie eine Datensatztypvariable direkt als - definieren

var
Books : record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: integer;
end;

Zugriff auf Felder eines Datensatzes

Um auf ein Feld eines Datensatzes zuzugreifen, verwenden wir den Member Access Operator (.). Der Mitgliedszugriffsoperator wird als Punkt zwischen dem Namen der Datensatzvariablen und dem Feld codiert, auf das wir zugreifen möchten. Das folgende Beispiel erläutert die Verwendung der Struktur:

program exRecords;
type
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
   Book1, Book2: Books; (* Declare Book1 and Book2 of type Books *)

begin
   (* book 1 specification *)
   Book1.title  := 'C Programming';
   Book1.author := 'Nuha Ali '; 
   Book1.subject := 'C Programming Tutorial';
   Book1.book_id := 6495407;

   (* book 2 specification *)
   Book2.title := 'Telecom Billing';
   Book2.author := 'Zara Ali';
   Book2.subject := 'Telecom Billing Tutorial';
   Book2.book_id := 6495700;
 
   (* print Book1 info *)
   writeln ('Book 1 title : ', Book1.title);
   writeln('Book 1 author : ', Book1.author);
   writeln( 'Book 1 subject : ', Book1.subject);
   writeln( 'Book 1 book_id : ', Book1.book_id);
   writeln; 

   (* print Book2 info *)
   writeln ('Book 2 title : ', Book2.title);
   writeln('Book 2 author : ', Book2.author);
   writeln( 'Book 2 subject : ', Book2.subject);
   writeln( 'Book 2 book_id : ', Book2.book_id);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Datensätze als Unterprogrammargumente

Sie können einen Datensatz als Unterprogrammargument auf sehr ähnliche Weise übergeben wie jede andere Variable oder jeden anderen Zeiger. Sie würden auf die Datensatzfelder auf ähnliche Weise zugreifen wie im obigen Beispiel -

program exRecords;
type
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
   Book1, Book2: Books; (* Declare Book1 and Book2 of type Books *)

(* procedure declaration *)
procedure printBook( var book: Books );

begin
   (* print Book info *)
   writeln ('Book  title : ', book.title);
   writeln('Book  author : ', book.author);
   writeln( 'Book  subject : ', book.subject);
   writeln( 'Book book_id : ', book.book_id);
end;

begin
   (* book 1 specification *)
   Book1.title  := 'C Programming';
   Book1.author := 'Nuha Ali '; 
   Book1.subject := 'C Programming Tutorial';
   Book1.book_id := 6495407;
   
   (* book 2 specification *)
   Book2.title := 'Telecom Billing';
   Book2.author := 'Zara Ali';
   Book2.subject := 'Telecom Billing Tutorial';
   Book2.book_id := 6495700;
   
   (* print Book1 info *)
   printbook(Book1);
   writeln; 

   (* print Book2 info *)
   printbook(Book2);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Zeiger auf Aufzeichnungen

Sie können Zeiger auf Datensätze auf sehr ähnliche Weise definieren, wie Sie Zeiger auf eine andere Variable wie folgt definieren:

type
record-ptr = ^ record-name;
record-name = record
   field-1: field-type1;
   field-2: field-type2;
   ...
   field-n: field-typen;
end;

Jetzt können Sie die Adresse einer Datensatztypvariablen in der oben definierten Zeigervariablen speichern. Um eine Variable des erstellten Zeigertyps zu deklarieren, verwenden Sie das Schlüsselwort var -

var
   r1, r2, ... : record-ptr;

Bevor Sie diese Zeiger verwenden, müssen Sie einen Speicher für eine Variable vom Typ Datensatzname erstellen, die von diesen Zeigern bearbeitet wird.

new(r1);
new(r2);

Um mit einem Zeiger auf diesen Datensatz auf die Mitglieder eines Datensatzes zuzugreifen, müssen Sie das ^ verwenden. Betreiber wie folgt -

r1^.feild1 := value1;
r1^.feild2 := value2;
...
r1^fieldn := valuen;

Vergessen Sie nicht, den gebrauchten Speicher zu entsorgen, wenn er nicht mehr verwendet wird.

dispose(r1);
dispose(r2);

Lassen Sie uns das erste Beispiel mit einem Zeiger auf den Buchdatensatz neu schreiben. Ich hoffe, dass Sie das Konzept leicht verstehen können -

program exRecords;
type
BooksPtr = ^ Books;
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
  (* Declare Book1 and Book2 of pointer type that refers to Book type *)
   Book1, Book2: BooksPtr; 

begin
   new(Book1);
   new(book2);
   
   (* book 1 specification *)
   Book1^.title  := 'C Programming';
   Book1^.author := 'Nuha Ali '; 
   Book1^.subject := 'C Programming Tutorial';
   Book1^.book_id := 6495407;
   
   (* book 2 specification *)
   Book2^.title := 'Telecom Billing';
   Book2^.author := 'Zara Ali';
   Book2^.subject := 'Telecom Billing Tutorial';
   Book2^.book_id := 6495700;
   
   (* print Book1 info *)
   writeln ('Book 1 title : ', Book1^.title);
   writeln('Book 1 author : ', Book1^.author);
   writeln( 'Book 1 subject : ', Book1^.subject);
   writeln( 'Book 1 book_id : ', Book1^.book_id);
   
   (* print Book2 info *)
   writeln ('Book 2 title : ', Book2^.title);
   writeln('Book 2 author : ', Book2^.author);
   writeln( 'Book 2 subject : ', Book2^.subject);
   writeln( 'Book 2 book_id : ', Book2^.book_id);
   
   dispose(Book1); 
   dispose(Book2);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Die With-Anweisung

Wir haben diskutiert, dass auf die Mitglieder eines Datensatzes mit dem Mitgliedszugriffsoperator (.) Zugerechnet werden kann. Auf diese Weise muss der Name der Datensatzvariablen jedes Mal geschrieben werden. DasWith Anweisung bietet eine alternative Möglichkeit, dies zu tun.

Schauen Sie sich das folgende Code-Snippet aus unserem ersten Beispiel an:

(* book 1 specification *)
   Book1.title  := 'C Programming';
   Book1.author := 'Nuha Ali '; 
   Book1.subject := 'C Programming Tutorial';
   Book1.book_id := 6495407;

Die gleiche Aufgabe könnte mit dem geschrieben werden With Aussage als -

(* book 1 specification *)
With Book1 do
begin
   title  := 'C Programming';
   author := 'Nuha Ali '; 
   subject := 'C Programming Tutorial';
   book_id := 6495407;
end;

Pascal unterstützt einen einzigartigen Speichertyp namens Varianten. Sie können in einer Variantenvariablen einen beliebigen einfachen Wertetyp zuweisen. Der Typ eines in einer Variante gespeicherten Wertes wird nur zur Laufzeit ermittelt. Fast jeder einfache Typ kann Varianten zugeordnet werden: Ordinaltypen, Zeichenfolgentypen, int64-Typen.

Strukturierte Typen wie Mengen, Datensätze, Arrays, Dateien, Objekte und Klassen sind mit einer Variante nicht zuweisungskompatibel. Sie können einer Variante auch einen Zeiger zuweisen.

Free Pascal unterstützt Varianten.

Eine Variante deklarieren

Sie können den Variantentyp wie alle anderen Typen mit dem deklarieren varStichwort. Die Syntax zum Deklarieren eines Variantentyps lautet -

var
   v: variant;

Diese Variantenvariable v kann nun fast allen einfachen Typen zugeordnet werden, einschließlich der aufgezählten Typen und umgekehrt.

type  
   color = (red, black, white);  
var  
   v : variant;  
   i : integer;  
   b : byte;  
   w : word;  
   q : int64;  
   e : extended;  
   d : double;  
   en : color;  
   as : ansistring;  
   ws : widestring;  

begin  
   v := i;  
   v := b;  
   v := w;  
   v := q;  
   v := e;  
   v := en;  
   v := d:  
   v := as;  
   v := ws;  
end;

Beispiel

Das folgende Beispiel würde das Konzept veranschaulichen -

Program exVariant;

uses variants;
type
   color = (red, black, white);

var
   v : variant;
   i : integer;
   r: real;
   c : color;
   as : ansistring;


begin
   i := 100;
   v:= i;
   writeln('Variant as Integer: ', v);

   r:= 234.345;
   v:= r;
   writeln('Variant as real: ', v);

   c := red;
   v := c;
   writeln('Variant as Enumerated data: ', v);

   as:= ' I am an AnsiString';
   v:= as;
   writeln('Variant as AnsiString: ', v);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Variant as Integer: 100
Variant as real: 234.345
Variant as Enumerated data: 0
Variant as AnsiString: I am an AnsiString

Eine Menge ist eine Sammlung von Elementen des gleichen Typs. Mit Pascal kann der eingestellte Datentyp definiert werden. Die Elemente in einer Menge werden als ihre Mitglieder bezeichnet. In der Mathematik werden Mengen dargestellt, indem die Elemente in geschweifte Klammern {} eingeschlossen werden . In Pascal sind Mengenelemente jedoch in eckigen Klammern [] eingeschlossen, die als Mengenkonstruktor bezeichnet werden.

Set-Typen und -Variablen definieren

Pascal Set-Typen sind definiert als

type
set-identifier = set of base type;

Variablen vom Satztyp sind definiert als

var
s1, s2, ...: set-identifier;

oder,

s1, s2...: set of base type;

Beispiele für eine gültige Satztypdeklaration sind -

type
Days = (mon, tue, wed, thu, fri, sat, sun);
Letters = set of char;
DaySet = set of days;
Alphabets = set of 'A' .. 'Z';
studentAge = set of 13..20;

Operatoren einstellen

Sie können die folgenden Set-Operationen für Pascal-Sets ausführen.

Sr.Nr.	Operationen & Beschreibungen
1	Union Dies verbindet zwei Sätze und gibt einen neuen Satz mit Mitgliedern aus beiden Sätzen.
2	Difference Ruft die Differenz zweier Sätze ab und gibt einen neuen Satz mit Elementen an, die keinem Satz gemeinsam sind.
3	Intersection Ruft den Schnittpunkt zweier Mengen ab und gibt eine neue Menge mit Elementen an, die beiden Mengen gemeinsam sind.
4	Inclusion Eine Menge P ist in Menge Q enthalten, wenn alle Elemente in P ebenfalls in Q sind, aber nicht umgekehrt.
5	Symmetric difference Ruft die symmetrische Differenz zweier Mengen ab und gibt eine Menge von Elementen an, die sich in einer der Mengen und nicht in ihrem Schnittpunkt befinden.
6	In Es überprüft die Mitgliedschaft.

Die folgende Tabelle zeigt alle von Free Pascal unterstützten Set-Operatoren. Annehmen, dassS1 und S2 sind zwei Zeichensätze, so dass -

S1: = ['a', 'b', 'c'];

S2: = ['c', 'd', 'e'];

Operator	Beschreibung	Beispiel
+	Vereinigung zweier Sätze	S1 + S2 gibt einen Satz ['a', 'b', 'c', 'd', 'e']
- -	Unterschied zweier Sätze	S1 - S2 gibt einen Satz ['a', 'b']
* *	Schnittpunkt zweier Sätze	S1 * S2 gibt einen Satz ['c']
> <	Symmetrische Differenz zweier Sätze	S1> <S2 ergibt eine Menge ['a', 'b', 'd', 'e']
=	Überprüft die Gleichheit zweier Sätze	S1 = S2 ergibt den Booleschen Wert False
<>	Überprüft die Ungleichheit zweier Sätze	S1 <> S2 gibt den booleschen Wert True an
<=	Enthält (Überprüft, ob eine Menge eine Teilmenge der anderen ist)	S1 <= S2 ergibt den Booleschen Wert False
Einschließen	Schließt ein Element in das Set ein; Im Grunde ist es die Vereinigung einer Menge und eines Elements desselben Basistyps	Include (S1, ['d']) ergibt einen Satz ['A B C D']
Ausschließen	Schließt ein Element aus einer Menge aus; Im Grunde ist es der Unterschied einer Menge und eines Elements desselben Basistyps	Ausschließen (S2, ['d']) ergibt eine Menge ['c', 'e']
Im	Überprüft die Zugehörigkeit eines Elements zu einer Menge	['e'] in S2 gibt den booleschen Wert True an

Beispiel

Das folgende Beispiel zeigt die Verwendung einiger dieser Operatoren:

program setColors;
type  
color = (red, blue, yellow, green, white, black, orange);  
colors = set of color;  
 
procedure displayColors(c : colors);  
const  
names : array [color] of String[7]  
  = ('red', 'blue', 'yellow', 'green', 'white', 'black', 'orange');  
var  
   cl : color;  
   s : String;  

begin  
   s:= ' ';  
   for cl:=red to orange do  
      if cl in c then  
      begin  
         if (s<>' ') then s :=s +' , ';  
         s:=s+names[cl];  
      end;  
   writeln('[',s,']');  
end;  
 
var  
   c : colors;  
 
begin  
   c:= [red, blue, yellow, green, white, black, orange];
   displayColors(c);

   c:=[red, blue]+[yellow, green]; 
   displayColors(c);  

   c:=[red, blue, yellow, green, white, black, orange] - [green, white];     
   displayColors(c);    

   c:= [red, blue, yellow, green, white, black, orange]*[green, white];     
   displayColors(c);  

   c:= [red, blue, yellow, green]><[yellow, green, white, black]; 
   displayColors(c);  
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

[ red , blue , yellow , green , white , black , orange]
[ red , blue , yellow , green]
[ red , blue , yellow , black , orange]
[ green , white]
[ red , blue , white , black]

Pascal behandelt eine Datei als eine Folge von Komponenten, die vom einheitlichen Typ sein müssen. Der Dateityp wird durch den Typ der Komponenten bestimmt. Der Datendatentyp ist definiert als -

type
file-name = file of base-type;

Wobei der Basistyp den Typ der Komponenten der Datei angibt. Der Basistyp kann mit Ausnahme eines anderen Dateityps Integer, Real, Boolean, Enumerated, Subrange, Record, Arrays und Sets sein. Variablen eines Dateityps werden mit der var- Deklaration erstellt -

var
f1, f2,...: file-name;

Im Folgenden finden Sie einige Beispiele zum Definieren einiger Dateitypen und Dateivariablen.

type
   rfile = file of real;
   ifile = file of integer;
   bfile = file of boolean;
   datafile = file of record
   arrfile = file of array[1..4] of integer;

var
   marks: arrfile;
   studentdata: datafile;
   rainfalldata: rfile;
   tempdata: ifile;
   choices: bfile;

Erstellen und Schreiben in eine Datei

Lassen Sie uns ein Programm schreiben, das eine Datendatei für die Aufzeichnungen der Schüler erstellt. Es würde eine Datei mit dem Namen students.dat erstellen und die Daten eines Schülers darin schreiben -

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   Assign(f,'students.dat');
   Rewrite(f);
   Student.s_name := 'John Smith';
   Student.s_addr := 'United States of America';
   Student.s_batchcode := 'Computer Science';
   Write(f,Student);
   Close(f);
end.

Beim Kompilieren und Ausführen erstellt das Programm eine Datei mit dem Namen students.dat im Arbeitsverzeichnis. Sie können die Datei mit einem Texteditor wie dem Editor öffnen, um die Daten von John Smith anzuzeigen.

Lesen aus einer Datei

Wir haben gerade eine Datei mit dem Namen students.dat erstellt und in diese geschrieben. Lassen Sie uns nun ein Programm schreiben, das die Daten des Schülers aus der Datei liest -

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   assign(f, 'students.dat');
   reset(f); 
   while not eof(f) do
   
   begin
      read(f,Student);
      writeln('Name: ',Student.s_name);
      writeln('Address: ',Student.s_addr);
      writeln('Batch Code: ', Student.s_batchcode);
   end;
   
   close(f);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Name: John Smith
Address: United States of America
Batch Code: Computer Science

Dateien als Unterprogrammparameter

Mit Pascal können Dateivariablen als Parameter in Standard- und benutzerdefinierten Unterprogrammen verwendet werden. Das folgende Beispiel veranschaulicht dieses Konzept. Das Programm erstellt eine Datei mit dem Namen rainfall.txt und speichert einige Niederschlagsdaten. Als nächstes öffnet es die Datei, liest die Daten und berechnet den durchschnittlichen Niederschlag.

Bitte beachte, dass, if you use a file parameter with subprograms, it must be declared as a var parameter.

program addFiledata;
const
   MAX = 4;
type
   raindata = file of real;

var
   rainfile: raindata;
   filename: string;
procedure writedata(var f: raindata);

var
   data: real;
   i: integer;

begin
   rewrite(f, sizeof(data));
   for i:=1 to MAX do
   
   begin
      writeln('Enter rainfall data: ');
      readln(data);
      write(f, data);
   end;
   
   close(f);
end;

procedure computeAverage(var x: raindata);
var
   d, sum: real;
   average: real;

begin
   reset(x);
   sum:= 0.0;
   while not eof(x) do
   
   begin
      read(x, d);
      sum := sum + d;
   end;
   
   average := sum/MAX;
   close(x);
   writeln('Average Rainfall: ', average:7:2);
end;

begin
   writeln('Enter the File Name: ');
   readln(filename);
   assign(rainfile, filename);
   writedata(rainfile);
   computeAverage(rainfile);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Enter the File Name:
rainfall.txt
Enter rainfall data:
34
Enter rainfall data:
45
Enter rainfall data:
56
Enter rainfall data:
78
Average Rainfall: 53.25

Textdateien

Eine Textdatei in Pascal besteht aus Zeichenzeilen, wobei jede Zeile mit einer Zeilenende-Markierung abgeschlossen wird. Sie können Dateien wie folgt deklarieren und definieren:

type
file-name = text;

Der Unterschied zwischen einer normalen Zeichendatei und einer Textdatei besteht darin, dass eine Textdatei in Zeilen unterteilt ist, die jeweils durch eine spezielle Zeilenende-Markierung abgeschlossen werden, die vom System automatisch eingefügt wird. Im folgenden Beispiel wird eine Textdatei mit dem Namen contact.txt erstellt und in diese geschrieben.

program exText;
var
   filename, data: string;
   myfile: text;

begin
   writeln('Enter the file name: ');
   readln(filename);
   
   assign(myfile, filename);
   rewrite(myfile);
   
   writeln(myfile, 'Note to Students: ');
   writeln(myfile, 'For details information on Pascal Programming');
   writeln(myfile, 'Contact: Tutorials Point');
   writeln('Completed writing'); 
   
   close(myfile);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Enter the file name:
contact.txt 
Completed writing

An eine Datei anhängen

Das Anhängen an eine Datei bedeutet das Schreiben in eine vorhandene Datei, die bereits einige Daten enthält, ohne die Datei zu überschreiben. Das folgende Programm veranschaulicht dies -

program exAppendfile;
var
   myfile: text;
   info: string;

begin
   assign(myfile, 'contact.txt');
   append(myfile);
   
   writeln('Contact Details');
   writeln('[email protected]');
   close(myfile);
   
   (* let us read from this file *)
   assign(myfile, 'contact.txt');
   reset(myfile);
   while not eof(myfile) do
   
   begin
      readln(myfile, info);
      writeln(info);
   end;
   close(myfile);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Contact Details
[email protected]
Note to Students:
For details information on Pascal Programming
Contact: Tutorials Point

Funktionen zur Dateiverwaltung

Free Pascal bietet die folgenden Funktionen / Verfahren für die Dateiverwaltung:

Sr.Nr.	Funktionsname & Beschreibung
1	procedure Append(var t: Text); Öffnet eine Datei im Anhänge-Modus
2	procedure Assign(out f: file; const Name:); Weist einer Datei einen Namen zu
3	procedure Assign(out f: file; p: PChar); Weist einer Datei einen Namen zu
4	procedure Assign(out f: file; c: Char); Weist einer Datei einen Namen zu
5	procedure Assign(out f: TypedFile; const Name:); Weist einer Datei einen Namen zu
6	procedure Assign(out f: TypedFile; p: PChar); Weist einer Datei einen Namen zu
7	procedure Assign(out f: TypedFile; c: Char); Weist einer Datei einen Namen zu
8	procedure Assign(out t: Text; const s:); Weist einer Datei einen Namen zu
9	procedure Assign(out t: Text; p: PChar); Weist einer Datei einen Namen zu
10	procedure Assign(out t: Text; c: Char); Weist einer Datei einen Namen zu
11	procedure BlockRead(var f: file; var Buf; count: Int64; var Result: Int64); Liest Daten aus einer Datei in den Speicher
12	procedure BlockRead(var f: file; var Buf; count: LongInt; var Result: LongInt); Liest Daten aus einer Datei in den Speicher
13	procedure BlockRead(var f: file; var Buf; count: Cardinal; var Result: Cardinal); Liest Daten aus einer Datei in den Speicher
14	procedure BlockRead(var f: file; var Buf; count: Word; var Result: Word); Liest Daten aus einer Datei in den Speicher
15	procedure BlockRead(var f: file; var Buf; count: Word; var Result: Integer); Liest Daten aus einer Datei in den Speicher
16	procedure BlockRead(var f: file; var Buf; count: Int64); Liest Daten aus einer Datei in den Speicher
17	procedure BlockWrite(var f: file; const Buf; Count: Int64; var Result: Int64); Schreibt Daten aus dem Speicher in eine Datei
18	procedure BlockWrite(var f: file; const Buf; Count: LongInt; var Result: LongInt); Schreibt Daten aus dem Speicher in eine Datei
19	procedure BlockWrite(var f: file; const Buf; Count: Cardinal; var Result: Cardinal); Schreibt Daten aus dem Speicher in eine Datei
20	procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Word); Schreibt Daten aus dem Speicher in eine Datei
21	procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Integer); Schreibt Daten aus dem Speicher in eine Datei
22	procedure BlockWrite(var f: file; const Buf; Count: LongInt); Schreibt Daten aus dem Speicher in eine Datei
23	procedure Close(var f: file); Schließt eine Datei
24	procedure Close(var t: Text); Schließt eine Datei
25	function EOF(var f: file):Boolean; Überprüft das Dateiende
26	function EOF(var t: Text):Boolean; Überprüft das Dateiende
27	function EOF: Boolean; Überprüft das Dateiende
28	function EOLn(var t: Text):Boolean; Überprüft das Zeilenende
29	function EOLn: Boolean; Überprüft das Zeilenende
30	procedure Erase(var f: file); Löscht die Datei von der Festplatte
31	procedure Erase(var t: Text); Löscht die Datei von der Festplatte
32	function FilePos( var f: file):Int64; Position in Datei
33	function FileSize(var f: file):Int64; Größe der Datei
34	procedure Flush(var t: Text); Schreibt Dateipuffer auf die Festplatte
35	function IOResult: Word; Gibt das Ergebnis der letzten Datei-E / A-Operation zurück
36	procedure Read(var F: Text; Args: Arguments); Liest aus der Datei in die Variable
37	procedure Read(Args: Arguments); Liest aus der Datei in die Variable
38	procedure ReadLn(var F: Text; Args: Arguments); Liest aus der Datei in die Variable und geht zur nächsten Zeile
39	procedure ReadLn(Args: Arguments); Liest aus der Datei in die Variable und geht zur nächsten Zeile
40	procedure Rename(var f: file; const s:); Benennt die Datei auf der Festplatte um
41	procedure Rename(var f: file; p: PChar); Benennt die Datei auf der Festplatte um
42	procedure Rename(var f: file; c: Char); Benennt die Datei auf der Festplatte um
43	procedure Rename(var t: Text; const s); Datei auf der Festplatte umbenennen
44	procedure Rename(var t: Text; p: PChar); Benennt die Datei auf der Festplatte um
45	procedure Rename( var t: Text; c: Char); Benennt die Datei auf der Festplatte um
46	procedure Reset(var f: file; l: LongInt); Öffnet die Datei zum Lesen
47	procedure Reset(var f: file); Öffnet die Datei zum Lesen
48	procedure Reset(var f: TypedFile); Öffnet die Datei zum Lesen
49	procedure Reset(var t: Text); Öffnet die Datei zum Lesen
50	procedure Rewrite(var f: file; l: LongInt); Öffnet die Datei zum Schreiben
51	procedure Rewrite(var f: file); Öffnet die Datei zum Schreiben
52	procedure Rewrite(var f: TypedFile); Öffnet die Datei zum Schreiben
53	procedure Rewrite(var t: Text); Öffnet die Datei zum Schreiben
54	procedure Seek(var f: file; Pos: Int64); Legt die Dateiposition fest
55	function SeekEOF(var t: Text):Boolean; Setzt die Dateiposition auf das Dateiende
56	function SeekEOF: Boolean; Setzt die Dateiposition auf das Dateiende
57	function SeekEOLn(var t: Text):Boolean; Setzt die Dateiposition auf das Zeilenende
58	function SeekEOLn: Boolean; Setzt die Dateiposition auf das Zeilenende
59	procedure SetTextBuf(var f: Text; var Buf); Legt die Größe des Dateipuffers fest
60	procedure SetTextBuf(var f: Text; var Buf; Size: SizeInt); Legt die Größe des Dateipuffers fest
61	procedure Truncate(var F: file); Schneiden Sie die Datei an der Position ab
62	procedure Write(Args: Arguments); Schreibt eine Variable in eine Datei
63	procedure Write(var F: Text; Args: Arguments); Variable in Datei schreiben
64	procedure Writeln(Args: Arguments); Schreibt eine Variable in eine Datei und hängt eine neue Zeile an
65	procedure WriteLn(var F: Text; Args: Arguments); Schreibt eine Variable in eine Datei und hängt eine neue Zeile an

In diesem Kapitel wird die dynamische Speicherverwaltung in Pascal erläutert. Die Programmiersprache Pascal bietet verschiedene Funktionen für die Speicherzuweisung und -verwaltung.

Speicher dynamisch zuweisen

Wenn Sie während der Programmierung die Größe eines Arrays kennen, ist dies einfach und Sie können es als Array definieren. Um beispielsweise einen Namen einer Person zu speichern, können maximal 100 Zeichen verwendet werden, sodass Sie Folgendes definieren können:

var
name: array[1..100] of char;

Betrachten wir nun eine Situation, in der Sie keine Ahnung von der Länge des zu speichernden Textes haben, z. B. eine detaillierte Beschreibung zu einem Thema speichern möchten. Hier müssen wir einen Zeiger auf eine Zeichenfolge definieren, ohne zu definieren, wie viel Speicher benötigt wird.

Pascal bietet eine Prozedur newZeigervariablen erstellen.

program exMemory;
var
name: array[1..100] of char;
description: ^string;

begin
   name:= 'Zara Ali';
   
   new(description);
      if not assigned(description) then
         writeln(' Error - unable to allocate required memory')
      else
         description^ := 'Zara ali a DPS student in class 10th';
   writeln('Name = ', name );
   writeln('Description: ', description^ );
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

Wenn Sie nun einen Zeiger mit einer bestimmten Anzahl von Bytes definieren müssen, auf die später verwiesen werden soll, sollten Sie den verwenden getmem Funktion oder die getmem Prozedur, die die folgende Syntax hat -

procedure Getmem(
   out p: pointer;
   Size: PtrUInt
);

function GetMem(
   size: PtrUInt
):pointer;

Im vorherigen Beispiel haben wir einen Zeiger auf eine Zeichenfolge deklariert. Eine Zeichenfolge hat einen Maximalwert von 255 Byte. Wenn Sie wirklich nicht so viel Speicherplatz oder einen größeren Speicherplatz in Bezug auf Bytes benötigen , können Sie dies im Unterprogramm getmem angeben . Lassen Sie uns das vorherige Beispiel mit getmem - neu schreiben.

program exMemory;
var
name: array[1..100] of char;
description: ^string;

begin
   name:= 'Zara Ali';
   
   description := getmem(200);
      if not assigned(description) then
         writeln(' Error - unable to allocate required memory')
      else
         description^ := 'Zara ali a DPS student in class 10th';
   writeln('Name = ', name );
   writeln('Description: ', description^ );
   
   freemem(description);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

Sie haben also die vollständige Kontrolle und können einen beliebigen Größenwert übergeben, während Sie Speicher zuweisen, im Gegensatz zu Arrays, bei denen die Größe nach der Definition nicht mehr geändert werden kann.

Ändern der Größe und Freigeben des Speichers

Wenn Ihr Programm herauskommt, gibt das Betriebssystem automatisch den gesamten von Ihrem Programm zugewiesenen Speicher frei. Wenn Sie jedoch keinen Speicher mehr benötigen, sollten Sie diesen Speicher freigeben.

Pascal liefert das Verfahren dispose um eine dynamisch erstellte Variable mit der Prozedur freizugeben new. Wenn Sie Speicher mit dem zugewiesen haben getmem Unterprogramm, dann müssen Sie das Unterprogramm verwenden freememum diesen Speicher freizugeben. Die Freemem- Unterprogramme haben die folgende Syntax:

procedure Freemem(
   p: pointer;
  Size: PtrUInt
);

function Freemem(
   p: pointer
):PtrUInt;

Alternativ können Sie die Größe eines zugewiesenen Speicherblocks erhöhen oder verringern, indem Sie die Funktion ReAllocMem aufrufen . Lassen Sie uns das obige Programm noch einmal überprüfen und die Unterprogramme ReAllocMem und Freemem verwenden . Es folgt die Syntax für ReAllocMem -

function ReAllocMem(
   var p: pointer;
   Size: PtrUInt
):pointer;

Das folgende Beispiel verwendet ReAllocMem- und Freemem- Unterprogramme -

program exMemory;
var
name: array[1..100] of char;
description: ^string;
desp: string;

begin
   name:= 'Zara Ali';
   desp := 'Zara ali a DPS student.';
   
   description := getmem(30);
      if not assigned(description) then
         writeln('Error - unable to allocate required memory')
      else
         description^ := desp;

   (* Suppose you want to store bigger description *)
   description := reallocmem(description, 100);
   desp := desp + ' She is in class 10th.';
   description^:= desp; 
   
   writeln('Name = ', name );
   writeln('Description: ', description^ );
   
   freemem(description);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Name = Zara Ali
Description: Zara ali a DPS student. She is in class 10th

Speicherverwaltungsfunktionen

Pascal bietet eine Vielzahl von Speicherverwaltungsfunktionen, die bei der Implementierung verschiedener Datenstrukturen und der Implementierung von Low-Level-Programmierung in Pascal verwendet werden. Viele dieser Funktionen sind implementierungsabhängig. Free Pascal bietet die folgenden Funktionen und Verfahren für die Speicherverwaltung:

SN	Funktionsname & Beschreibung
1	function Addr(X: TAnytype):Pointer; Gibt die Adresse der Variablen zurück
2	function Assigned(P: Pointer):Boolean; Überprüft, ob ein Zeiger gültig ist
3	function CompareByte(const buf1; const buf2; len: SizeInt):SizeInt; Vergleicht 2 Speicherpuffer Byte pro Byte
4	function CompareChar(const buf1; const buf2; len: SizeInt):SizeInt; Vergleicht 2 Speicherpuffer Byte pro Byte
5	function CompareDWord(const buf1; const buf2; len: SizeInt):SizeInt; Vergleicht 2 Speicherpuffer Byte pro Byte
6	function CompareWord(const buf1; const buf2; len: SizeInt):SizeInt; Vergleicht 2 Speicherpuffer Byte pro Byte
7	function Cseg: Word; Gibt das Codesegment zurück
8	procedure Dispose(P: Pointer); Gibt dynamisch zugewiesenen Speicher frei
9	procedure Dispose(P: TypedPointer; Des: TProcedure); Gibt dynamisch zugewiesenen Speicher frei
10	function Dseg: Word; Gibt das Datensegment zurück
11	procedure FillByte(var x; count: SizeInt; value: Byte); Füllt den Speicherbereich mit einem 8-Bit-Muster
12	procedure FillChar( var x; count: SizeInt; Value: Byte|Boolean|Char); Füllt den Speicherbereich mit einem bestimmten Zeichen
13	procedure FillDWord( var x; count: SizeInt; value: DWord); Füllt den Speicherbereich mit einem 32-Bit-Muster
14	procedure FillQWord( var x; count: SizeInt; value: QWord); Füllt den Speicherbereich mit einem 64-Bit-Muster
15	procedure FillWord( var x; count: SizeInt; Value: Word); Füllt den Speicherbereich mit einem 16-Bit-Muster
16	procedure Freemem( p: pointer; Size: PtrUInt); Gibt den zugewiesenen Speicher frei
17	procedure Freemem( p: pointer ); Gibt den zugewiesenen Speicher frei
18	procedure Getmem( out p: pointer; Size: PtrUInt); Weist neuen Speicher zu
19	procedure Getmem( out p: pointer); Weist neuen Speicher zu
20	procedure GetMemoryManager( var MemMgr: TMemoryManager); Gibt den aktuellen Speichermanager zurück
21	function High( Arg: TypeOrVariable):TOrdinal; Gibt den höchsten Index des geöffneten Arrays oder der Aufzählung zurück
22	function IndexByte( const buf; len: SizeInt; b: Byte):SizeInt; Findet einen bytegroßen Wert in einem Speicherbereich
23	function IndexChar( const buf; len: SizeInt; b: Char):SizeInt; Findet einen Wert in Zeichengröße in einem Speicherbereich
24	function IndexDWord( const buf; len: SizeInt; b: DWord):SizeInt; Findet einen 32-Bit-Wert in DWord-Größe in einem Speicherbereich
25	function IndexQWord( const buf; len: SizeInt; b: QWord):SizeInt; Findet einen Wert in QWord-Größe in einem Speicherbereich
26	function Indexword( const buf; len: SizeInt; b: Word):SizeInt; Findet einen wortgroßen Wert in einem Speicherbereich
27	function IsMemoryManagerSet: Boolean; Ist der Speichermanager eingestellt?
28	function Low( Arg: TypeOrVariable ):TOrdinal; Gibt den niedrigsten Index des geöffneten Arrays oder der Aufzählung zurück
29	procedure Move( const source; var dest; count: SizeInt ); Verschiebt Daten von einem Speicherort an einen anderen
30	procedure MoveChar0( const buf1; var buf2; len: SizeInt); Verschiebt Daten bis zum ersten Nullzeichen
31	procedure New( var P: Pointer); Ordnen Sie dynamisch Speicher für Variablen zu
32	procedure New( var P: Pointer; Cons: TProcedure); Ordnet dynamisch Speicher für Variablen zu
33	function Ofs( var X ):LongInt; Gibt den Offset der Variablen zurück
34	function ptr( sel: LongInt; off: LongInt):farpointer; Kombiniert Segment und Offset zum Zeiger
35	function ReAllocMem( var p: pointer; Size: PtrUInt):pointer; Ändert die Größe eines Speicherblocks auf dem Heap
36	function Seg( var X):LongInt; Gibt das Segment zurück
37	procedure SetMemoryManager( const MemMgr: TMemoryManager ); Legt einen Speichermanager fest
38	function Sptr: Pointer; Gibt den aktuellen Stapelzeiger zurück
39	function Sseg: Word; Gibt den Wert des Stapelsegmentregisters zurück

Ein Pascal-Programm kann aus Modulen bestehen, die als Einheiten bezeichnet werden. Eine Einheit kann aus einigen Codeblöcken bestehen, die wiederum aus Variablen und Typdeklarationen, Anweisungen, Prozeduren usw. bestehen. In Pascal gibt es viele integrierte Einheiten, und Pascal ermöglicht es Programmierern, ihre eigenen Einheiten zu definieren und zu schreiben, die verwendet werden sollen später in verschiedenen Programmen.

Eingebaute Einheiten verwenden

Sowohl die integrierten als auch die benutzerdefinierten Einheiten werden durch die Verwendungsklausel in ein Programm aufgenommen. Wir haben die Varianteneinheit bereits im Pascal - Variants Tutorial verwendet. In diesem Tutorial wird das Erstellen und Einfügen von benutzerdefinierten Einheiten erläutert. Lassen Sie uns jedoch zunächst sehen, wie eine eingebaute Einheit eingebaut wirdcrt in Ihrem Programm -

program myprog;
uses crt;

Das folgende Beispiel zeigt die Verwendung von crt Einheit -

Program Calculate_Area (input, output);
uses crt;
var 
   a, b, c, s, area: real;

begin
   textbackground(white); (* gives a white background *)
   clrscr; (*clears the screen *)
   
   textcolor(green); (* text color is green *)
   gotoxy(30, 4); (* takes the pointer to the 4th line and 30th column) 
   
   writeln('This program calculates area of a triangle:');
   writeln('Area = area = sqrt(s(s-a)(s-b)(s-c))');
   writeln('S stands for semi-perimeter');
   writeln('a, b, c are sides of the triangle');
   writeln('Press any key when you are ready');
   
   readkey;
   clrscr;
   gotoxy(20,3);
   
   write('Enter a: ');
   readln(a);
   gotoxy(20,5);
   
   write('Enter b:');
   readln(b);
   gotoxy(20, 7);
   
   write('Enter c: ');
   readln(c);

   s := (a + b + c)/2.0;
   area := sqrt(s * (s - a)*(s-b)*(s-c));
   gotoxy(20, 9);
   
   writeln('Area: ',area:10:3);
   readkey;
end.

Es ist dasselbe Programm, das wir gleich zu Beginn des Pascal-Tutorials verwendet haben. Kompilieren Sie es und führen Sie es aus, um die Auswirkungen der Änderung zu ermitteln.

Erstellen und Verwenden einer Pascal-Einheit

Um eine Einheit zu erstellen, müssen Sie die Module oder Unterprogramme schreiben, die Sie darin speichern möchten, und sie in einer Datei mit speichern .pasErweiterung. Die erste Zeile dieser Datei sollte mit dem Schlüsselwort unit beginnen, gefolgt vom Namen der Einheit. Zum Beispiel -

unit calculateArea;

Es folgen drei wichtige Schritte zum Erstellen einer Pascal-Einheit:

• Der Name der Datei und der Name des Geräts sollten genau gleich sein. Daher wird unsere Einheit berechneArea in einer Datei mit dem Namen berechneArea.pas gespeichert .

• Die nächste Zeile sollte aus einem einzelnen Schlüsselwort bestehen interface. Nach dieser Zeile schreiben Sie die Deklarationen für alle Funktionen und Prozeduren, die in dieser Einheit enthalten sein werden.

• Schreiben Sie das Wort direkt nach den Funktionsdeklarationen implementation, was wieder ein Schlüsselwort ist. Geben Sie nach der Zeile mit der Schlüsselwortimplementierung eine Definition aller Unterprogramme an.

Das folgende Programm erstellt die Einheit berechneArea -

unit CalculateArea;
interface

function RectangleArea( length, width: real): real;
function CircleArea(radius: real) : real;
function TriangleArea( side1, side2, side3: real): real;

implementation

function RectangleArea( length, width: real): real;
begin
   RectangleArea := length * width;
end;

function CircleArea(radius: real) : real;
const
   PI = 3.14159;
begin
   CircleArea := PI * radius * radius;
end;

function TriangleArea( side1, side2, side3: real): real;
var
   s, area: real;

begin
   s := (side1 + side2 + side3)/2.0;
   area := sqrt(s * (s - side1)*(s-side2)*(s-side3));
   TriangleArea := area;
end;

end.

Als nächstes schreiben wir ein einfaches Programm, das die oben definierte Einheit verwendet -

program AreaCalculation;
uses CalculateArea,crt;

var
   l, w, r, a, b, c, area: real;

begin
   clrscr;
   l := 5.4;
   w := 4.7;
   area := RectangleArea(l, w);
   writeln('Area of Rectangle 5.4 x 4.7 is: ', area:7:3);

   r:= 7.0;
   area:= CircleArea(r);
   writeln('Area of Circle with radius 7.0 is: ', area:7:3);

   a := 3.0;
   b:= 4.0;
   c:= 5.0;
  
   area:= TriangleArea(a, b, c);
   writeln('Area of Triangle 3.0 by 4.0 by 5.0 is: ', area:7:3);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Area of Rectangle 5.4 x 4.7 is: 25.380
Area of Circle with radius 7.0 is: 153.938
Area of Triangle 3.0 by 4.0 by 5.0 is: 6.000

Die meisten von Ihnen geschriebenen Softwareprogramme müssen Datumsfunktionen implementieren, die das aktuelle Datum und die aktuelle Uhrzeit zurückgeben. Termine gehören so sehr zum Alltag, dass es einfach wird, mit ihnen zu arbeiten, ohne nachzudenken. Pascal bietet außerdem leistungsstarke Tools für die Datumsarithmetik, mit denen Datumsangaben einfach bearbeitet werden können. Der tatsächliche Name und die Funktionsweise dieser Funktionen sind jedoch für verschiedene Compiler unterschiedlich.

Aktuelles Datum und Uhrzeit abrufen

Mit der TimeToString-Funktion von Pascal erhalten Sie die aktuelle Zeit in einer durch Doppelpunkte (:) getrennten Form. Das folgende Beispiel zeigt, wie die aktuelle Zeit abgerufen wird -

program TimeDemo;
uses sysutils;

begin
   writeln ('Current time : ',TimeToStr(Time));
end.

Wenn der obige Code kompiliert und ausgeführt wurde, ergibt sich das folgende Ergebnis:

Current time : 18:33:08

Das Date Funktion gibt das aktuelle Datum in zurück TDateTimeFormat. TDateTime ist ein doppelter Wert, der dekodiert und formatiert werden muss. Das folgende Programm zeigt, wie Sie es in Ihrem Programm verwenden, um das aktuelle Datum anzuzeigen:

Program DateDemo;
uses sysutils;
var
   YY,MM,DD : Word;

begin
   writeln ('Date : ',Date);
   DeCodeDate (Date,YY,MM,DD);
   writeln (format ('Today is (DD/MM/YY): %d/%d/%d ',[dd,mm,yy]));
end.

Wenn der obige Code kompiliert und ausgeführt wurde, ergibt sich das folgende Ergebnis:

Date: 4.111300000000000E+004
Today is (DD/MM/YY):23/7/2012

Die Now-Funktion gibt das aktuelle Datum und die aktuelle Uhrzeit zurück -

Program DatenTimeDemo;
uses sysutils;
begin
   writeln ('Date and Time at the time of writing : ',DateTimeToStr(Now));
end.

Wenn der obige Code kompiliert und ausgeführt wurde, ergibt sich das folgende Ergebnis:

Date and Time at the time of writing : 23/7/2012 18:51:

Free Pascal bietet eine einfache Zeitstempelstruktur mit dem Namen TTimeStamp, die das folgende Format hat -

type TTimeStamp = record
   Time: Integer;
   Date: Integer;
end;

Verschiedene Datums- und Uhrzeitfunktionen

Free Pascal bietet die folgenden Datums- und Uhrzeitfunktionen:

Sr.Nr.	Funktionsname & Beschreibung
1	function DateTimeToFileDate(DateTime: TDateTime):LongInt; Konvertiert den DateTime-Typ in das Dateidatum.
2	function DateTimeToStr( DateTime: TDateTime):; Erstellt eine Zeichenfolgendarstellung von DateTime
3	function DateTimeToStr(DateTime: TDateTime; const FormatSettings: TFormatSettings):; Erstellt eine Zeichenfolgendarstellung von DateTime
4	procedure DateTimeToString(out Result: ;const FormatStr: ;const DateTime: TDateTime); Erstellt eine Zeichenfolgendarstellung von DateTime
5	procedure DateTimeToString(out Result: ; const FormatStr: ; const DateTime: TDateTime; const FormatSettings: TFormatSettings); Erstellt eine Zeichenfolgendarstellung von DateTime
6	procedure DateTimeToSystemTime(DateTime: TDateTime; out SystemTime: TSystemTime); Konvertiert DateTime in Systemzeit
7	function DateTimeToTimeStamp( DateTime: TDateTime):TTimeStamp;Konvertiert DateTime in Zeitstempel
8	function DateToStr(Date: TDateTime):; Erstellt eine Zeichenfolgendarstellung des Datums
9	function DateToStr(Date: TDateTime; const FormatSettings: TFormatSettings):; Erstellt eine Zeichenfolgendarstellung des Datums
10	function Date: TDateTime; Ruft das aktuelle Datum ab
11	function DayOfWeek(DateTime: TDateTime):Integer; Ruft den Wochentag ab
12	procedure DecodeDate(Date: TDateTime; out Year: Word; out Month: Word; out Day: Word); Dekodiert DateTime in Jahr, Monat und Tag
13	procedure DecodeTime(Time: TDateTime; out Hour: Word; out Minute: Word; out Second: Word; out MilliSecond: Word); Dekodiert DateTime in Stunden, Minuten und Sekunden
14	function EncodeDate(Year: Word; Month: Word; Day: Word):TDateTime; Codiert Jahr, Tag und Monat in DateTime
15	function EncodeTime(Hour: Word; Minute: Word; Second: Word; MilliSecond: Word):TDateTime; Codiert Stunden, Minuten und Sekunden in DateTime
16	function FormatDateTime(const FormatStr: ; DateTime: TDateTime):; Gibt die Zeichenfolgendarstellung von DateTime zurück
17	function FormatDateTime(const FormatStr: ; DateTime: TDateTime; const FormatSettings: TFormatSettings):; Gibt die Zeichenfolgendarstellung von DateTime zurück
18	function IncMonth(const DateTime: TDateTime; NumberOfMonths: Integer = 1):TDateTime; Fügt 1 zum Monat hinzu
19	function IsLeapYear(Year: Word):Boolean; Bestimmt, ob das Jahr das Schaltjahr ist
20	function MSecsToTimeStamp(MSecs: Comp):TTimeStamp; Konvertiert die Anzahl der Millisekunden in einen Zeitstempel
21	function Now: TDateTime; Ruft das aktuelle Datum und die aktuelle Uhrzeit ab
22	function StrToDateTime(const S:):TDateTime; Konvertiert einen String in DateTime
23	function StrToDateTime(const s: ShortString; const FormatSettings: TFormatSettings):TDateTime; Konvertiert einen String in DateTime
24	function StrToDateTime(const s: AnsiString; const FormatSettings: TFormatSettings):TDateTime; Konvertiert einen String in DateTime
25	function StrToDate(const S: ShortString):TDateTime; Konvertiert Zeichenfolge in Datum
26	function StrToDate(const S: Ansistring):TDateTime; Konvertiert Zeichenfolge in Datum
27	function StrToDate(const S: ShortString; separator: Char):TDateTime; Konvertiert Zeichenfolge in Datum
28	function StrToDate(const S: AnsiString; separator: Char):TDateTime; Konvertiert Zeichenfolge in Datum
29	function StrToDate(const S: ShortString; const useformat: ; separator: Char):TDateTime; Converts string to date
30	function StrToDate(const S: AnsiString; const useformat: ; separator: Char):TDateTime; Converts string to date
31	function StrToDate(const S: PChar; Len: Integer; const useformat: ; separator: Char = #0):TDateTime; Converts string to date
32	function StrToTime(const S: Shortstring):TDateTime; Converts string to time
33	function StrToTime(const S: Ansistring):TDateTime; Converts string to time
34	function StrToTime(const S: ShortString; separator: Char):TDateTime; Converts string to time
35	function StrToTime(const S: AnsiString; separator: Char):TDateTime; Converts string to time
36	function StrToTime(const S: ; FormatSettings: TFormatSettings):TDateTime; Converts string to time
37	function StrToTime(const S: PChar; Len: Integer; separator: Char = #0):TDateTime; Converts string to time
38	function SystemTimeToDateTime(const SystemTime: TSystemTime):TDateTime; Converts system time to datetime
39	function TimeStampToDateTime(const TimeStamp: TTimeStamp):TDateTime; Converts time stamp to DateTime
40	function TimeStampToMSecs(const TimeStamp: TTimeStamp):comp; Converts Timestamp to number of milliseconds
41	function TimeToStr(Time: TDateTime):; Returns string representation of Time
42	function TimeToStr(Time: TDateTime; const FormatSettings: TFormatSettings):; Returns string representation of Time
43	function Time: TDateTime; Get current time

The following example illustrates the use of some of the above functions −

Program DatenTimeDemo;
uses sysutils;
var
year, month, day, hr, min, sec, ms: Word;

begin
   writeln ('Date and Time at the time of writing : ',DateTimeToStr(Now));
   writeln('Today is ',LongDayNames[DayOfWeek(Date)]);
   writeln;
   writeln('Details of Date: ');
   
   DecodeDate(Date,year,month,day);
   writeln (Format ('Day: %d',[day]));
   writeln (Format ('Month: %d',[month]));
   writeln (Format ('Year: %d',[year]));
   writeln;
   writeln('Details of Time: ');
   
   DecodeTime(Time,hr, min, sec, ms);
   writeln (format('Hour: %d:',[hr]));
   writeln (format('Minutes: %d:',[min]));
   writeln (format('Seconds: %d:',[sec]));
   writeln (format('Milliseconds: %d:',[hr]));
end.

When the above code was compiled and executed, it produced the following result:

Date and Time at the time of writing : 7/24/2012 8:26:
Today is Tuesday
Details of Date:
Day:24
Month:7
Year: 2012
Details of Time:
Hour: 8
Minutes: 26
Seconds: 21
Milliseconds: 8

We can imagine our universe made of different objects like sun, earth, moon, etc. Similarly, we can imagine our car made of different objects like wheel, steering, gear, etc. Same way, there are object-oriented programming concepts, which assume everything as an object and implement a software using different objects. In Pascal, there are two structural data types used to implement a real world object −

• Object types
• Class types

Object-Oriented Concepts

Before we go in detail, let's define important Pascal terms related to Object-Oriented Pascal.

• Object − An Object is a special kind of record that contains fields like a record; however, unlike records, objects contain procedures and functions as part of the object. These procedures and functions are held as pointers to the methods associated with the object's type.

• Class − A Class is defined in almost the same way as an Object, but there is a difference in way they are created. The Class is allocated on the Heap of a program, whereas the Object is allocated on the Stack. It is a pointer to the object, not the object itself.

• Instantiation of a class − Instantiation means creating a variable of that class type. Since a class is just a pointer, when a variable of a class type is declared, there is memory allocated only for the pointer, not for the entire object. Only when it is instantiated using one of its constructors, memory is allocated for the object. Instances of a class are also called 'objects', but do not confuse them with Object Pascal Objects. In this tutorial, we will write 'Object' for Pascal Objects and 'object' for the conceptual object or class instance.

• Member Variables − These are the variables defined inside a Class or an Object.

• Member Functions − These are the functions or procedures defined inside a Class or an Object and are used to access object data.

• Visibility of Members − The members of an Object or Class are also called the fields. These fields have different visibilities. Visibility refers to accessibility of the members, i.e., exactly where these members will be accessible. Objects have three visibility levels: public, private and protected. Classes have five visibility types: public, private, strictly private, protected and published. We will discuss visibility in details.

• Inheritance − When a Class is defined by inheriting existing functionalities of a parent Class, then it is said to be inherited. Here child class will inherit all or few member functions and variables of a parent class. Objects can also be inherited.

• Parent Class − A Class that is inherited by another Class. This is also called a base class or super class.

• Child Class − A class that inherits from another class. This is also called a subclass or derived class.

• Polymorphism − This is an object-oriented concept where same function can be used for different purposes. For example, function name will remain same but it may take different number of arguments and can do different tasks. Pascal classes implement polymorphism. Objects do not implement polymorphism.

• Overloading − It is a type of polymorphism in which some or all of operators have different implementations depending on the types of their arguments. Similarly functions can also be overloaded with different implementation. Pascal classes implement overloading, but the Objects do not.

• Data Abstraction − Any representation of data in which the implementation details are hidden (abstracted).

• Encapsulation − Refers to a concept where we encapsulate all the data and member functions together to form an object.

• Constructor − Refers to a special type of function which will be called automatically whenever there is an object formation from a class or an Object.

• Destructor − Refers to a special type of function which will be called automatically whenever an Object or Class is deleted or goes out of scope.

Defining Pascal Objects

An object is declared using the type declaration. The general form of an object declaration is as follows −

type object-identifier = object  
   private
   field1 : field-type;  
   field2 : field-type;  
   ...
   public
   procedure proc1;  
   function f1(): function-type;
   end;  
var objectvar : object-identifier;

Let us define a Rectangle Object that has two integer type data members - length and width and some member functions to manipulate these data members and a procedure to draw the rectangle.

type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      constructor init;  
      destructor done;  
      
      procedure setlength(l: inteter);  
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

After creating your objects, you will be able to call member functions related to that object. One member function will be able to process member variable of related object only.

Following example shows how to set lengths and widths for two rectangle objects and draw them by calling the member functions.

r1.setlength(3);
r1.setwidth(7);

writeln(' Draw a rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
r1.draw;
new(pr1);
pr1^.setlength(5);
pr1^.setwidth(4);

writeln(' Draw a rectangle: ', pr1^.getlength(), ' by ' ,pr1^.getwidth());
pr1^.draw;
dispose(pr1);

Following is a complete example to show how to use objects in Pascal −

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
     for j:= 1 to width do
        write(' * ');
     writeln;
   end;
end;

begin
   r1.setlength(3);
   r1.setwidth(7);
   
   writeln('Draw a rectangle:', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   new(pr1);
   pr1^.setlength(5);
   pr1^.setwidth(4);
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
end.

When the above code is compiled and executed, it produces the following result −

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *

Visibility of the Object Members

Visibility indicates the accessibility of the object members. Pascal object members have three types of visibility −

Sr.No	Visibility & Accessibility
1	Public The members can be used by other units outside the program unit
2	Private The members are only accessible in the current unit.
3	Protected The members are available only to objects descended from the parent object.

By default, fields and methods of an object are public and are exported outside the current unit.

Constructors and Destructors for Pascal Objects −

Constructors are special type of methods, which are called automatically whenever an object is created. You create a constructor in Pascal just by declaring a method with a keyword constructor. Conventionally, the method name is Init, however, you can provide any valid identifier of your own. You can pass as many arguments as you like into the constructor function.

Destructors are methods that are called during the destruction of the object. The destructor methods destroy any memory allocation created by constructors.

Following example will provide a constructor and a destructor for the Rectangle class which will initialize length and width for the rectangle at the time of object creation and destroy it when it goes out of scope.

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      constructor init(l, w: integer);
      destructor done;
      
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;

var
   r1: Rectangle;
   pr1: ^Rectangle;

constructor Rectangle.init(l, w: integer);
begin
   length := l;
   width := w;
end;

destructor Rectangle.done;
begin
   writeln(' Desctructor Called');
end; 

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
   end;
end;

begin
   r1.init(3, 7);
   writeln('Draw a rectangle:', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   new(pr1, init(5, 4));
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ',pr1^.getwidth());
   pr1^.draw;
   pr1^.init(7, 9);
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
   r1.done;
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *
Draw a rectangle: 7 by 9
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
Destructor Called

Vererbung für Pascal-Objekte

Pascal-Objekte können optional von einem übergeordneten Objekt erben. Das folgende Programm veranschaulicht die Vererbung in Pascal-Objekten. Lassen Sie uns ein anderes Objekt mit dem Namen erstellenTableTop, die vom Rectangle-Objekt erbt.

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      procedure setlength(l: integer);  
      function getlength(): integer;  
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      procedure draw;
end;

TableTop = object (Rectangle)
   private
     material: string;
   public
      function getmaterial(): string;
      procedure setmaterial( m: string);
      procedure displaydetails;
      procedure draw;
end;

var
   tt1: TableTop;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth():integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
  end;
end;

function TableTop.getmaterial(): string;
begin
   getmaterial := material;
end;

procedure TableTop.setmaterial( m: string);
begin
   material := m;
end;

procedure TableTop.displaydetails;
begin
   writeln('Table Top: ', self.getlength(), ' by ' , self.getwidth());
   writeln('Material: ', self.getmaterial());
end;

procedure TableTop.draw();
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
   writeln;
   end;
   writeln('Material: ', material);
end;

begin
   tt1.setlength(3);
   tt1.setwidth(7);
   tt1.setmaterial('Wood');
   tt1.displaydetails();
   writeln;
   writeln('Calling the Draw method');
   tt1.draw();
end.

Im Folgenden sind die wichtigen Punkte aufgeführt, die notiert werden sollten:

• Das Objekt Tabletop hat alle Mitglieder des Rectangle-Objekts geerbt.

• Es gibt auch eine Zeichenmethode in TableTop . Wenn das Ziehverfahren eines aufgerufen wird TableTop Objekt, wird TableTop der Auslosung aufgerufen.

• Es gibt eine implizite Instanz mit dem Namen self das bezieht sich auf die aktuelle Instanz des Objekts.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Table Top: 3 by 7
Material: Wood

Calling the Draw Method 
* * * * * * *
* * * * * * *
* * * * * * *
Material: Wood

Sie haben gesehen, dass Pascal-Objekte einige Merkmale eines objektorientierten Paradigmas aufweisen. Sie implementieren Kapselung, Verstecken von Daten und Vererbung, haben aber auch Einschränkungen. Zum Beispiel nehmen Pascal-Objekte nicht am Polymorphismus teil. Daher werden Klassen häufig verwendet, um ein korrektes objektorientiertes Verhalten in einem Programm zu implementieren, insbesondere in der GUI-basierten Software.

Eine Klasse wird fast genauso definiert wie ein Objekt, ist jedoch eher ein Zeiger auf ein Objekt als auf das Objekt selbst. Technisch bedeutet dies, dass die Klasse auf dem Heap eines Programms zugewiesen wird, während das Objekt auf dem Stapel zugewiesen wird. Mit anderen Worten, wenn Sie eine Variable als Objekttyp deklarieren, nimmt sie auf dem Stapel so viel Platz ein wie die Größe des Objekts. Wenn Sie jedoch eine Variable vom Klassentyp deklarieren, nimmt sie immer die Größe eines Zeigers an auf dem Stapel. Die tatsächlichen Klassendaten befinden sich auf dem Heap.

Pascal-Klassen definieren

Eine Klasse wird wie ein Objekt mithilfe der Typdeklaration deklariert. Die allgemeine Form einer Klassendeklaration lautet wie folgt:

type class-identifier = class  
   private
      field1 : field-type;  
      field2 : field-type;  
        ...
   
   public
      constructor create();
      procedure proc1;  
      function f1(): function-type;
end;  
var classvar : class-identifier;

Es lohnt sich, folgende wichtige Punkte zu beachten:

• Klassendefinitionen sollten nur unter den Typdeklarationsteil des Programms fallen.

• Eine Klasse wird mit dem definiert class Stichwort.

• Felder sind Datenelemente, die in jeder Instanz der Klasse vorhanden sind.

• Methoden werden innerhalb der Definition einer Klasse deklariert.

• Es gibt einen vordefinierten Konstruktor namens Createin der Root-Klasse. Jede abstrakte Klasse und jede konkrete Klasse ist ein Nachkomme von Root, daher haben alle Klassen mindestens einen Konstruktor.

• Es gibt einen vordefinierten Destruktor namens Destroyin der Root-Klasse. Jede abstrakte Klasse und jede konkrete Klasse ist ein Nachkomme von Root, daher haben alle Klassen mindestens einen Destruktor.

Definieren wir eine Rechteckklasse mit zwei Datenelementen vom Typ Integer - Länge und Breite sowie einige Elementfunktionen zum Bearbeiten dieser Datenelemente und eine Prozedur zum Zeichnen des Rechtecks.

type
   Rectangle = class
   private
      length, width: integer;
   
   public
      constructor create(l, w: integer);
      procedure setlength(l: integer);
      function getlength(): integer;
      procedure setwidth(w: integer);
      function getwidth(): integer;
      procedure draw;
end;

Schreiben wir ein vollständiges Programm, das eine Instanz einer Rechteckklasse erstellt und das Rechteck zeichnet. Dies ist das gleiche Beispiel, das wir bei der Erörterung von Pascal-Objekten verwendet haben. Sie werden feststellen, dass beide Programme mit den folgenden Ausnahmen fast gleich sind:

• Sie müssen die Anweisung {$ mode objfpc} einschließen, um die Klassen verwenden zu können.

• Sie müssen die Anweisung {$ m +} für die Verwendung von Konstruktoren einschließen.

• Die Klasseninstanziierung unterscheidet sich von der Objektinstanziierung. Nur das Deklarieren der Variablen schafft keinen Platz für die Instanz. Sie verwenden den Konstruktor create, um Speicher zuzuweisen.

Hier ist das vollständige Beispiel -

{$mode objfpc} // directive to be used for defining classes {$m+}		   // directive to be used for using constructor

program exClass;
type
   Rectangle = class
   private
      length, width: integer;
   
   public
      constructor create(l, w: integer);
      procedure setlength(l: integer);
      
      function getlength(): integer;
      procedure setwidth(w: integer);
      
      function getwidth(): integer;
      procedure draw;
end;
var
   r1: Rectangle;

constructor Rectangle.create(l, w: integer);
begin
   length := l;
   width := w;
end;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
   end;
end;

begin
   r1:= Rectangle.create(3, 7);
   
   writeln(' Draw Rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   r1.setlength(4);
   r1.setwidth(6);
   
   writeln(' Draw Rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Draw Rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw Rectangle: 4 by 6
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * *

Sichtbarkeit der Klassenmitglieder

Sichtbarkeit gibt die Zugänglichkeit der Klassenmitglieder an. Pascal-Klassenmitglieder haben fünf Arten der Sichtbarkeit -

Sr.Nr.	Sichtbarkeit und Zugänglichkeit
1	Public Diese Mitglieder sind immer erreichbar.
2	Private Auf diese Mitglieder kann nur in dem Modul oder der Einheit zugegriffen werden, die die Klassendefinition enthält. Sie können von innerhalb oder außerhalb der Klassenmethoden aufgerufen werden.
3	Strict Private Auf diese Mitglieder kann nur über Methoden der Klasse selbst zugegriffen werden. Andere Klassen oder untergeordnete Klassen in derselben Einheit können nicht auf sie zugreifen.
4	Protected Dies ist dasselbe wie privat, außer dass diese Mitglieder für absteigende Typen zugänglich sind, selbst wenn sie in anderen Modulen implementiert sind.
5	Published Dies ist dasselbe wie ein Public, aber der Compiler generiert Typinformationen, die für das automatische Streaming dieser Klassen benötigt werden, wenn sich der Compiler im Status {$ M +} befindet. In einem veröffentlichten Abschnitt definierte Felder müssen vom Klassentyp sein.

Konstruktoren und Destruktoren für Pascal-Klassen

Konstruktoren sind spezielle Methoden, die automatisch aufgerufen werden, wenn ein Objekt erstellt wird. Wir nutzen dieses Verhalten also voll aus, indem wir viele Dinge durch Konstruktorfunktionen initialisieren.

Pascal bietet eine spezielle Funktion namens create () zum Definieren eines Konstruktors. Sie können beliebig viele Argumente an die Konstruktorfunktion übergeben.

Im folgenden Beispiel wird ein Konstruktor für eine Klasse mit dem Namen "Bücher" erstellt und der Preis und der Titel für das Buch zum Zeitpunkt der Objekterstellung initialisiert.

program classExample;

{$MODE OBJFPC} //directive to be used for creating classes
{$M+} //directive that allows class constructors and destructors
type
   Books = Class 
   private 
      title : String; 
      price: real;
   
   public
      constructor Create(t : String; p: real); //default constructor
      
      procedure setTitle(t : String); //sets title for a book
      function getTitle() : String; //retrieves title
      
      procedure setPrice(p : real); //sets price for a book
      function getPrice() : real; //retrieves price
      
      procedure Display(); // display details of a book
end;
var
   physics, chemistry, maths: Books;

//default constructor 
constructor Books.Create(t : String; p: real);
begin
   title := t;
   price := p;
end;

procedure Books.setTitle(t : String); //sets title for a book
begin
   title := t;
end;

function Books.getTitle() : String; //retrieves title
begin
   getTitle := title;
end;

procedure Books.setPrice(p : real); //sets price for a book
begin
   price := p;
end;

function Books.getPrice() : real; //retrieves price
begin
   getPrice:= price;
end;

procedure Books.Display();
begin
   writeln('Title: ', title);
   writeln('Price: ', price:5:2);
end;

begin 
   physics := Books.Create('Physics for High School', 10);
   chemistry := Books.Create('Advanced Chemistry', 15);
   maths := Books.Create('Algebra', 7);
   
   physics.Display;
   chemistry.Display;
   maths.Display;
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Title: Physics for High School
Price: 10
Title: Advanced Chemistry
Price: 15
Title: Algebra
Price: 7

Wie der implizite Konstruktor create gibt es auch eine implizite Destruktormethode destroy, mit der Sie alle in der Klasse verwendeten Ressourcen freigeben können.

Erbe

Pascal-Klassendefinitionen können optional von einer übergeordneten Klassendefinition erben. Die Syntax lautet wie folgt:

type
childClas-identifier = class(baseClass-identifier) 
< members >
end;

Das folgende Beispiel enthält eine Romanklasse, die die Books-Klasse erbt und je nach Anforderung weitere Funktionen hinzufügt.

program inheritanceExample;

{$MODE OBJFPC} //directive to be used for creating classes
{$M+} //directive that allows class constructors and destructors

type
   Books = Class 
   protected 
      title : String; 
      price: real;
   
   public
      constructor Create(t : String; p: real); //default constructor
      
      procedure setTitle(t : String); //sets title for a book
      function getTitle() : String; //retrieves title
      
      procedure setPrice(p : real); //sets price for a book
      function getPrice() : real; //retrieves price
      
      procedure Display(); virtual; // display details of a book
end;
(* Creating a derived class *)

type
   Novels = Class(Books)
   private
      author: String;
   
   public
      constructor Create(t: String); overload;
      constructor Create(a: String; t: String; p: real); overload;
      
      procedure setAuthor(a: String); // sets author for a book
      function getAuthor(): String; // retrieves author name
      
      procedure Display(); override;
end;
var
   n1, n2: Novels;

//default constructor 
constructor Books.Create(t : String; p: real);
begin
   title := t;
   price := p;
end;

procedure Books.setTitle(t : String); //sets title for a book
begin
   title := t;
end;

function Books.getTitle() : String; //retrieves title
begin
   getTitle := title;
end;

procedure Books.setPrice(p : real); //sets price for a book
begin
   price := p;
end;

function Books.getPrice() : real; //retrieves price
begin
   getPrice:= price;
end;

procedure Books.Display();
begin
   writeln('Title: ', title);
   writeln('Price: ', price);
end;

(* Now the derived class methods  *)
constructor Novels.Create(t: String);
begin
   inherited Create(t, 0.0);
   author:= ' ';
end;

constructor Novels.Create(a: String; t: String; p: real);
begin
   inherited Create(t, p);
   author:= a;
end;

procedure Novels.setAuthor(a : String); //sets author for a book
begin
   author := a;
end;

function Novels.getAuthor() : String; //retrieves author
begin
   getAuthor := author;
end;

procedure Novels.Display();
begin
   writeln('Title: ', title);
   writeln('Price: ', price:5:2);
   writeln('Author: ', author);
end;

begin 
   n1 := Novels.Create('Gone with the Wind');
   n2 := Novels.Create('Ayn Rand','Atlas Shrugged', 467.75);
   n1.setAuthor('Margaret Mitchell');
   n1.setPrice(375.99);
   n1.Display;
   n2.Display;
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Title: Gone with the Wind
Price: 375.99
Author: Margaret Mitchell
Title: Atlas Shrugged
Price: 467.75
Author: Ayn Rand

Es lohnt sich, folgende wichtige Punkte zu beachten:

• Die Mitglieder der Bücherklasse haben protected Sichtweite.

• Die Novels-Klasse hat zwei Konstruktoren, also die overload Der Operator wird zum Überladen von Funktionen verwendet.

• Das Books.Display-Verfahren wurde deklariert virtual, so dass die gleiche Methode aus der Novels-Klasse kann override es.

• Der Novels.Create-Konstruktor ruft den Basisklassenkonstruktor mit dem auf inherited Stichwort.

Schnittstellen

Schnittstellen werden definiert, um den Implementierern einen gemeinsamen Funktionsnamen bereitzustellen. Verschiedene Implementierer können diese Schnittstellen entsprechend ihren Anforderungen implementieren. Man kann sagen, Schnittstellen sind Skelette, die von Entwicklern implementiert werden. Das Folgende ist ein Beispiel für eine Schnittstelle -

type  
   Mail = Interface  
      Procedure SendMail;  
      Procedure GetMail;  
   end;  
   
   Report = Class(TInterfacedObject,  Mail)  
      Procedure SendMail;  
      Procedure GetMail;  
   end;

Beachten Sie, dass eine Klasse, wenn sie eine Schnittstelle implementiert, alle Methoden der Schnittstelle implementieren sollte. Wenn eine Methode einer Schnittstelle nicht implementiert ist, gibt der Compiler einen Fehler aus.

Abstrakte Klassen

Eine abstrakte Klasse kann nicht instanziiert, sondern nur vererbt werden. Eine abstrakte Klasse wird angegeben, indem das Wortsymbol abstrakt wie folgt in die Klassendefinition aufgenommen wird:

type
   Shape = ABSTRACT CLASS (Root)
      Procedure draw; ABSTRACT;
      ...
   end;

Beim Erben von einer abstrakten Klasse müssen alle in der Klassendeklaration des Elternteils als abstrakt gekennzeichneten Methoden vom Kind definiert werden. Darüber hinaus müssen diese Methoden mit derselben Sichtbarkeit definiert werden.

Statisches Schlüsselwort

Wenn Sie Klassenmitglieder oder Methoden als statisch deklarieren, können Sie auf sie zugreifen, ohne dass eine Instanziierung der Klasse erforderlich ist. Auf ein als statisch deklariertes Mitglied kann nicht mit einem instanziierten Klassenobjekt zugegriffen werden (obwohl dies mit einer statischen Methode möglich ist). Das folgende Beispiel veranschaulicht das Konzept -

program StaticExample;
{$mode objfpc}
{$static on}
type
   myclass=class
      num : integer;static;
   end;
var
   n1, n2 : myclass;
begin
   n1:= myclass.create;
   n2:= myclass.create;
   n1.num := 12;
   writeln(n2.num);
   n2.num := 31;
   writeln(n1.num);
   writeln(myclass.num);
   myclass.num := myclass.num + 20;
   writeln(n1.num);
   writeln(n2.num);
end.

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

12
31
31
51
51

Sie müssen die Direktive {$ static on} verwenden, um die statischen Elemente zu verwenden.