Pascal - Guide rapide

Pascal est un langage de haut niveau à usage général qui a été développé à l'origine par Niklaus Wirth au début des années 1970. Il a été développé pour enseigner la programmation en tant que discipline systématique et pour développer des programmes fiables et efficaces.

Pascal est un langage basé sur Algol et comprend de nombreuses constructions d'Algol. Algol 60 est un sous-ensemble de Pascal. Pascal propose plusieurs types de données et structures de programmation. Il est facile de comprendre et de maintenir les programmes Pascal.

Pascal a gagné en popularité dans le domaine de l'enseignement et des universitaires pour diverses raisons:

• Facile à apprendre.
• Langage structuré.
• Il produit des programmes transparents, efficaces et fiables.
• Il peut être compilé sur une variété de plates-formes informatiques.

Caractéristiques du langage Pascal

Pascal a les caractéristiques suivantes -

• Pascal est un langage fortement typé.
• Il offre une vérification complète des erreurs.
• Il propose plusieurs types de données tels que des tableaux, des enregistrements, des fichiers et des ensembles.
• Il offre une variété de structures de programmation.
• Il prend en charge la programmation structurée à travers des fonctions et des procédures.
• Il prend en charge la programmation orientée objet.

Faits sur Pascal

• Le langage Pascal a été nommé en l'honneur de Blaise Pascal, mathématicien français et pionnier du développement informatique.

• Niklaus Wirth a terminé le développement du langage de programmation Pascal original en 1970.

• Pascal est basé sur le style structuré par blocs du langage de programmation Algol.

• Pascal a été développé comme un langage adapté à l'enseignement de la programmation en tant que discipline systématique, dont les implémentations pourraient être à la fois fiables et efficaces.

• La norme ISO 7185 Pascal a été publiée à l'origine en 1983.

• Pascal était le principal langage de haut niveau utilisé pour le développement dans Apple Lisa et dans les premières années du Mac.

• En 1986, Apple Computer a publié la première implémentation Object Pascal, et en 1993, le Pascal Standards Committee a publié une extension orientée objet vers Pascal.

Pourquoi utiliser Pascal?

Pascal permet aux programmeurs de définir des types de données structurées complexes et de créer des structures de données dynamiques et récursives, telles que des listes, des arbres et des graphiques. Pascal offre des fonctionnalités telles que des enregistrements, des énumérations, des sous-plages, des variables allouées dynamiquement avec des pointeurs et des ensembles associés.

Pascal autorise les définitions de procédures imbriquées à n'importe quel niveau de profondeur. Cela fournit vraiment un excellent environnement de programmation pour l'apprentissage de la programmation en tant que discipline systématique basée sur les concepts fondamentaux.

Parmi les implémentations les plus étonnantes de Pascal sont -

• Skype
• Commandant total
• TeX
• Macromedia Captivate
• Apple Lisa
• Divers jeux PC
• Systèmes embarqués

Il existe plusieurs compilateurs et interprètes Pascal disponibles pour une utilisation générale. Parmi ceux-ci sont -

• Turbo Pascal - fournit un IDE et un compilateur pour exécuter des programmes Pascal sur CP / M, CP / M-86, DOS, Windows et Macintosh.

• Delphi- fournit des compilateurs pour exécuter Object Pascal et génère du code natif pour les systèmes d'exploitation Windows 32 et 64 bits, ainsi que pour Mac OS X et iOS 32 bits. Embarcadero prévoit de développer la prise en charge du système d'exploitation Linux et Android.

• Free Pascal- c'est un compilateur gratuit pour exécuter des programmes Pascal et Object Pascal. Le compilateur Free Pascal est un compilateur Pascal 32 et 64 bits compatible avec Turbo Pascal et Delphi pour Linux, Windows, OS / 2, FreeBSD, Mac OS X, DOS et plusieurs autres plates-formes.

• Turbo51 - Il s'agit d'un compilateur Pascal gratuit pour la famille de microcontrôleurs 8051, avec la syntaxe Turbo Pascal 7.

• Oxygene - Il s'agit d'un compilateur Object Pascal pour les plates-formes .NET et Mono.

• GNU Pascal (GPC) - C'est un compilateur Pascal composé d'un frontal vers GNU Compiler Collection.

Nous utiliserons Free Pascal dans ces tutoriels. Vous pouvez télécharger Free Pascal pour votre système d'exploitation à partir du lien: Télécharger Free Pascal

Installer Free Pascal sur Linux

La distribution Linux de Free Pascal se présente sous trois formes -

• une tar.gz version, également disponible sous forme de fichiers séparés.

• une .rpm (Red Hat Package Manager) version.

• une .deb (Debian) version.

Code d'installation pour la version .rpm ::

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

Où XYZ est le numéro de version du fichier .rpm et ARCH est l'une des architectures prises en charge (i386, x86_64, etc.).

Code d'installation pour la version Debian (comme Ubuntu) -

dpkg -i fpc-XXX.deb

Où XXX est le numéro de version du fichier .deb.

Pour plus de détails, lisez: Guide d'installation gratuit de Pascal

Installer Free Pascal sur Mac

Si vous utilisez Mac OS X, le moyen le plus simple d'utiliser Free Pascal est de télécharger l'environnement de développement Xcode à partir du site Web d'Apple et de suivre les instructions d'installation simples. Une fois que vous avez configuré Xcode, vous pourrez utiliser le compilateur Free Pascal.

Installer Free Pascal sur Windows

Pour Windows, vous téléchargerez le programme d'installation de Windows, setup.exe. Il s'agit d'un programme d'installation habituel. Vous devez suivre les étapes suivantes pour l'installation -

• Sélectionnez un répertoire.

• Sélectionnez les parties du package que vous souhaitez installer.

• Choisissez éventuellement d'associer les extensions .pp ou .pas à l'IDE Free Pascal.

Pour plus de détails, lisez: Guide d'installation gratuit de Pascal

Éditeur de texte

Cela sera utilisé pour taper votre programme. Quelques exemples d'éditeurs incluent le Bloc-notes Windows, la commande d'édition du système d'exploitation, Brief, Epsilon, EMACS et vim ou vi.

Le nom et la version de l'éditeur de texte peuvent varier selon les systèmes d'exploitation. Par exemple, le Bloc-notes sera utilisé sous Windows et vim ou vi peut être utilisé sur Windows ainsi que Linux ou UNIX.

Les fichiers que vous créez avec votre éditeur sont appelés fichiers source et contiennent le code source du programme. Les fichiers source des programmes Pascal sont généralement nommés avec l'extension.pas.

Avant de commencer votre programmation, assurez-vous d'avoir un éditeur de texte en place et que vous avez suffisamment d'expérience pour écrire un programme informatique, l'enregistrer dans un fichier, le compiler et enfin l'exécuter.

Avant d'étudier les blocs de construction de base du langage de programmation Pascal, examinons une structure de programme Pascal minimale afin de pouvoir la prendre comme référence dans les chapitres à venir.

Structure du programme Pascal

Un programme Pascal se compose essentiellement des parties suivantes -

• Nom du programme
• Utilise la commande
• Déclarations de type
• Déclarations constantes
• Déclarations de variables
• Déclarations de fonctions
• Déclarations de procédures
• Bloc de programme principal
• Déclarations et expressions dans chaque bloc
• Comments

Chaque programme pascal a généralement une instruction d'en-tête, une déclaration et une partie exécution strictement dans cet ordre. Le format suivant montre la syntaxe de base d'un programme Pascal -

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 }

Exemple de Pascal Hello World

Voici un simple code pascal qui afficherait les mots "Hello, World!" -

program HelloWorld;
uses crt;

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

Cela produira le résultat suivant -

Hello, World!

Regardons différentes parties du programme ci-dessus -

• La première ligne du programme program HelloWorld; indique le nom du programme.

• La deuxième ligne du programme uses crt; est une commande de préprocesseur, qui indique au compilateur d'inclure l'unité crt avant de passer à la compilation réelle.

• Les lignes suivantes incluses dans les instructions begin et end constituent le bloc principal du programme. Chaque bloc de Pascal est enfermé dans unbegin déclaration et un enddéclaration. Cependant, l'instruction de fin indiquant la fin du programme principal est suivie d'un point (.) Au lieu d'un point-virgule (;).

• le begin l'instruction du bloc de programme principal est l'endroit où commence l'exécution du programme.

• Les lignes à l'intérieur (*...*) sera ignoré par le compilateur et il a été mis pour ajouter un comment dans le programme.

• La déclaration writeln('Hello, World!');utilise la fonction writeln disponible dans Pascal qui provoque le message "Hello, World!" à afficher à l'écran.

• La déclaration readkey;permet à l'affichage de se mettre en pause jusqu'à ce que l'utilisateur appuie sur une touche. Il fait partie de l'unité crt. Une unité est comme une bibliothèque en Pascal.

• La dernière déclaration end. met fin à votre programme.

Compiler et exécuter le programme Pascal

• Ouvrez un éditeur de texte et ajoutez le code mentionné ci-dessus.

• Enregistrez le fichier sous hello.pas

• Ouvrez une invite de commande et accédez au répertoire dans lequel vous avez enregistré le fichier.

• Tapez fpc hello.pas à l'invite de commande et appuyez sur Entrée pour compiler votre code.

• S'il n'y a pas d'erreurs dans votre code, l'invite de commande vous amènera à la ligne suivante et générera hello fichier exécutable et hello.o fichier objet.

• Maintenant, tapez hello à l'invite de commande pour exécuter votre programme.

• Vous pourrez voir "Hello World" imprimé sur l'écran et le programme attend jusqu'à ce que vous appuyiez sur n'importe quelle touche.

$ 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!

Assurez-vous que le compilateur pascal gratuit fpc est dans votre chemin et que vous l'exécutez dans le répertoire contenant le fichier source hello.pas.

Vous avez vu une structure de base du programme pascal, il sera donc facile de comprendre les autres blocs de construction de base du langage de programmation pascal.

Variables

Une définition de variable est placée dans un bloc commençant par un var mot-clé, suivi des définitions des variables comme suit:

var
A_Variable, B_Variable ... : Variable_Type;

Les variables Pascal sont déclarées en dehors du corps de code de la fonction, ce qui signifie qu'elles ne sont pas déclarées dans le begin et end paires, mais elles sont déclarées après la définition de la procédure / fonction et avant le beginmot-clé. Pour les variables globales, elles sont définies après l'en-tête du programme.

Fonctions / procédures

Chez Pascal, un procedure est un ensemble d'instructions à exécuter, sans valeur de retour et un functionest une procédure avec une valeur de retour. La définition de la fonction / des procédures sera la suivante -

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

commentaires

Les commentaires multilignes sont placés entre accolades et astérisques sous la forme (* ... *). Pascal autorise les commentaires sur une seule ligne entre accolades {...}.

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

{ This is a single line comment in pascal }

Sensibilité à la casse

Pascal est un langage non sensible à la casse, ce qui signifie que vous pouvez écrire vos variables, fonctions et procédure dans les deux cas. Comme les variables A_Variable, a_variable et A_VARIABLE ont la même signification en Pascal.

Déclarations de Pascal

Les programmes Pascal sont constitués d'instructions. Chaque déclaration spécifie un travail défini du programme. Ces tâches peuvent être la déclaration, l'affectation, la lecture de données, l'écriture de données, la prise de décisions logiques, le transfert du contrôle de flux de programme, etc.

Par exemple -

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

Mots réservés en Pascal

Les instructions en Pascal sont conçues avec des mots Pascal spécifiques, appelés mots réservés. Par exemple, les mots program, input, output, var, real, begin, readline, writeline et end sont tous des mots réservés.

Voici une liste de mots réservés disponibles en Pascal.

et	tableau	commencer	Cas	const
div	faire	vers le bas	autre	fin
fichier	pour	fonction	aller à	si
dans	étiquette	mod	néant	ne pas
de	ou	emballé	procédure	programme
record	répéter	ensemble	puis	à
type	jusqu'à	var	tandis que	avec

Jeu de caractères et identificateurs en Pascal

Le jeu de caractères Pascal se compose de -

• Toutes les lettres majuscules (AZ)

• Toutes les lettres minuscules (az)

• Tous les chiffres (0-9)

• Symboles spéciaux - + * /: =,. ;. () [] = {} `espace blanc

Les entités d'un programme Pascal comme les variables et les constantes, les types, les fonctions, les procédures et les enregistrements, etc., ont un nom ou un identifiant. Un identifiant est une séquence de lettres et de chiffres commençant par une lettre. Les symboles spéciaux et les espaces ne doivent pas être utilisés dans un identifiant.

Les types de données d'une entité indiquent la signification, les contraintes, les valeurs possibles, les opérations, les fonctions et le mode de stockage qui lui sont associés.

Les types entier, réel, booléen et caractère sont appelés types de données standard. Les types de données peuvent être classés en types de données scalaires, pointeurs et structurés. Des exemples de types de données scalaires sont entier, réel, booléen, caractère, sous-plage et énuméré. Les types de données structurées sont constitués des types scalaires; par exemple, des tableaux, des enregistrements, des fichiers et des ensembles. Nous discuterons des types de données de pointeur plus tard.

Types de données Pascal

Les types de données Pascal peuvent être résumés comme ci-dessous dans le diagramme suivant -

Déclarations de type

La déclaration de type est utilisée pour déclarer le type de données d'un identifiant. La syntaxe de la déclaration de type est -

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

Par exemple, la déclaration suivante définit les variables jours et âge comme type entier, yes et true comme type booléen, nom et ville comme type chaîne, frais et dépenses comme type réel.

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

Types entiers

Le tableau suivant vous donne des détails sur les types d'entiers standard avec ses tailles de stockage et ses plages de valeurs utilisées dans Object Pascal -

Type	Le minimum	Maximum	Format
Entier	-2147483648	2147483647	signé 32 bits
Cardinal	0	4294967295	non signé 32 bits
Shortint	-128	127	signé 8 bits
Smallint	-32768	32767	signé 16 bits
Longint	-2147483648	2147483647	signé 32 bits
Int64	-2 ^ 63	2 ^ 63 - 1	signé 64 bits
Octet	0	255	non signé 8 bits
Mot	0	65535	non signé 16 bits
Longword	0	4294967295	non signé 32 bits

Constantes

L'utilisation de constantes rend un programme plus lisible et aide à conserver des quantités spéciales à un seul endroit au début du programme. Pascal autorise les constantes numériques, logiques, chaînes et caractères . Les constantes peuvent être déclarées dans la partie déclaration du programme en spécifiant leconst déclaration.

La syntaxe de la déclaration de type constant est la suivante -

const
Identifier = contant_value;

Voici quelques exemples de déclarations constantes -

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

Toutes les déclarations de constantes doivent être données avant la déclaration de variable.

Types énumérés

Les types de données énumérés sont des types de données définis par l'utilisateur. Ils permettent de spécifier des valeurs dans une liste. Seuls les opérateurs d' affectation et les opérateurs relationnels sont autorisés sur le type de données énuméré. Les types de données énumérés peuvent être déclarés comme suit -

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

Voici quelques exemples de déclarations de types énumérés -

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

L'ordre dans lequel les éléments sont répertoriés dans le domaine d'un type énuméré définit l'ordre des éléments. Par exemple, dans le type énuméré SUMMER, avril vient avant mai, mai avant juin, et ainsi de suite. Le domaine des identificateurs de type énumérés ne peut pas être constitué de constantes numériques ou de caractères.

Types de sous-plages

Les types de sous-plage permettent à une variable de prendre des valeurs comprises dans une certaine plage. Par exemple, si l' âge des électeurs doit être compris entre 18 et 100 ans, une variable nommée âge pourrait être déclarée comme -

var
age: 18 ... 100;

Nous examinerons la déclaration de variable en détail dans la section suivante. Vous pouvez également définir un type de sous-plage à l'aide de la déclaration de type. La syntaxe pour déclarer un type de sous-plage est la suivante -

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

Voici quelques exemples de déclarations de types de sous-plages -

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

Les types de sous-plage peuvent être créés à partir d'un sous-ensemble d'un type énuméré déjà défini, par exemple -

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

Une variable n'est rien d'autre qu'un nom donné à une zone de stockage que nos programmes peuvent manipuler. Chaque variable en Pascal a un type spécifique, qui détermine la taille et la disposition de la mémoire de la variable; la plage de valeurs pouvant être stockées dans cette mémoire; et l'ensemble des opérations qui peuvent être appliquées à la variable.

Le nom d'une variable peut être composé de lettres, de chiffres et du caractère de soulignement. Il doit commencer par une lettre ou un trait de soulignement. Pascal estnot case-sensitive, donc les lettres majuscules et minuscules signifient la même chose ici. Sur la base des types de base expliqués dans le chapitre précédent, il y aura les types de variables de base suivants -

Variables de base en Pascal

Sr.Non	Type et description
1	Character Généralement un seul octet (un octet). Il s'agit d'un type entier.
2	Integer La taille entière la plus naturelle de la machine.
3	Real Valeur à virgule flottante simple précision.
4	Boolean Spécifie des valeurs logiques vraies ou fausses. C'est également un type entier.
5	Enumerated Spécifie une liste définie par l'utilisateur.
6	Subrange Représente des variables dont les valeurs se trouvent dans une plage.
sept	String Stocke un tableau de caractères.

Le langage de programmation Pascal permet également de définir divers autres types de variables, que nous aborderons dans les chapitres suivants comme Pointer, Array, Records, Sets, and Files, etc. Pour ce chapitre, étudions uniquement les types de variables de base.

Déclaration de variable en Pascal

Toutes les variables doivent être déclarées avant de les utiliser dans le programme Pascal. Toutes les déclarations de variables sont suivies du mot-clé var . Une déclaration spécifie une liste de variables, suivie de deux points (:) et du type. La syntaxe de la déclaration de variable est -

var
variable_list : type;

Ici, type doit être un type de données Pascal valide comprenant un caractère, un entier, un réel, un booléen ou tout type de données défini par l'utilisateur, etc., et variable_list peut être constitué d'un ou plusieurs noms d'identificateurs séparés par des virgules. Certaines déclarations de variables valides sont affichées ici -

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

Dans le tutoriel précédent, nous avons discuté du fait que Pascal permet de déclarer un type. Un type peut être identifié par un nom ou un identifiant. Ce type peut être utilisé pour définir des variables de ce type. Par exemple,

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

Maintenant, les types ainsi définis peuvent être utilisés dans les déclarations de variables -

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

Veuillez noter la différence entre la déclaration de type et la déclaration var . La déclaration de type indique la catégorie ou la classe des types tels que entier, réel, etc., tandis que la spécification de variable indique le type de valeurs qu'une variable peut prendre. Vous pouvez comparer la déclaration de type en Pascal avec typedef en C. Plus important encore, le nom de la variable fait référence à l'emplacement mémoire où la valeur de la variable va être stockée. Ce n'est pas le cas avec la déclaration de type.

Initialisation de variable en Pascal

Les variables se voient attribuer une valeur avec deux points et le signe égal, suivi d'une expression constante. La forme générale d'attribution d'une valeur est -

variable_name := value;

Par défaut, les variables en Pascal ne sont pas initialisées avec zéro. Ils peuvent contenir des valeurs de déchets. Il est donc préférable d'initialiser des variables dans un programme. Les variables peuvent être initialisées (affectées d'une valeur initiale) dans leur déclaration. L'initialisation est suivie duvar mot clé et la syntaxe d'initialisation est la suivante -

var
variable_name : type = value;

Quelques exemples sont -

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

Prenons un exemple, qui utilise divers types de variables discutés jusqu'à présent -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Variables énumérées

Vous avez vu comment utiliser des types de variables simples comme entier, réel et booléen. Voyons maintenant les variables de type énuméré, qui peuvent être définies comme -

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

Lorsque vous avez déclaré un type énuméré, vous pouvez déclarer des variables de ce type. Par exemple,

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

L'exemple suivant illustre le concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Which drink do you want?
You can drink limejuice

Variables de sous-plage

Les variables de sous-plage sont déclarées comme -

var
subrange-name : lowerlim ... uperlim;

Des exemples de variables de sous-plage sont -

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

Le programme suivant illustre le concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Une constante est une entité qui reste inchangée pendant l'exécution du programme. Pascal n'autorise que les constantes des types suivants à être déclarées -

• Types ordinaux
• Définir les types
• Types de pointeurs (mais la seule valeur autorisée est Nil).
• Types réels
• Char
• String

Déclaration de constantes

La syntaxe pour déclarer les constantes est la suivante -

const
identifier = constant_value;

Le tableau suivant fournit des exemples de certaines déclarations de constantes valides -

Real type constant

Sr.Non	Type de constante et exemples
1	Ordinal(Integer)type constant valid_age = 21;
2	Set type constant Voyelles = ensemble de (A, E, I, O, U);
3	Pointer type constant P = NUL;
4	e = 2,7182818; velocity_light = 3,0E + 10;
5	Character type constant Opérateur = '+';
6	String type constant président = 'Johnny Depp';

L'exemple suivant illustre le concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Observez le formatage dans l'instruction de sortie du programme. La variable c doit être formatée avec le nombre total de chiffres 7 et 2 chiffres après le signe décimal. Pascal permet un tel formatage de sortie avec les variables numériques.

Un opérateur est un symbole qui indique au compilateur d'effectuer des manipulations mathématiques ou logiques spécifiques. Pascal autorise les types d'opérateurs suivants -

• Opérateurs arithmétiques
• Opérateurs relationnels
• opérateurs booléens
• Opérateurs de bits
• Définir les opérateurs
• Opérateurs de chaîne

Discutons un par un des opérateurs arithmétique, relationnel, booléen et bit. Nous discuterons plus tard des opérateurs d'ensemble et des opérations sur les chaînes.

Opérateurs arithmétiques

Le tableau suivant montre tous les opérateurs arithmétiques pris en charge par Pascal. Supposons une variableA détient 10 et variable B détient 20, alors -

Afficher des exemples

Opérateur	La description	Exemple
+	Ajoute deux opérandes	A + B donnera 30
-	Soustrait le deuxième opérande du premier	A - B donnera -10
*	Multiplie les deux opérandes	A * B donnera 200
/	Divise le numérateur par le dénominateur	B / A donnera 2
%	Opérateur de module et reste après une division entière	B% A donnera 0

Opérateurs relationnels

Le tableau suivant montre tous les opérateurs relationnels pris en charge par Pascal. Supposons une variableA détient 10 et variable B détient 20, alors -

Afficher des exemples

Opérateur	La description	Exemple
=	Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, alors la condition devient vraie.	(A = B) n'est pas vrai.
<>	Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie.	(A <> B) est vrai.
>	Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(A> B) n'est pas vrai.
<	Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(A <B) est vrai.
> =	Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.	(A> = B) n'est pas vrai.
<=	Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.	(A <= B) est vrai.

Opérateurs booléens

Le tableau suivant montre tous les opérateurs booléens pris en charge par le langage Pascal. Tous ces opérateurs travaillent sur des opérandes booléens et produisent des résultats booléens. Supposons une variableA est vrai et variable B est faux, alors -

Afficher des exemples

Opérateur	La description	Exemple
et	Appelé opérateur booléen AND. Si les deux opérandes sont vrais, la condition devient vraie.	(A et B) est faux.
et alors	Il est similaire à l'opérateur AND, cependant, il garantit l'ordre dans lequel le compilateur évalue l'expression logique. Les opérandes de gauche à droite et de droite ne sont évalués que lorsque cela est nécessaire.	(A puis B) est faux.
ou	Opérateur OR booléen appelé. Si l'un des deux opérandes est vrai, la condition devient vraie.	(A ou B) est vrai.
ou sinon	Il est similaire à Boolean OR, cependant, il garantit l'ordre dans lequel le compilateur évalue l'expression logique. Les opérandes de gauche à droite et de droite ne sont évalués que lorsque cela est nécessaire.	(A ou bien B) est vrai.
ne pas	Opérateur Boolean NOT appelé. Utilisé pour inverser l'état logique de son opérande. Si une condition est vraie, alors l'opérateur logique NOT la rendra fausse.	not (A et B) est vrai.

Opérateurs de bits

Les opérateurs au niveau du bit fonctionnent sur les bits et effectuent des opérations bit par bit. Tous ces opérateurs travaillent sur des opérandes entiers et produisent des résultats entiers. La table de vérité pour les bits et (&), les bits ou (|) et les bits non (~) est la suivante:

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

Supposons que A = 60; et B = 13; maintenant au format binaire, ils seront comme suit -

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A ^ B = 0011 0001

~ A = 1100 0011

Les opérateurs Bitwise pris en charge par Pascal sont répertoriés dans le tableau suivant. Supposons que la variable A a 60 et la variable B 13, alors:

Afficher des exemples

Opérateur	La description	Exemple
&	L'opérateur binaire AND copie un peu le résultat s'il existe dans les deux opérandes.	(A & B) donnera 12, soit 0000 1100
|	L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes.	(A | B) donnera 61, soit 0011 1101
!	L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes. C'est la même chose que | opérateur.	(A! B) donnera 61, soit 0011 1101
~	L'opérateur de complément Binary Ones est unaire et a pour effet de «retourner» les bits.	(~ A) donnera -61, soit 1100 0011 sous la forme du complément à 2 en raison d'un nombre binaire signé.
<<	Opérateur de décalage binaire gauche. La valeur des opérandes de gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande de droite.	Un << 2 donnera 240, soit 1111 0000
>>	Opérateur de décalage binaire vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite.	Un >> 2 donnera 15, soit 0000 1111

Veuillez noter que les différentes implémentations de Pascal diffèrent par les opérateurs bit à bit. Free Pascal, le compilateur que nous avons utilisé ici, prend cependant en charge les opérateurs de bits suivants -

Les opérateurs	Opérations
ne pas	Pas au niveau du bit
et	ET au niveau du bit
ou	OU au niveau du bit
xor	OU exclusif au niveau du bit
shl	Décalage bit à gauche
Shr	Décalage binaire à droite
<<	Décalage bit à gauche
>>	Décalage binaire à droite

Priorité des opérateurs en Pascal

La priorité des opérateurs détermine le regroupement des termes dans une expression. Cela affecte la manière dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d'autres; par exemple, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition.

Par exemple x = 7 + 3 * 2; ici, x est attribué à 13, et non à 20 car l'opérateur * a une priorité plus élevée que +, il est donc d'abord multiplié par 3 * 2, puis ajouté en 7.

Ici, les opérateurs avec la priorité la plus élevée apparaissent en haut du tableau, ceux avec la priorité la plus basse apparaissent en bas. Dans une expression, les opérateurs de priorité supérieure seront évalués en premier.

Afficher des exemples

Opérateur	Priorité
~, pas,	Le plus élevé
*, /, div, mod et, &
|,!, +, -, ou,
=, <>, <, <=,>,> =, dans
ou bien, et puis	Le plus bas

Les structures de prise de décision exigent que le programmeur spécifie une ou plusieurs conditions à évaluer ou à tester par le programme, ainsi qu'une ou plusieurs instructions à exécuter si la condition est jugée vraie, et éventuellement d'autres instructions à exécuter si la condition est déterminé comme étant faux.

Voici la forme générale d'une structure de prise de décision typique trouvée dans la plupart des langages de programmation -

Le langage de programmation Pascal fournit les types suivants d'énoncés de prise de décision. Cliquez sur les liens suivants pour vérifier leurs détails.

Sr.Non	Déclaration et description
1	if - instruction alors Un if - then statement se compose d'une expression booléenne suivie d'une ou plusieurs instructions.
2	Instruction If-then-else Un if - then statement peut être suivi d'une option else statement, qui s'exécute lorsque l'expression booléenne est fausse.
3	instructions if imbriquées Vous pouvez en utiliser un if ou else if déclaration dans un autre if ou else if déclaration (s).
4	déclaration de cas UNE case L'instruction permet à une variable d'être testée pour l'égalité par rapport à une liste de valeurs.
5	case - instruction else Il est similaire au if-then-else déclaration. Ici, unelse terme suit le case statement.
6	instructions de cas imbriquées Vous pouvez en utiliser un case déclaration dans un autre case déclaration (s).

Il peut arriver que vous deviez exécuter un bloc de code plusieurs fois. En général, les instructions sont exécutées de manière séquentielle: la première instruction d'une fonction est exécutée en premier, suivie de la seconde, et ainsi de suite.

Les langages de programmation fournissent diverses structures de contrôle qui permettent des chemins d'exécution plus compliqués.

Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois et voici la forme générale d'une instruction de boucle dans la plupart des langages de programmation -

Le langage de programmation Pascal fournit les types suivants de constructions de boucle pour gérer les exigences de boucle. Cliquez sur les liens suivants pour vérifier leurs détails.

Sr.Non	Type de boucle et description
1	boucle while-do Répète une instruction ou un groupe d'instructions tant qu'une condition donnée est vraie. Il teste la condition avant d'exécuter le corps de la boucle.
2	boucle for-do Exécute une séquence d'instructions plusieurs fois et abrége le code qui gère la variable de boucle.
3	boucle de répétition jusqu'à Comme une instruction while, sauf qu'elle teste la condition à la fin du corps de la boucle.
4	boucles imbriquées Vous pouvez utiliser une ou plusieurs boucles dans n'importe quelle autre boucle while, for ou répéter jusqu'à boucle.

Déclarations de contrôle de boucle

Les instructions de contrôle de boucle modifient l'exécution de sa séquence normale. Lorsque l'exécution quitte une étendue, tous les objets automatiques qui ont été créés dans cette étendue sont détruits.

Pascal prend en charge les instructions de contrôle suivantes. Cliquez sur les liens suivants pour vérifier leurs détails.

Sr.Non	Déclaration de contrôle et description
1	déclaration break Met fin au loop ou case et transfère l'exécution à l'instruction immédiatement après l'instruction de boucle ou de cas.
2	continue déclaration Force la boucle à ignorer le reste de son corps et à retester immédiatement son état avant de réitérer.
3	déclaration goto Transfère le contrôle vers l'instruction étiquetée. Bien qu'il ne soit pas conseillé d'utiliser l'instruction goto dans votre programme.

Sous-programmes

Un sous-programme est une unité / module de programme qui exécute une tâche particulière. Ces sous-programmes sont combinés pour former des programmes plus vastes. C'est ce qu'on appelle fondamentalement la «conception modulaire». Un sous-programme peut être appelé par un sous-programme / programme, appelé programme appelant.

Pascal propose deux types de sous-programmes -

• Functions - ces sous-programmes renvoient une valeur unique.

• Procedures - ces sous-programmes ne renvoient pas directement de valeur.

Les fonctions

UNE functionest un groupe d'instructions qui exécutent ensemble une tâche. Chaque programme Pascal a au moins une fonction, qui est le programme lui-même, et tous les programmes les plus triviaux peuvent définir des fonctions supplémentaires.

Une fonction declarationindique au compilateur le nom, le type de retour et les paramètres d'une fonction. Une fonctiondefinition fournit le corps réel de la fonction.

La bibliothèque standard Pascal fournit de nombreuses fonctions intégrées que votre programme peut appeler. Par exemple, fonctionAppendStr() ajoute deux chaînes, fonction New() alloue dynamiquement de la mémoire aux variables et à bien d'autres fonctions.

Définition d'une fonction

Chez Pascal, un functionest défini à l'aide du mot-clé function. La forme générale d'une définition de fonction est la suivante -

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

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

Une définition de fonction en Pascal consiste en une fonction header, local declarations et une fonction body. L'en-tête de la fonction se compose de la fonction mot-clé et d'unnamedonné à la fonction. Voici toutes les parties d'une fonction -

• Arguments- Le ou les arguments établissent le lien entre le programme appelant et les identificateurs de fonction et également appelés paramètres formels. Un paramètre est comme un espace réservé. Lorsqu'une fonction est appelée, vous transmettez une valeur au paramètre. Cette valeur est appelée paramètre ou argument réel. La liste des paramètres fait référence au type, à l'ordre et au nombre de paramètres d'une fonction. L'utilisation de tels paramètres formels est facultative. Ces paramètres peuvent avoir un type de données standard, un type de données défini par l'utilisateur ou un type de données de sous-plage.

  La liste des paramètres formels apparaissant dans l'instruction de fonction peut être des variables simples ou en indice, des tableaux ou des variables structurées, ou des sous-programmes.

• Return Type- Toutes les fonctions doivent renvoyer une valeur, toutes les fonctions doivent donc se voir attribuer un type. lefunction-typeest le type de données de la valeur renvoyée par la fonction. Il peut être de type scalaire ou de sous-plage standard, défini par l'utilisateur, mais il ne peut pas être de type structuré.

• Local declarations - Les déclarations locales font référence aux déclarations d'étiquettes, de constantes, de variables, de fonctions et de procédures, qui s'appliquent uniquement au corps de la fonction.

• Function Body- Le corps de la fonction contient une collection d'instructions qui définissent ce que fait la fonction. Il doit toujours être placé entre les mots réservés de début et de fin. C'est la partie d'une fonction où tous les calculs sont effectués. Il doit y avoir une instruction d'affectation du type -name := expression;dans le corps de la fonction qui attribue une valeur au nom de la fonction. Cette valeur est renvoyée au fur et à mesure de l'exécution de la fonction. La dernière instruction du corps doit être une instruction de fin.

Voici un exemple montrant comment définir une fonction dans pascal -

(* 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;

Déclarations de fonction

Une fonction declarationindique au compilateur un nom de fonction et comment appeler la fonction. Le corps réel de la fonction peut être défini séparément.

Une déclaration de fonction comprend les parties suivantes -

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

Pour la fonction max () définie ci-dessus, voici la déclaration de fonction -

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

La déclaration de fonction est requise lorsque vous définissez une fonction dans un fichier source et que vous appelez cette fonction dans un autre fichier. Dans ce cas, vous devez déclarer la fonction en haut du fichier appelant la fonction.

Appeler une fonction

Lors de la création d'une fonction, vous donnez une définition de ce que la fonction doit faire. Pour utiliser une fonction, vous devrez appeler cette fonction pour exécuter la tâche définie. Lorsqu'un programme appelle une fonction, le contrôle du programme est transféré à la fonction appelée. Une fonction appelée exécute une tâche définie, et lorsque son instruction return est exécutée ou lorsque la dernière instruction end est atteinte, elle renvoie le contrôle du programme au programme principal.

Pour appeler une fonction, vous devez simplement transmettre les paramètres requis avec le nom de la fonction, et si la fonction renvoie une valeur, vous pouvez stocker la valeur renvoyée. Voici un exemple simple pour montrer l'utilisation -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Max value is : 200

Procedures sont des sous-programmes qui, au lieu de renvoyer une seule valeur, permettent d'obtenir un groupe de résultats.

Définition d'une procédure

En Pascal, une procédure est définie à l'aide du proceduremot-clé. La forme générale d'une définition de procédure est la suivante -

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

Une procédure definition en Pascal se compose d'un header, local declarations et un bodyde la procédure. L'en-tête de la procédure se compose du mot-cléprocedureet un nom donné à la procédure. Voici toutes les parties d'une procédure -

• Arguments- Le ou les arguments établissent le lien entre le programme appelant et les identificateurs de procédure et sont également appelés paramètres formels. Les règles des arguments dans les procédures sont les mêmes que celles des fonctions.

• Local declarations - Les déclarations locales font référence aux déclarations d'étiquettes, de constantes, de variables, de fonctions et de procédures, qui ne s'appliquent qu'au corps de la procédure.

• Procedure Body- Le corps de la procédure contient une collection d'instructions qui définissent ce que fait la procédure. Il doit toujours être placé entre les mots réservés de début et de fin. C'est la partie d'une procédure où tous les calculs sont effectués.

Voici le code source d'une procédure appelée findMin () . Cette procédure prend 4 paramètres x, y, z et m et stocke le minimum parmi les trois premières variables dans la variable nommée m. La variable m est passée parreference (nous discuterons des arguments de passage par référence un peu plus tard) -

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 }

Déclarations de procédure

Une procédure declarationindique au compilateur un nom de procédure et comment appeler la procédure. Le corps réel de la procédure peut être défini séparément.

Une déclaration de procédure a la syntaxe suivante -

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

Veuillez noter que le name of the procedure is not associated with any type. Pour la procédure définie ci-dessus findMin () , voici la déclaration -

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

Appel d'une procédure

Lors de la création d'une procédure, vous donnez une définition de ce que la procédure doit faire. Pour utiliser la procédure, vous devrez appeler cette procédure pour exécuter la tâche définie. Lorsqu'un programme appelle une procédure, le contrôle du programme est transféré à la procédure appelée. Une procédure appelée exécute la tâche définie et lorsque sa dernière instruction de fin est atteinte, elle renvoie le contrôle au programme appelant.

Pour appeler une procédure, il vous suffit de transmettre les paramètres requis avec le nom de la procédure comme indiqué ci-dessous -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Enter three numbers:
89 45 67
Minimum: 45

Sous-programmes récursifs

Nous avons vu qu'un programme ou sous-programme peut appeler un autre sous-programme. Lorsqu'un sous-programme s'appelle lui-même, il est appelé appel récursif et le processus est appelé récursivité.

Pour illustrer le concept, calculons la factorielle d'un nombre. La factorielle d'un nombre n est définie comme -

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

Le programme suivant calcule la factorielle d'un nombre donné en s'appelant lui-même récursivement.

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Enter a number:
5
Factorial 5 is: 120

Voici un autre exemple, qui génère le Fibonacci Series pour un nombre donné en utilisant un recursive fonction -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

0 1 1 2	3 5 8 13 21 34

Arguments d'un sous-programme

Si un sous-programme (function or procedure) consiste à utiliser des arguments, il doit déclarer des variables qui acceptent les valeurs des arguments. Ces variables sont appeléesformal parameters du sous-programme.

Les paramètres formels se comportent comme les autres variables locales à l'intérieur du sous-programme et sont créés à l'entrée dans le sous-programme et détruits à la sortie.

Lors de l'appel d'un sous-programme, il existe deux façons de transmettre des arguments au sous-programme -

Sr.Non	Type d'appel et description
1	Appel par valeur Cette méthode copie la valeur réelle d'un argument dans le paramètre formel du sous-programme. Dans ce cas, les modifications apportées au paramètre à l'intérieur du sous-programme n'ont aucun effet sur l'argument.
2	Appel par référence Cette méthode copie l'adresse d'un argument dans le paramètre formel. À l'intérieur du sous-programme, l'adresse est utilisée pour accéder à l'argument réel utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affectent l'argument.

Par défaut, Pascal utilise call by valuepour passer des arguments. En général, cela signifie que le code dans un sous-programme ne peut pas modifier les arguments utilisés pour appeler le sous-programme. L'exemple de programme que nous avons utilisé dans le chapitre 'Pascal - Fonctions' a appelé la fonction nommée max () en utilisantcall by value.

Alors que l'exemple de programme fourni ici ( exProcedure ) appelle la procédure findMin () en utilisantcall by reference.

Une portée dans toute programmation est une région du programme où une variable définie peut avoir son existence et au-delà de cette variable ne peut pas être accédée. Il y a trois endroits où les variables peuvent être déclarées en langage de programmation Pascal -

• À l'intérieur d'un sous-programme ou d'un bloc appelé variables locales

• En dehors de tous les sous-programmes appelés variables globales

• Dans la définition des paramètres de sous-programme, appelés paramètres formels

Expliquons ce que sont local et global variables et paramètres formels.

Variables locales

Les variables déclarées dans un sous-programme ou un bloc sont appelées variables locales. Ils ne peuvent être utilisés que par des instructions qui se trouvent à l'intérieur de ce sous-programme ou bloc de code. Les variables locales ne sont pas connues des sous-programmes en dehors des leurs. Voici l'exemple utilisant des variables locales. Ici, toutes les variables a , b et c sont locales au programme nommé 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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of a = 10 b = 20 c = 30

Maintenant, étendons un peu plus le programme, créons une procédure nommée display, qui aura son propre ensemble de variables a , b et c et affichera leurs valeurs, directement depuis le programme exLocal .

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Variables globales

Les variables globales sont définies en dehors d'une fonction, généralement au-dessus du programme. Les variables globales conserveront leur valeur pendant toute la durée de vie de votre programme et elles peuvent être accédées à l'intérieur de l'une des fonctions définies pour le programme.

UNE globalvariable est accessible par n'importe quelle fonction. Autrement dit, une variable globale est disponible pour une utilisation dans tout votre programme après sa déclaration. Voici un exemple d'utilisationglobal et local variables -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Veuillez noter que l'affichage de la procédure a accès aux variables a, b et c, qui sont des variables globales par rapport à l'affichage ainsi qu'à ses propres variables locales. Un programme peut avoir le même nom pour les variables locales et globales mais la valeur de la variable locale à l'intérieur d'une fonction aura la préférence.

Modifions un peu l'exemple précédent, maintenant les variables locales pour l'affichage de la procédure ont les mêmes noms que 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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

La chaîne en Pascal est en fait une séquence de caractères avec une spécification de taille facultative. Les caractères peuvent être numériques, lettres, blancs, caractères spéciaux ou une combinaison de tous. Extended Pascal fournit de nombreux types d'objets chaîne en fonction du système et de l'implémentation. Nous discuterons des types de chaînes plus courants utilisés dans les programmes.

Vous pouvez définir une chaîne de plusieurs manières -

• Character arrays - Il s'agit d'une chaîne de caractères qui est une séquence de zéro caractères ou plus de la taille d'un octet entre guillemets simples.

• String variables - La variable de type String, telle que définie dans Turbo Pascal.

• Short strings - La variable de type String avec spécification de taille.

• Null terminated strings - La variable de pchar type.

• AnsiStrings - Les réponses sont des chaînes sans limite de longueur.

Pascal fournit un seul opérateur de chaîne, l'opérateur de concaténation de chaînes (+).

Exemples

Le programme suivant imprime les quatre premiers types de chaînes. Nous utiliserons AnsiStrings dans l'exemple suivant.

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

L'exemple suivant utilise quelques fonctions supplémentaires, voyons -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Fonctions et procédures Pascal String

Pascal prend en charge un large éventail de fonctions et de procédures qui manipulent des chaînes. Ces sous-programmes varient d'un outil à l'autre. Ici, nous listons divers sous-programmes de manipulation de chaînes fournis par Free Pascal -

Sr.No.	Fonction et objectif
1	function AnsiCompareStr(const S1: ; const S2:):Integer; Compare deux chaînes
2	function AnsiCompareText(const S1: ; const S2:):Integer; Compare deux chaînes, insensible à la casse
3	function AnsiExtractQuotedStr(var Src: PChar; Quote: Char):; Supprime les guillemets de la chaîne
4	function AnsiLastChar(const S:):PChar; Obtient le dernier caractère de la chaîne
5	function AnsiLowerCase(const s:): Convertit la chaîne en minuscules
6	function AnsiQuotedStr(const S: ; Quote: Char):; Cite une chaîne
sept	function AnsiStrComp(S1: PChar;S2: PChar):Integer; Compare les chaînes sensibles à la casse
8	function AnsiStrIComp(S1: PChar; S2: PChar):Integer; Compare les chaînes insensibles à la casse
9	function AnsiStrLComp(S1: PChar; S2: PChar; MaxLen: Cardinal):Integer; Compare les caractères L des chaînes sensibles à la casse
dix	function AnsiStrLIComp(S1: PChar; S2: PChar; MaxLen: Cardinal):Integer; Compare les caractères L des chaînes insensibles à la casse
11	function AnsiStrLastChar(Str: PChar):PChar; Obtient le dernier caractère de la chaîne
12	function AnsiStrLower(Str: PChar):PChar; Convertit la chaîne en minuscules
13	function AnsiStrUpper(Str: PChar):PChar; Convertit la chaîne en majuscules
14	function AnsiUpperCase(const s:):; Convertit la chaîne en majuscules
15	procedure AppendStr(var Dest: ; const S:); Ajoute 2 chaînes
16	procedure AssignStr(var P: PString; const S:); Attribue la valeur des chaînes sur le tas
17	function CompareStr(const S1: ; const S2:):Integer; overload; Compare deux chaînes sensibles à la casse
18	function CompareText(const S1: ; const S2:):Integer; Compare deux chaînes insensible à la casse
19	procedure DisposeStr(S: PString); overload; Supprime la chaîne du tas
20	procedure DisposeStr(S: PShortString); overload; Supprime la chaîne du tas
21	function IsValidIdent( const Ident:):Boolean; La chaîne est-elle un identifiant pascal valide
22	function LastDelimiter(const Delimiters: ; const S:):Integer; Dernière occurrence de caractère dans une chaîne
23	function LeftStr(const S: ; Count: Integer):; Obtient les N premiers caractères d'une chaîne
24	function LoadStr(Ident: Integer):; Charge la chaîne à partir des ressources
25	function LowerCase(const s: ):; overload; Convertit la chaîne en minuscules
26	function LowerCase(const V: variant ):; overload; Convertit la chaîne en minuscules
27	function NewStr(const S:):PString; overload; Alloue une nouvelle chaîne sur le tas
28	function RightStr(const S: ; Count: Integer):; Obtient les N derniers caractères d'une chaîne
29	function StrAlloc(Size: Cardinal):PChar; Alloue de la mémoire pour la chaîne
30	function StrBufSize(Str: PChar):SizeUInt; Réserve de la mémoire pour une chaîne
31	procedure StrDispose(Str: PChar); Supprime la chaîne du tas
32	function StrPas(Str: PChar):; Convertit PChar en chaîne pascal
33	function StrPCopy(Dest: PChar; Source:):PChar; Copie la chaîne pascal
34	function StrPLCopy(Dest: PChar; Source: ; MaxLen: SizeUInt):PChar; Copie N octets de chaîne pascal
35	function UpperCase(const s:):; Convertit la chaîne en majuscules

Pascal fournit le type de données Boolean qui permet aux programmeurs de définir, stocker et manipuler des entités logiques, telles que des constantes, des variables, des fonctions et des expressions, etc.

Les valeurs booléennes sont essentiellement de type entier. Les variables de type booléen ont deux valeurs possibles prédéfiniesTrue et False. Les expressions résolvant en une valeur booléenne peuvent également être affectées à un type booléen.

Free Pascal prend également en charge le ByteBool, WordBool et LongBoolles types. Ceux-ci sont de type Byte, Word ou Longint, respectivement.

La valeur False est équivalente à 0 (zéro) et toute valeur différente de zéro est considérée comme True lors de la conversion en valeur booléenne. Une valeur booléenne de True est convertie en -1 au cas où elle serait affectée à une variable de type LongBool.

Il est à noter que les opérateurs logiques and, or et not sont définis pour les types de données booléens.

Déclaration des types de données booléens

Une variable de type booléen est déclarée à l'aide du mot clé var.

var
boolean-identifier: boolean;

par exemple,

var
choice: boolean;

Exemple

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Le langage de programmation Pascal fournit une structure de données appelée tableau, qui peut stocker une collection séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection de données, mais il est souvent plus utile de considérer un tableau comme une collection de variables du même type.

Au lieu de déclarer des variables individuelles, telles que nombre1, nombre2, ... et nombre100, vous déclarez une variable de tableau telle que des nombres et utilisez les nombres [1], les nombres [2] et ..., les nombres [100] pour représenter variables individuelles. Un élément spécifique d'un tableau est accessible par un index.

Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse correspond au premier élément et l'adresse la plus élevée au dernier élément.

Veuillez noter que si vous voulez un tableau de style C à partir de l'index 0, il vous suffit de démarrer l'index à partir de 0, au lieu de 1.

Déclaration de tableaux

Pour déclarer un tableau en Pascal, un programmeur peut soit déclarer le type puis créer des variables de ce tableau, soit déclarer directement la variable tableau.

La forme générale de la déclaration de type d'un tableau à une dimension est -

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

Où,

• array-identifier - indique le nom du type de tableau.

• index-type- spécifie l'indice du tableau; il peut s'agir de n'importe quel type de données scalaires sauf réel

• element-type - spécifie les types de valeurs qui vont être stockées

Par exemple,

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

Maintenant, la vitesse est un tableau variable de type vectoriel, qui est suffisant pour contenir jusqu'à 25 nombres réels.

Pour démarrer le tableau à partir de 0 index, la déclaration serait -

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

Types d'indice de tableau

En Pascal, un indice de tableau peut être de n'importe quel type scalaire comme, entier, booléen, énuméré ou sous-intervalle, sauf réel. Les indices de tableau peuvent également avoir des valeurs négatives.

Par exemple,

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

Prenons un autre exemple où l'indice est de type caractère -

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

L'indice peut être de type énuméré -

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

Initialisation des tableaux

En Pascal, les tableaux sont initialisés par affectation, soit en spécifiant un indice particulier, soit en utilisant une boucle for-do.

Par exemple -

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 *)

Accès aux éléments de la baie

Un élément est accessible en indexant le nom du tableau. Cela se fait en plaçant l'index de l'élément entre crochets après le nom du tableau. Par exemple -

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

L'instruction ci-dessus prendra le premier élément du tableau nommé alphabet et affectera la valeur à la variable a.

Voici un exemple, qui utilisera tous les trois concepts mentionnés ci-dessus à savoir. déclaration, affectation et accès aux tableaux -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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 en détail

Les tableaux sont importants pour Pascal et devraient avoir besoin de beaucoup plus de détails. Voici quelques concepts importants liés au tableau qui devraient être clairs pour un programmeur Pascal -

Sr.Non	Concept et description
1	Tableaux multidimensionnels Pascal prend en charge les tableaux multidimensionnels. La forme la plus simple du tableau multidimensionnel est le tableau à deux dimensions.
2	Tableau dynamique Dans ce type de tableaux, la longueur initiale est zéro. La longueur réelle du tableau doit être définie avec la normeSetLength fonction.
3	Tableau emballé Ces tableaux sont remplis de bits, c'est-à-dire que chaque caractère ou valeur de vérité est stocké dans des octets consécutifs au lieu d'utiliser une unité de stockage, généralement un mot (4 octets ou plus).
4	Passer des tableaux à des sous-programmes Vous pouvez passer à un sous-programme un pointeur vers un tableau en spécifiant le nom du tableau sans index.

Les pointeurs en Pascal sont faciles et amusants à apprendre. Certaines tâches de programmation Pascal sont exécutées plus facilement avec des pointeurs, et d'autres tâches, telles que l'allocation de mémoire dynamique, ne peuvent pas être effectuées sans l'utilisation de pointeurs. Il devient donc nécessaire d'apprendre les pointeurs pour devenir un parfait programmeur Pascal. Commençons à les apprendre par étapes simples et faciles.

Comme vous le savez, chaque variable est un emplacement de mémoire et chaque emplacement de mémoire a son adresse définie qui peut être accédée en utilisant le nom de la variable de pointeur, qui désigne une adresse en mémoire.

Que sont les pointeurs?

Un pointeur est une variable dynamique, dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe de l'emplacement mémoire. Comme toute variable ou constante, vous devez déclarer un pointeur avant de pouvoir l'utiliser pour stocker une adresse de variable. La forme générale d'une déclaration de variable de pointeur est -

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

Le type de pointeur est défini en préfixant la flèche vers le haut du symbole caret (^) avec le type de base. Le type de base définit les types des éléments de données. Une fois qu'une variable de pointeur est définie comme étant d'un certain type, elle ne peut pointer que des éléments de données de ce type. Une fois qu'un type de pointeur a été défini, nous pouvons utiliser levar déclaration pour déclarer des variables de pointeur.

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

Voici quelques déclarations de pointeur valides -

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;

Les variables de pointeur sont déréférencées à l'aide du même symbole d'insertion (^). Par exemple, la variable associée référencée par un pointeur rptr , est rptr ^ . Il peut être consulté comme -

rptr^ := 234.56;

L'exemple suivant illustrera ce concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Impression d'une adresse mémoire en Pascal

En Pascal, nous pouvons affecter l'adresse d'une variable à une variable pointeur en utilisant l'opérateur d'adresse (@). Nous utilisons ce pointeur pour manipuler et accéder à l'élément de données. Cependant, si pour une raison quelconque, nous devons travailler avec l'adresse mémoire elle-même, nous devons la stocker dans une variable de type mot.

Prolongeons l'exemple ci-dessus pour imprimer l'adresse mémoire stockée dans le pointeur iptr -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Pointeurs NIL

Il est toujours bon d'attribuer un NILvaleur à une variable de pointeur au cas où vous n'avez pas d'adresse exacte à attribuer. Cela se fait au moment de la déclaration des variables. Un pointeur attribuéNILne pointe nulle part. Considérez le programme suivant -

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

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

The value of ptr is 0

Pour vérifier un nil pointeur, vous pouvez utiliser une instruction if comme suit -

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

Pascal Pointers en détail

Les pointeurs ont des concepts nombreux mais simples et ils sont très importants pour la programmation Pascal. Voici quelques concepts de pointeurs importants, qui devraient être clairs pour un programmeur Pascal -

Sr.Non	Concept et description
1	Pascal - Arithmétique du pointeur Il existe quatre opérateurs arithmétiques qui peuvent être utilisés sur les pointeurs: incrémenter, décrémenter, +, -
2	Pascal - Tableau de pointeurs Vous pouvez définir des tableaux pour contenir un certain nombre de pointeurs.
3	Pascal - Pointeur vers pointeur Pascal vous permet d'avoir un pointeur sur un pointeur et ainsi de suite.
4	Passer des pointeurs vers des sous-programmes en Pascal Le passage d'un argument par référence ou par adresse permet tous deux de modifier l'argument passé dans le sous-programme appelant par le sous-programme appelé.
5	Renvoyer le pointeur des sous-programmes en Pascal Pascal permet à un sous-programme de renvoyer un pointeur.

Les tableaux Pascal vous permettent de définir le type de variables pouvant contenir plusieurs éléments de données du même type, mais un enregistrement est un autre type de données défini par l'utilisateur disponible dans Pascal qui vous permet de combiner des éléments de données de différents types.

Les enregistrements se composent de différents champs. Supposons que vous souhaitiez garder une trace de vos livres dans une bibliothèque, vous souhaiterez peut-être suivre les attributs suivants pour chaque livre -

• Title
• Author
• Subject
• ID du livre

Définition d'un enregistrement

Pour définir un type d'enregistrement, vous pouvez utiliser l'instruction de déclaration de type. Le type d'enregistrement est défini comme -

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

Voici la façon dont vous déclareriez l'enregistrement du livre -

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;

Les variables d'enregistrement sont définies de la manière habituelle comme

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

Vous pouvez également définir directement une variable de type d'enregistrement comme -

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;

Accès aux champs d'un enregistrement

Pour accéder à n'importe quel champ d'un enregistrement, nous utilisons l'opérateur d'accès aux membres (.). L'opérateur d'accès aux membres est codé comme un point entre le nom de la variable d'enregistrement et le champ auquel nous souhaitons accéder. Voici l'exemple pour expliquer l'utilisation de la structure -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Enregistrements en tant qu'arguments de sous-programme

Vous pouvez transmettre un enregistrement en tant qu'argument de sous-programme de la même manière que vous transmettez toute autre variable ou pointeur. Vous accéderiez aux champs d'enregistrement de la même manière que vous avez accédé dans l'exemple ci-dessus -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Pointeurs vers des enregistrements

Vous pouvez définir des pointeurs vers des enregistrements de la même manière que vous définissez le pointeur vers n'importe quelle autre variable comme suit -

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

Vous pouvez maintenant stocker l'adresse d'une variable de type d'enregistrement dans la variable de pointeur définie ci-dessus. Pour déclarer une variable du type pointeur créé, vous utilisez le mot-clé var -

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

Avant d'utiliser ces pointeurs, vous devez créer un stockage pour une variable de type de nom d'enregistrement, qui sera manipulée par ces pointeurs.

new(r1);
new(r2);

Pour accéder aux membres d'un enregistrement à l'aide d'un pointeur vers cet enregistrement, vous devez utiliser ^. opérateur comme suit -

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

Enfin, n'oubliez pas de jeter le stockage utilisé, lorsqu'il n'est plus utilisé -

dispose(r1);
dispose(r2);

Réécrivons le premier exemple en utilisant un pointeur vers l'enregistrement Books. J'espère que ce sera facile pour vous de comprendre le concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

La déclaration With

Nous avons discuté du fait que les membres d'un enregistrement sont accessibles à l'aide de l'opérateur d'accès aux membres (.). De cette façon, le nom de la variable d'enregistrement doit être écrit à chaque fois. leWith La déclaration fournit une autre façon de le faire.

Regardez l'extrait de code suivant extrait de notre premier exemple -

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

Le même devoir peut être rédigé en utilisant le With déclaration comme -

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

Pascal prend en charge un type unique de stockage nommé variants. Vous pouvez affecter n'importe quel type simple de valeurs dans une variable variant. Le type d'une valeur stockée dans une variante n'est déterminé qu'au moment de l'exécution. Presque tous les types simples peuvent être affectés à des variantes: types ordinaux, types chaîne, types int64.

Les types structurés tels que les ensembles, les enregistrements, les tableaux, les fichiers, les objets et les classes ne sont pas compatibles avec les affectations avec une variante. Vous pouvez également affecter un pointeur à une variante.

Free Pascal prend en charge les variantes.

Déclarer une variante

Vous pouvez déclarer un type de variante comme tout autre type en utilisant le varmot-clé. La syntaxe pour déclarer un type variant est -

var
   v: variant;

Maintenant, cette variable variable v peut être affectée à presque tous les types simples, y compris les types énumérés et vice versa.

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;

Exemple

L'exemple suivant illustre le concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Un ensemble est une collection d'éléments du même type. Pascal permet de définir le type de données défini. Les éléments d'un ensemble sont appelés ses membres. En mathématiques, les ensembles sont représentés en entourant les membres entre accolades {} . Cependant, en Pascal, les éléments set sont placés entre crochets [], qui sont appelés constructeur d'ensemble.

Définition des types et des variables d'ensemble

Les types d'ensemble Pascal sont définis comme

type
set-identifier = set of base type;

Les variables de type set sont définies comme

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

ou,

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

Des exemples de déclaration de type d'ensemble valide sont -

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;

Définir les opérateurs

Vous pouvez effectuer les opérations d'ensemble suivantes sur les ensembles Pascal.

Sr.Non	Opérations et descriptions
1	Union Cela joint deux ensembles et donne un nouvel ensemble avec des membres des deux ensembles.
2	Difference Obtient la différence de deux ensembles et donne un nouvel ensemble avec des éléments qui ne sont communs à aucun des ensembles.
3	Intersection Obtient l'intersection de deux ensembles et donne un nouvel ensemble avec des éléments communs aux deux ensembles.
4	Inclusion Un ensemble P est inclus dans l'ensemble Q, si tous les éléments de P sont également dans Q mais pas l'inverse.
5	Symmetric difference Obtient la différence symétrique de deux ensembles et donne un ensemble d'éléments, qui se trouvent dans l'un des ensembles et non dans leur intersection.
6	In Il vérifie l'adhésion.

Le tableau suivant montre tous les opérateurs d'ensemble pris en charge par Free Pascal. Suppose queS1 et S2 sont deux jeux de caractères, tels que -

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

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

Opérateur	La description	Exemple
+	Union de deux ensembles	S1 + S2 donnera un ensemble ['a', 'b', 'c', 'd', 'e']
-	Différence de deux ensembles	S1 - S2 donnera un ensemble ['un B']
*	Intersection de deux ensembles	S1 * S2 donnera un ensemble ['c']
> <	Différence symétrique de deux ensembles	S1> <S2 donnera un ensemble ['a', 'b', 'd', 'e']
=	Vérifie l'égalité de deux ensembles	S1 = S2 donnera la valeur booléenne False
<>	Vérifie la non-égalité de deux ensembles	S1 <> S2 donnera la valeur booléenne True
<=	Contient (vérifie si un ensemble est un sous-ensemble de l'autre)	S1 <= S2 donnera la valeur booléenne False
Comprendre	Comprend un élément dans l'ensemble; au fond c'est l'union d'un ensemble et d'un élément du même type de base	Inclure (S1, ['d']) donnera un ensemble ['a B c d']
Exclure	Exclut un élément d'un ensemble; c'est fondamentalement la différence d'un ensemble et d'un élément du même type de base	Exclude (S2, ['d']) donnera un ensemble ['c', 'e']
Dans	Vérifie l'appartenance à un ensemble d'un élément dans un ensemble	['e'] dans S2 donne la valeur booléenne True

Exemple

L'exemple suivant illustre l'utilisation de certains de ces opérateurs -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Pascal traite un fichier comme une séquence de composants, qui doivent être de type uniforme. Le type d'un fichier est déterminé par le type des composants. Le type de données de fichier est défini comme -

type
file-name = file of base-type;

Où, le type de base indique le type des composants du fichier. Le type de base peut être n'importe quoi comme, entier, réel, booléen, énuméré, sous-plage, enregistrement, tableaux et ensembles sauf un autre type de fichier. Les variables d'un type de fichier sont créées à l'aide de la déclaration var -

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

Voici quelques exemples de définition de certains types de fichiers et variables de fichier -

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;

Création et écriture dans un fichier

Écrivons un programme qui créerait un fichier de données pour les dossiers des étudiants. Cela créerait un fichier nommé étudiants.dat et y inscrirait les données d'un étudiant -

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.

Une fois compilé et exécuté, le programme créait un fichier nommé étudiants.dat dans le répertoire de travail. Vous pouvez ouvrir le fichier à l'aide d'un éditeur de texte, comme le bloc-notes, pour consulter les données de John Smith.

Lecture à partir d'un fichier

Nous venons de créer et d'écrire dans un fichier nommé étudiants.dat. Maintenant, écrivons un programme qui lirait les données de l'étudiant à partir du fichier -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Fichiers en tant que paramètre de sous-programme

Pascal permet aux variables de fichier d'être utilisées comme paramètres dans les sous-programmes standard et définis par l'utilisateur. L'exemple suivant illustre ce concept. Le programme crée un fichier nommé rain.txt et stocke certaines données de pluie. Ensuite, il ouvre le fichier, lit les données et calcule les précipitations moyennes.

Veuillez noter que, 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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Fichiers texte

Un fichier texte, en Pascal, est constitué de lignes de caractères où chaque ligne se termine par un marqueur de fin de ligne. Vous pouvez déclarer et définir de tels fichiers comme -

type
file-name = text;

La différence entre un fichier normal de caractères et un fichier texte est qu'un fichier texte est divisé en lignes, chacune terminée par un marqueur de fin de ligne spécial, automatiquement inséré par le système. L'exemple suivant crée et écrit dans un fichier texte nommé contact.txt -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Enter the file name:
contact.txt 
Completed writing

Ajout à un fichier

Ajouter à un fichier signifie écrire dans un fichier existant qui contient déjà des données sans écraser le fichier. Le programme suivant illustre cela -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Fonctions de gestion de fichiers

Free Pascal fournit les fonctions / procédures suivantes pour la gestion des fichiers -

Sr.No.	Nom et description de la fonction
1	procedure Append(var t: Text); Ouvre un fichier en mode ajout
2	procedure Assign(out f: file; const Name:); Attribue un nom à un fichier
3	procedure Assign(out f: file; p: PChar); Attribue un nom à un fichier
4	procedure Assign(out f: file; c: Char); Attribue un nom à un fichier
5	procedure Assign(out f: TypedFile; const Name:); Attribue un nom à un fichier
6	procedure Assign(out f: TypedFile; p: PChar); Attribue un nom à un fichier
sept	procedure Assign(out f: TypedFile; c: Char); Attribue un nom à un fichier
8	procedure Assign(out t: Text; const s:); Attribue un nom à un fichier
9	procedure Assign(out t: Text; p: PChar); Attribue un nom à un fichier
dix	procedure Assign(out t: Text; c: Char); Attribue un nom à un fichier
11	procedure BlockRead(var f: file; var Buf; count: Int64; var Result: Int64); Lit les données d'un fichier en mémoire
12	procedure BlockRead(var f: file; var Buf; count: LongInt; var Result: LongInt); Lit les données d'un fichier en mémoire
13	procedure BlockRead(var f: file; var Buf; count: Cardinal; var Result: Cardinal); Lit les données d'un fichier en mémoire
14	procedure BlockRead(var f: file; var Buf; count: Word; var Result: Word); Lit les données d'un fichier en mémoire
15	procedure BlockRead(var f: file; var Buf; count: Word; var Result: Integer); Lit les données d'un fichier en mémoire
16	procedure BlockRead(var f: file; var Buf; count: Int64); Lit les données d'un fichier en mémoire
17	procedure BlockWrite(var f: file; const Buf; Count: Int64; var Result: Int64); Écrit des données de la mémoire dans un fichier
18	procedure BlockWrite(var f: file; const Buf; Count: LongInt; var Result: LongInt); Écrit des données de la mémoire dans un fichier
19	procedure BlockWrite(var f: file; const Buf; Count: Cardinal; var Result: Cardinal); Écrit des données de la mémoire dans un fichier
20	procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Word); Écrit des données de la mémoire dans un fichier
21	procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Integer); Écrit des données de la mémoire dans un fichier
22	procedure BlockWrite(var f: file; const Buf; Count: LongInt); Écrit des données de la mémoire dans un fichier
23	procedure Close(var f: file); Ferme un dossier
24	procedure Close(var t: Text); Ferme un dossier
25	function EOF(var f: file):Boolean; Vérifie la fin du fichier
26	function EOF(var t: Text):Boolean; Vérifie la fin du fichier
27	function EOF: Boolean; Vérifie la fin du fichier
28	function EOLn(var t: Text):Boolean; Vérifie la fin de la ligne
29	function EOLn: Boolean; Vérifie la fin de la ligne
30	procedure Erase(var f: file); Supprime le fichier du disque
31	procedure Erase(var t: Text); Supprime le fichier du disque
32	function FilePos( var f: file):Int64; Position dans le fichier
33	function FileSize(var f: file):Int64; Taille du fichier
34	procedure Flush(var t: Text); Écrit les tampons de fichiers sur le disque
35	function IOResult: Word; Renvoie le résultat de la dernière opération d'E / S de fichier
36	procedure Read(var F: Text; Args: Arguments); Lit un fichier dans une variable
37	procedure Read(Args: Arguments); Lit un fichier dans une variable
38	procedure ReadLn(var F: Text; Args: Arguments); Lit le fichier dans la variable et passe à la ligne suivante
39	procedure ReadLn(Args: Arguments); Lit le fichier dans la variable et passe à la ligne suivante
40	procedure Rename(var f: file; const s:); Renomme le fichier sur le disque
41	procedure Rename(var f: file; p: PChar); Renomme le fichier sur le disque
42	procedure Rename(var f: file; c: Char); Renomme le fichier sur le disque
43	procedure Rename(var t: Text; const s); Renommer le fichier sur le disque
44	procedure Rename(var t: Text; p: PChar); Renomme le fichier sur le disque
45	procedure Rename( var t: Text; c: Char); Renomme le fichier sur le disque
46	procedure Reset(var f: file; l: LongInt); Ouvre le fichier pour lecture
47	procedure Reset(var f: file); Ouvre le fichier pour lecture
48	procedure Reset(var f: TypedFile); Ouvre le fichier pour lecture
49	procedure Reset(var t: Text); Ouvre le fichier pour lecture
50	procedure Rewrite(var f: file; l: LongInt); Ouvre le fichier pour l'écriture
51	procedure Rewrite(var f: file); Ouvre le fichier pour l'écriture
52	procedure Rewrite(var f: TypedFile); Ouvre le fichier pour l'écriture
53	procedure Rewrite(var t: Text); Ouvre le fichier pour l'écriture
54	procedure Seek(var f: file; Pos: Int64); Définit la position du fichier
55	function SeekEOF(var t: Text):Boolean; Définit la position du fichier à la fin du fichier
56	function SeekEOF: Boolean; Définit la position du fichier à la fin du fichier
57	function SeekEOLn(var t: Text):Boolean; Définit la position du fichier à la fin de la ligne
58	function SeekEOLn: Boolean; Définit la position du fichier à la fin de la ligne
59	procedure SetTextBuf(var f: Text; var Buf); Définit la taille du tampon de fichier
60	procedure SetTextBuf(var f: Text; var Buf; Size: SizeInt); Définit la taille du tampon de fichier
61	procedure Truncate(var F: file); Tronquer le fichier à la position
62	procedure Write(Args: Arguments); Écrit la variable dans le fichier
63	procedure Write(var F: Text; Args: Arguments); Ecrire une variable dans un fichier
64	procedure Writeln(Args: Arguments); Écrit la variable dans le fichier et ajoute une nouvelle ligne
65	procedure WriteLn(var F: Text; Args: Arguments); Écrit la variable dans le fichier et ajoute une nouvelle ligne

Ce chapitre explique la gestion dynamique de la mémoire dans Pascal. Le langage de programmation Pascal fournit plusieurs fonctions pour l'allocation et la gestion de la mémoire.

Allocation dynamique de la mémoire

Lors de la programmation, si vous connaissez la taille d'un tableau, c'est facile et vous pouvez le définir comme un tableau. Par exemple, pour stocker le nom de n'importe quelle personne, il peut comporter au maximum 100 caractères afin que vous puissiez définir quelque chose comme suit -

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

Mais maintenant, considérons une situation dans laquelle vous n'avez aucune idée de la longueur du texte que vous devez stocker, par exemple, vous souhaitez stocker une description détaillée d'un sujet. Ici, nous devons définir un pointeur vers une chaîne sans définir la quantité de mémoire requise.

Pascal fournit une procédure newpour créer des variables de pointeur.

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Maintenant, si vous avez besoin de définir un pointeur avec un nombre spécifique d'octets à référencer ultérieurement, vous devez utiliser le getmem fonction ou le getmem procédure, qui a la syntaxe suivante -

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

function GetMem(
   size: PtrUInt
):pointer;

Dans l'exemple précédent, nous avons déclaré un pointeur vers une chaîne. Une chaîne a une valeur maximale de 255 octets. Si vous n'avez vraiment pas besoin de beaucoup d'espace, ou d'un espace plus grand, en termes d'octets, le sous-programme getmem permet de le spécifier. Réécrivons l' exemple précédent, en utilisant getmem -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Ainsi, vous avez un contrôle total et vous pouvez transmettre n'importe quelle valeur de taille tout en allouant de la mémoire contrairement aux tableaux, où une fois que vous avez défini la taille ne peut pas être modifiée.

Redimensionner et libérer la mémoire

Lorsque votre programme sort, le système d'exploitation libère automatiquement toute la mémoire allouée par votre programme, mais comme une bonne pratique lorsque vous n'avez plus besoin de mémoire, vous devez libérer cette mémoire.

Pascal fournit la procédure dispose pour libérer une variable créée dynamiquement à l'aide de la procédure new. Si vous avez alloué de la mémoire à l'aide du getmem sous-programme, vous devez alors utiliser le sous-programme freemempour libérer cette mémoire. Les sous-programmes freemem ont la syntaxe suivante -

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

function Freemem(
   p: pointer
):PtrUInt;

Vous pouvez également augmenter ou diminuer la taille d'un bloc de mémoire alloué en appelant la fonction ReAllocMem . Vérifions à nouveau le programme ci-dessus et utilisons les sous-programmes ReAllocMem et freemem . Voici la syntaxe de ReAllocMem -

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

Voici un exemple qui utilise les sous-programmes ReAllocMem et freemem -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Fonctions de gestion de la mémoire

Pascal fournit une foule de fonctions de gestion de la mémoire qui sont utilisées pour implémenter diverses structures de données et implémenter la programmation de bas niveau en Pascal. Beaucoup de ces fonctions dépendent de l'implémentation. Free Pascal fournit les fonctions et procédures suivantes pour la gestion de la mémoire -

SN	Nom et description de la fonction
1	function Addr(X: TAnytype):Pointer; Renvoie l'adresse de la variable
2	function Assigned(P: Pointer):Boolean; Vérifie si un pointeur est valide
3	function CompareByte(const buf1; const buf2; len: SizeInt):SizeInt; Compare 2 octets de mémoire tampon par octet
4	function CompareChar(const buf1; const buf2; len: SizeInt):SizeInt; Compare 2 octets de mémoire tampon par octet
5	function CompareDWord(const buf1; const buf2; len: SizeInt):SizeInt; Compare 2 octets de mémoire tampon par octet
6	function CompareWord(const buf1; const buf2; len: SizeInt):SizeInt; Compare 2 octets de mémoire tampon par octet
sept	function Cseg: Word; Renvoie le segment de code
8	procedure Dispose(P: Pointer); Libère la mémoire allouée dynamiquement
9	procedure Dispose(P: TypedPointer; Des: TProcedure); Libère la mémoire allouée dynamiquement
dix	function Dseg: Word; Renvoie le segment de données
11	procedure FillByte(var x; count: SizeInt; value: Byte); Remplit la région mémoire avec un motif 8 bits
12	procedure FillChar( var x; count: SizeInt; Value: Byte|Boolean|Char); Remplit la région mémoire avec un certain caractère
13	procedure FillDWord( var x; count: SizeInt; value: DWord); Remplit la région mémoire avec un motif 32 bits
14	procedure FillQWord( var x; count: SizeInt; value: QWord); Remplit la région mémoire avec un modèle 64 bits
15	procedure FillWord( var x; count: SizeInt; Value: Word); Remplit la région mémoire avec un motif 16 bits
16	procedure Freemem( p: pointer; Size: PtrUInt); Libère la mémoire allouée
17	procedure Freemem( p: pointer ); Libère la mémoire allouée
18	procedure Getmem( out p: pointer; Size: PtrUInt); Alloue une nouvelle mémoire
19	procedure Getmem( out p: pointer); Alloue une nouvelle mémoire
20	procedure GetMemoryManager( var MemMgr: TMemoryManager); Renvoie le gestionnaire de mémoire actuel
21	function High( Arg: TypeOrVariable):TOrdinal; Renvoie l'indice le plus élevé du tableau ouvert ou énuméré
22	function IndexByte( const buf; len: SizeInt; b: Byte):SizeInt; Recherche une valeur de la taille d'un octet dans une plage de mémoire
23	function IndexChar( const buf; len: SizeInt; b: Char):SizeInt; Recherche une valeur de la taille d'un caractère dans une plage de mémoire
24	function IndexDWord( const buf; len: SizeInt; b: DWord):SizeInt; Recherche une valeur DWord (32 bits) dans une plage de mémoire
25	function IndexQWord( const buf; len: SizeInt; b: QWord):SizeInt; Recherche une valeur de taille QWord dans une plage de mémoire
26	function Indexword( const buf; len: SizeInt; b: Word):SizeInt; Recherche une valeur de la taille d'un mot dans une plage de mémoire
27	function IsMemoryManagerSet: Boolean; Le gestionnaire de mémoire est-il défini
28	function Low( Arg: TypeOrVariable ):TOrdinal; Renvoie l'indice le plus bas du tableau ouvert ou énuméré
29	procedure Move( const source; var dest; count: SizeInt ); Déplace les données d'un emplacement de la mémoire à un autre
30	procedure MoveChar0( const buf1; var buf2; len: SizeInt); Déplace les données jusqu'au premier caractère zéro
31	procedure New( var P: Pointer); Allouer dynamiquement de la mémoire pour la variable
32	procedure New( var P: Pointer; Cons: TProcedure); Alloue dynamiquement de la mémoire pour la variable
33	function Ofs( var X ):LongInt; Renvoie le décalage de la variable
34	function ptr( sel: LongInt; off: LongInt):farpointer; Combine le segment et le décalage avec le pointeur
35	function ReAllocMem( var p: pointer; Size: PtrUInt):pointer; Redimensionne un bloc de mémoire sur le tas
36	function Seg( var X):LongInt; Renvoie le segment
37	procedure SetMemoryManager( const MemMgr: TMemoryManager ); Définit un gestionnaire de mémoire
38	function Sptr: Pointer; Renvoie le pointeur de pile actuel
39	function Sseg: Word; Renvoie la valeur du registre du segment de pile

Un programme Pascal peut être constitué de modules appelés unités. Une unité peut être constituée de certains blocs de code, qui à leur tour sont constitués de variables et de déclarations de type, d'instructions, de procédures, etc. Il existe de nombreuses unités intégrées dans Pascal et Pascal permet aux programmeurs de définir et d'écrire leurs propres unités à utiliser plus tard dans divers programmes.

Utilisation d'unités intégrées

Les unités intégrées et les unités définies par l'utilisateur sont incluses dans un programme par la clause uses. Nous avons déjà utilisé l'unité des variantes dans le didacticiel Pascal - Variantes . Ce didacticiel explique la création et l'inclusion d'unités définies par l'utilisateur. Cependant, voyons d'abord comment inclure une unité intégréecrt dans votre programme -

program myprog;
uses crt;

L'exemple suivant illustre l'utilisation du crt unité -

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.

C'est le même programme que nous avons utilisé au tout début du tutoriel Pascal, compilez-le et exécutez-le pour trouver les effets du changement.

Créer et utiliser une unité Pascal

Pour créer une unité, vous devez écrire les modules ou sous-programmes que vous souhaitez y stocker et l'enregistrer dans un fichier avec .pasextension. La première ligne de ce fichier doit commencer par le mot-clé unité suivi du nom de l'unité. Par exemple -

unit calculateArea;

Voici trois étapes importantes pour créer une unité Pascal -

• Le nom du fichier et le nom de l'unité doivent être exactement les mêmes. Ainsi, notre unité CalculateArea sera enregistrée dans un fichier nommé CalculateArea.pas.

• La ligne suivante doit être constituée d'un seul mot-clé interface. Après cette ligne, vous écrirez les déclarations pour toutes les fonctions et procédures qui viendront dans cette unité.

• Juste après les déclarations de fonction, écrivez le mot implementation, qui est à nouveau un mot-clé. Après la ligne contenant l'implémentation du mot-clé, fournissez la définition de tous les sous-programmes.

Le programme suivant crée l'unité nommée CalculateArea -

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.

Ensuite, écrivons un programme simple qui utiliserait l'unité que nous avons définie ci-dessus -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

La plupart des logiciels que vous écrivez doivent implémenter une forme de fonction de date renvoyant la date et l'heure actuelles. Les dates font tellement partie de la vie quotidienne qu'il devient facile de travailler avec elles sans réfléchir. Pascal fournit également des outils puissants pour l'arithmétique des dates qui facilitent la manipulation des dates. Cependant, le nom et le fonctionnement réels de ces fonctions sont différents pour différents compilateurs.

Obtenir la date et l'heure actuelles

La fonction TimeToString de Pascal vous donne l'heure actuelle sous une forme délimitée par deux points (:). L'exemple suivant montre comment obtenir l'heure actuelle -

program TimeDemo;
uses sysutils;

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

Lorsque le code ci-dessus a été compilé et exécuté, il produit le résultat suivant -

Current time : 18:33:08

le Date La fonction renvoie la date actuelle dans TDateTimeformat. Le TDateTime est une valeur double, qui nécessite un certain décodage et formatage. Le programme suivant montre comment l'utiliser dans votre programme pour afficher la date actuelle -

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.

Lorsque le code ci-dessus a été compilé et exécuté, il produit le résultat suivant -

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

La fonction Now renvoie la date et l'heure actuelles -

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

Lorsque le code ci-dessus a été compilé et exécuté, il produit le résultat suivant -

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

Free Pascal fournit une structure d'horodatage simple nommée TTimeStamp, qui a le format suivant -

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

Diverses fonctions de date et d'heure

Free Pascal fournit les fonctions de date et d'heure suivantes -

Sr.No.	Nom et description de la fonction
1	function DateTimeToFileDate(DateTime: TDateTime):LongInt; Convertit le type DateTime en date du fichier.
2	function DateTimeToStr( DateTime: TDateTime):; Construit une représentation sous forme de chaîne de DateTime
3	function DateTimeToStr(DateTime: TDateTime; const FormatSettings: TFormatSettings):; Construit une représentation sous forme de chaîne de DateTime
4	procedure DateTimeToString(out Result: ;const FormatStr: ;const DateTime: TDateTime); Construit une représentation sous forme de chaîne de DateTime
5	procedure DateTimeToString(out Result: ; const FormatStr: ; const DateTime: TDateTime; const FormatSettings: TFormatSettings); Construit une représentation sous forme de chaîne de DateTime
6	procedure DateTimeToSystemTime(DateTime: TDateTime; out SystemTime: TSystemTime); Convertit DateTime en heure système
sept	function DateTimeToTimeStamp( DateTime: TDateTime):TTimeStamp;Convertit DateTime en horodatage
8	function DateToStr(Date: TDateTime):; Construit une représentation sous forme de chaîne de date
9	function DateToStr(Date: TDateTime; const FormatSettings: TFormatSettings):; Construit une représentation sous forme de chaîne de date
dix	function Date: TDateTime; Obtient la date actuelle
11	function DayOfWeek(DateTime: TDateTime):Integer; Obtient le jour de la semaine
12	procedure DecodeDate(Date: TDateTime; out Year: Word; out Month: Word; out Day: Word); Décode DateTime en année mois et jour
13	procedure DecodeTime(Time: TDateTime; out Hour: Word; out Minute: Word; out Second: Word; out MilliSecond: Word); Décode DateTime en heures, minutes et secondes
14	function EncodeDate(Year: Word; Month: Word; Day: Word):TDateTime; Encode l'année, le jour et le mois en DateTime
15	function EncodeTime(Hour: Word; Minute: Word; Second: Word; MilliSecond: Word):TDateTime; Encode les heures, les minutes et les secondes en DateTime
16	function FormatDateTime(const FormatStr: ; DateTime: TDateTime):; Renvoie une représentation sous forme de chaîne de DateTime
17	function FormatDateTime(const FormatStr: ; DateTime: TDateTime; const FormatSettings: TFormatSettings):; Renvoie une représentation sous forme de chaîne de DateTime
18	function IncMonth(const DateTime: TDateTime; NumberOfMonths: Integer = 1):TDateTime; Ajoute 1 au mois
19	function IsLeapYear(Year: Word):Boolean; Détermine si l'année est bissextile
20	function MSecsToTimeStamp(MSecs: Comp):TTimeStamp; Convertit le nombre de millisecondes en horodatage
21	function Now: TDateTime; Obtient la date et l'heure actuelles
22	function StrToDateTime(const S:):TDateTime; Convertit la chaîne en DateTime
23	function StrToDateTime(const s: ShortString; const FormatSettings: TFormatSettings):TDateTime; Convertit la chaîne en DateTime
24	function StrToDateTime(const s: AnsiString; const FormatSettings: TFormatSettings):TDateTime; Convertit la chaîne en DateTime
25	function StrToDate(const S: ShortString):TDateTime; Convertit la chaîne en date
26	function StrToDate(const S: Ansistring):TDateTime; Convertit la chaîne en date
27	function StrToDate(const S: ShortString; separator: Char):TDateTime; Convertit la chaîne en date
28	function StrToDate(const S: AnsiString; separator: Char):TDateTime; Convertit la chaîne en date
29	function StrToDate(const S: ShortString; const useformat: ; separator: Char):TDateTime; Convertit la chaîne en date
30	function StrToDate(const S: AnsiString; const useformat: ; separator: Char):TDateTime; Convertit la chaîne en date
31	function StrToDate(const S: PChar; Len: Integer; const useformat: ; separator: Char = #0):TDateTime; Convertit la chaîne en date
32	function StrToTime(const S: Shortstring):TDateTime; Convertit la chaîne en temps
33	function StrToTime(const S: Ansistring):TDateTime; Convertit la chaîne en temps
34	function StrToTime(const S: ShortString; separator: Char):TDateTime; Convertit la chaîne en temps
35	function StrToTime(const S: AnsiString; separator: Char):TDateTime; Convertit la chaîne en temps
36	function StrToTime(const S: ; FormatSettings: TFormatSettings):TDateTime; Convertit la chaîne en temps
37	function StrToTime(const S: PChar; Len: Integer; separator: Char = #0):TDateTime; Convertit la chaîne en temps
38	function SystemTimeToDateTime(const SystemTime: TSystemTime):TDateTime; Convertit l'heure système en date / heure
39	function TimeStampToDateTime(const TimeStamp: TTimeStamp):TDateTime; Convertit l'horodatage en DateTime
40	function TimeStampToMSecs(const TimeStamp: TTimeStamp):comp; Convertit l'horodatage en nombre de millisecondes
41	function TimeToStr(Time: TDateTime):; Renvoie une représentation sous forme de chaîne de Time
42	function TimeToStr(Time: TDateTime; const FormatSettings: TFormatSettings):; Renvoie une représentation sous forme de chaîne de Time
43	function Time: TDateTime; Obtenir l'heure actuelle

L'exemple suivant illustre l'utilisation de certaines des fonctions ci-dessus -

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.

Lorsque le code ci-dessus a été compilé et exécuté, il a produit le résultat suivant:

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

Nous pouvons imaginer notre univers fait de différents objets comme le soleil, la terre, la lune, etc. De même, nous pouvons imaginer notre voiture faite de différents objets comme le volant, la direction, l'équipement, etc. assumer tout comme un objet et implémenter un logiciel en utilisant différents objets. Dans Pascal, il existe deux types de données structurelles utilisées pour implémenter un objet du monde réel -

• Types d'objets
• Types de cours

Concepts orientés objet

Avant d'entrer dans les détails, définissons les termes Pascal importants liés au Pascal orienté objet.

• Object- Un objet est un type spécial d'enregistrement qui contient des champs comme un enregistrement; cependant, contrairement aux enregistrements, les objets contiennent des procédures et des fonctions faisant partie de l'objet. Ces procédures et fonctions sont conservées comme des pointeurs vers les méthodes associées au type de l'objet.

• Class- Une classe est définie presque de la même manière qu'un objet, mais il y a une différence dans la manière dont elles sont créées. La classe est allouée sur le tas d'un programme, tandis que l'objet est alloué sur la pile. C'est un pointeur vers l'objet, pas l'objet lui-même.

• Instantiation of a class- L'instanciation signifie la création d'une variable de ce type de classe. Puisqu'une classe n'est qu'un pointeur, lorsqu'une variable d'un type de classe est déclarée, de la mémoire est allouée uniquement pour le pointeur, pas pour l'objet entier. Uniquement lorsqu'il est instancié à l'aide de l'un de ses constructeurs, la mémoire est allouée à l'objet. Les instances d'une classe sont également appelées «objets», mais ne les confondez pas avec les objets Object Pascal. Dans ce didacticiel, nous écrirons 'Object' pour les objets Pascal et 'object' pour l'objet conceptuel ou l'instance de classe.

• Member Variables - Ce sont les variables définies à l'intérieur d'une classe ou d'un objet.

• Member Functions - Ce sont les fonctions ou procédures définies à l'intérieur d'une classe ou d'un objet et sont utilisées pour accéder aux données d'objet.

• Visibility of Members- Les membres d'un objet ou d'une classe sont également appelés les champs. Ces domaines ont des visibilités différentes. La visibilité fait référence à l'accessibilité des membres, c'est-à-dire exactement là où ces membres seront accessibles. Les objets ont trois niveaux de visibilité: public, privé et protégé. Les classes ont cinq types de visibilité: publique, privée, strictement privée, protégée et publiée. Nous discuterons de la visibilité dans les détails.

• Inheritance- Lorsqu'une classe est définie en héritant des fonctionnalités existantes d'une classe parent, on dit qu'elle est héritée. Ici, la classe enfant héritera de toutes ou de quelques fonctions membres et variables d'une classe parent. Les objets peuvent également être hérités.

• Parent Class- Une classe héritée par une autre classe. Ceci est également appelé une classe de base ou une super classe.

• Child Class- Une classe qui hérite d'une autre classe. Ceci est également appelé une sous-classe ou une classe dérivée.

• Polymorphism- Il s'agit d'un concept orienté objet où la même fonction peut être utilisée à des fins différentes. Par exemple, le nom de la fonction restera le même, mais il peut prendre un nombre d'arguments différent et effectuer différentes tâches. Les classes Pascal implémentent le polymorphisme. Les objets n'implémentent pas le polymorphisme.

• Overloading- C'est un type de polymorphisme dans lequel certains ou tous les opérateurs ont des implémentations différentes selon les types de leurs arguments. De même, les fonctions peuvent également être surchargées avec une implémentation différente. Les classes Pascal implémentent la surcharge, mais pas les objets.

• Data Abstraction - Toute représentation de données dans laquelle les détails d'implémentation sont masqués (abstraits).

• Encapsulation - Fait référence à un concept où nous encapsulons toutes les données et les fonctions membres ensemble pour former un objet.

• Constructor - Fait référence à un type spécial de fonction qui sera appelée automatiquement chaque fois qu'il y a une formation d'objet à partir d'une classe ou d'un objet.

• Destructor - Fait référence à un type spécial de fonction qui sera appelée automatiquement chaque fois qu'un objet ou une classe est supprimé ou hors de portée.

Définition des objets Pascal

Un objet est déclaré à l'aide de la déclaration de type. La forme générale d'une déclaration d'objet est la suivante -

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

Définissons un objet Rectangle qui a deux membres de données de type entier - length et width et certaines fonctions membres pour manipuler ces données membres et une procédure pour dessiner le 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;

Après avoir créé vos objets, vous pourrez appeler des fonctions membres liées à cet objet. Une fonction membre pourra traiter la variable membre de l'objet associé uniquement.

L'exemple suivant montre comment définir des longueurs et des largeurs pour deux objets rectangle et les dessiner en appelant les fonctions membres.

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);

Voici un exemple complet pour montrer comment utiliser des objets en 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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Visibilité des membres de l'objet

La visibilité indique l'accessibilité des membres de l'objet. Les membres d'objet Pascal ont trois types de visibilité -

Sr.Non	Visibilité et accessibilité
1	Public Les membres peuvent être utilisés par d'autres unités en dehors de l'unité de programme
2	Private Les membres ne sont accessibles que dans l'unité actuelle.
3	Protected Les membres ne sont disponibles que pour les objets descendants de l'objet parent.

Par défaut, les champs et méthodes d'un objet sont publics et sont exportés en dehors de l'unité courante.

Constructeurs et destructeurs pour les objets Pascal -

Constructorssont des méthodes de type spécial, qui sont appelées automatiquement chaque fois qu'un objet est créé. Vous créez un constructeur en Pascal simplement en déclarant une méthode avec un constructeur de mot-clé. Par convention, le nom de la méthode est Init, cependant, vous pouvez fournir tout identifiant valide de votre choix. Vous pouvez passer autant d'arguments que vous le souhaitez dans la fonction constructeur.

Destructorssont des méthodes appelées lors de la destruction de l'objet. Les méthodes destructrices détruisent toute allocation de mémoire créée par les constructeurs.

L'exemple suivant fournira un constructeur et un destructeur pour la classe Rectangle qui initialisera la longueur et la largeur du rectangle au moment de la création de l'objet et le détruira lorsqu'il sortira de la portée.

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Héritage des objets Pascal

Les objets Pascal peuvent éventuellement hériter d'un objet parent. Le programme suivant illustre l'héritage dans les objets Pascal. Créons un autre objet nomméTableTop, qui hérite de l'objet Rectangle.

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.

Voici les points importants à noter -

• L'objet Tabletop a hérité de tous les membres de l'objet Rectangle.

• Il existe également une méthode de dessin dans TableTop . Lorsque le tirage méthode est appelée à l' aide d' un TableTop objet, le tirage au sort de TableTop s'invoqué.

• Il existe une instance implicite nommée self qui fait référence à l'instance actuelle de l'objet.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Table Top: 3 by 7
Material: Wood

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

Vous avez vu que les objets Pascal présentent certaines caractéristiques du paradigme orienté objet. Ils implémentent l'encapsulation, le masquage des données et l'héritage, mais ils ont également des limites. Par exemple, les objets Pascal ne participent pas au polymorphisme. Ainsi, les classes sont largement utilisées pour implémenter un comportement orienté objet approprié dans un programme, en particulier le logiciel basé sur l'interface graphique.

Une classe est définie presque de la même manière qu'un objet, mais est un pointeur vers un objet plutôt que vers l'objet lui-même. Techniquement, cela signifie que la classe est allouée sur le tas d'un programme, alors que l'objet est alloué sur la pile. En d'autres termes, lorsque vous déclarez une variable de type objet, elle prendra autant d'espace sur la pile que la taille de l'objet, mais lorsque vous déclarez une variable de type classe, elle prendra toujours la taille d'un pointeur sur la pile. Les données de classe réelles seront sur le tas.

Définition des classes Pascal

Une classe est déclarée de la même manière qu'un objet, en utilisant la déclaration de type. La forme générale d'une déclaration de classe est la suivante -

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;

Il vaut la peine de noter les points importants suivants -

• Les définitions de classe doivent relever de la partie déclaration de type du programme uniquement.

• Une classe est définie à l'aide du class mot-clé.

• Les champs sont des éléments de données qui existent dans chaque instance de la classe.

• Les méthodes sont déclarées dans la définition d'une classe.

• Il existe un constructeur prédéfini appelé Createdans la classe Root. Chaque classe abstraite et chaque classe concrète est un descendant de Root, donc toutes les classes ont au moins un constructeur.

• Il existe un destructeur prédéfini appelé Destroydans la classe Root. Chaque classe abstraite et chaque classe concrète est un descendant de Root, donc toutes les classes ont au moins un destructeur.

Définissons une classe Rectangle qui a deux membres de données de type entier - longueur et largeur et certaines fonctions membres pour manipuler ces membres de données et une procédure pour dessiner le rectangle.

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;

Écrivons un programme complet qui créerait une instance d'une classe de rectangle et dessinerait le rectangle. C'est le même exemple que nous avons utilisé lors de la discussion des objets Pascal. Vous constaterez que les deux programmes sont presque identiques, avec les exceptions suivantes -

• Vous devrez inclure la directive {$ mode objfpc} pour utiliser les classes.

• Vous devrez inclure la directive {$ m +} pour utiliser les constructeurs.

• L'instanciation de classe est différente de l'instanciation d'objet. La seule déclaration de la variable ne crée pas d'espace pour l'instance, vous utiliserez le constructeur create pour allouer de la mémoire.

Voici l'exemple complet -

{$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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Visibilité des membres du groupe

La visibilité indique l'accessibilité des membres de la classe. Les membres de la classe Pascal ont cinq types de visibilité -

Sr.Non	Visibilité et accessibilité
1	Public Ces membres sont toujours accessibles.
2	Private Ces membres ne sont accessibles que dans le module ou l'unité contenant la définition de classe. Ils sont accessibles depuis l'intérieur des méthodes de classe ou depuis l'extérieur d'elles.
3	Strict Private Ces membres ne sont accessibles qu'à partir des méthodes de la classe elle-même. Les autres classes ou classes descendantes de la même unité ne peuvent pas y accéder.
4	Protected C'est la même chose que private, sauf que ces membres sont accessibles aux types descendants, même s'ils sont implémentés dans d'autres modules.
5	Published C'est la même chose qu'un Public, mais le compilateur génère des informations de type qui sont nécessaires pour le streaming automatique de ces classes si le compilateur est dans l'état {$ M +}. Les champs définis dans une section publiée doivent être de type classe.

Constructeurs et destructeurs pour les classes Pascal

Les constructeurs sont des méthodes spéciales, qui sont appelées automatiquement chaque fois qu'un objet est créé. Nous profitons donc pleinement de ce comportement en initialisant de nombreuses choses via des fonctions de constructeur.

Pascal fournit une fonction spéciale appelée create () pour définir un constructeur. Vous pouvez passer autant d'arguments que vous le souhaitez dans la fonction constructeur.

L'exemple suivant créera un constructeur pour une classe nommée Books et initialisera le prix et le titre du livre au moment de la création de l'objet.

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Comme le constructeur implicite nommé create, il existe également une méthode destructrice implicite destroy à l'aide de laquelle vous pouvez libérer toutes les ressources utilisées dans la classe.

Héritage

Les définitions de classe Pascal peuvent éventuellement hériter d'une définition de classe parent. La syntaxe est la suivante -

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

L'exemple suivant fournit une classe de romans, qui hérite de la classe Books et ajoute plus de fonctionnalités en fonction de l'exigence.

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Il vaut la peine de noter les points importants suivants -

• Les membres de la classe Livres ont protected visibilité.

• La classe Novels a deux constructeurs, donc le overload L'opérateur est utilisé pour la surcharge de fonction.

• La procédure Books.Display a été déclarée virtual, afin que la même méthode de la classe Novels puisse override il.

• Le constructeur Novels.Create appelle le constructeur de classe de base à l'aide du inherited mot-clé.

Interfaces

Les interfaces sont définies pour fournir un nom de fonction commun aux implémenteurs. Différents développeurs peuvent implémenter ces interfaces en fonction de leurs besoins. Vous pouvez dire que les interfaces sont des squelettes, qui sont implémentés par les développeurs. Voici un exemple d'interface -

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

Veuillez noter que, lorsqu'une classe implémente une interface, elle doit implémenter toutes les méthodes de l'interface. Si une méthode d'une interface n'est pas implémentée, alors le compilateur donnera une erreur.

Classes abstraites

Une classe abstraite est une classe qui ne peut pas être instanciée, seulement héritée. Une classe abstraite est spécifiée en incluant le mot symbole abstract dans la définition de classe, comme ceci -

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

Lors de l'héritage d'une classe abstraite, toutes les méthodes marquées abstract dans la déclaration de classe du parent doivent être définies par l'enfant; de plus, ces méthodes doivent être définies avec la même visibilité.

Mot-clé statique

Déclarer des membres de classe ou des méthodes comme statiques les rend accessibles sans avoir besoin d'une instanciation de la classe. Un membre déclaré comme statique n'est pas accessible avec un objet de classe instancié (bien qu'une méthode statique le puisse). L'exemple suivant illustre le concept -

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.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

12
31
31
51
51

Vous devez utiliser la directive {$ static on} pour utiliser les membres statiques.