Apprendre la programmation Pascal - Tutoriel Leçon 1

- Introduction à Pascal
À propos de Pascal

Le langage de programmation Pascal a été créé par Niklaus Wirth en 1970. Il a été nommé d'après
Blaise Pascal, un célèbre mathématicien français. Cela a été créé comme un langage pour enseigner la programmation
et pour être fiable et efficace. Pascal est depuis devenu plus qu'un simple langage académique
et est maintenant utilisé commercialement.

Ce dont vous aurez besoin

Avant de commencer à apprendre Pascal, vous aurez besoin d'un compilateur Pascal. Ce tutoriel utilises est leGratuit
Compilateur Pascal. Vous ctrouver une liste d'autres compilateurs PascaltLePascalDeTheFreeCountry
liste des compilateurs.

Votre premier programme

La première chose à faire est d'ouvrir votre IDE si votre compilateur en possède un ou d'ouvrir un éditeur de texte.
éditeur.

Nous commençons toujours un programme en tapant son nom. Tapez le nom du programme suivant.
Nous appellerons notre premier programme "Bonjour" car il va imprimer les mots "Bonjour le monde"
sur l'écran.

programme Bonjour;

Ensuite, nous allons taper debuts et fins. Nous allons taper le corps principal du programme entre
ces 2 mots-clés. N'oubliez pas de mettre le point final après la fin.

programme Bonjour;

commencer
fin.

La commande Write imprime des mots à l'écran.

programme Bonjour;

début
Écrire('Bonjour le monde');
fin.
Vous verrez que le « Hello world » est entre des guillemets simples. C'est parce que c'est ce qu'on appelle un
chaîne. Toutes les chaînes doivent être comme ça. Le point-virgule à la fin de la ligne est un séparateur d'instructions.
Vous devez toujours vous rappeler de le mettre à la fin de la ligne.

La commande Readln sera maintenant utilisée pour attendre que l'utilisateur appuie sur entrer avant de se terminer.
programme.

programme Bonjour;

commencer
Bonjour le monde
Lireln;
fin.

Vous devez maintenant enregistrer votre programme sous le nom [Link].

Compilation
Notre premier programme est maintenant prêt à être compilé. Lorsque vous compilez un programme, le compilateur lit
votre code source et le transforme en un fichier exécutable. Si vous utilisez un IDE, alors en appuyant sur
CTRL+F9 est généralement utilisé pour compiler et exécuter le programme. Si vous compilez à partir de
ligne de commande avec Free Pascal puis entrez ce qui suit :

fpc [Link]

Si vous obtenez des erreurs lors de la compilation, vous devez revoir cette leçon pour le découvrir.
où vous les avez créés. Les utilisateurs d'IDE constateront que leurs programmes se compilent et s'exécutent en même temps.
Les utilisateurs de la ligne de commande doivent taper le nom du programme à l'invite de commande pour l'exécuter.

Vous devriez voir les mots "Bonjour le monde" lorsque vous exécutez votre programme et appuyer sur entrer quittera.
le programme. Félicitations ! Vous venez de créer votre premier programme Pascal.

Plus de commandes
Writeln est juste comme Write sauf qu'il déplace le curseur à la ligne suivante après avoir imprimé le
Voici un programme qui imprimera "Bonjour" puis "monde" sur la ligne suivante :

programme Bonjour;

début
Écrivez('Bonjour');
écrire('monde');
Lireln;
fin.

Si vous voulez sauter une ligne, utilisez simplement Writeln par lui-même sans aucune parenthèse.
Utiliser des commandes des unités

Les commandes intégrées dans votre compilateur Pascal sont très basiques et nous aurons besoin de quelques unes.
plus. Les unités peuvent être incluses dans un programme pour vous donner accès à plus de commandes. L'unité crt est
l'un des plus utiles. La commande ClrScr dans l'unité crt efface l'écran. Voici comment vous
utilisez-le :

programme Bonjour;

utilisations
crt;

début
ClrScr;
Bonjour le monde
Lire;
fin.

Commentaires
Les commentaires sont des éléments utilisés pour expliquer ce que font les parties d'un programme. Les commentaires sont ignorés.
par le compilateur et ne sont là que pour les personnes qui utilisent le code source. Les commentaires doivent être
mettez entre accolades. Vous devriez toujours avoir un commentaire en haut de votre programme pour
Dites ce que cela fait ainsi que des commentaires pour tout code qui est difficile à comprendre. Voici un
exemple de la manière de commenter le programme que nous venons de faire :

Ce programme effacera l'écran, imprimera "Bonjour le monde" et attendra pour le

Utilisateur pour appuyer sur entrée.

programme Bonjour;

utilisations
crt;

début
ClrScr;{Efface l'écran}
Écrire('Bonjour le monde');{Imprime "Bonjour le monde"}
LireLn;{Attend que l'utilisateur appuie sur entrée}
fin.

Indentation
Vous remarquerez que j'ai mis 3 espaces devant certaines des commandes. Cela s'appelle
l'indentation et elle est utilisée pour rendre un programme plus facile à lire. Beaucoup de débutants ne comprennent pas
la raison de l'indentation et de ne pas l'utiliser mais quand nous commençons à faire des choses plus longues et plus complexes
programmes, vous comprendrez.
Couleurs
Pour changer la couleur du texte affiché à l'écran, nous utilisons la commande TextColor.

programme Couleurs;

utilisations
crt;

commencer
TexteCouleur(Rouge);
Écrire('Bonjour');
TextColor(Bleu);
Écrire('monde');
fin.

La commande TexteFond change la couleur de l'arrière-plan du texte. Si vous souhaitez

changez tout l'écran en une certaine couleur puis vous devez utiliser ClrScr.

programme Couleurs;

utilisations
crt;

début
TexteFond(Rouge);
Écrire('Bonjour');
TextColor(Bleu);
ClrScr;
fin.

Coordonnées de l'écran
Vous pouvez placer le curseur n'importe où sur l'écran en utilisant la commande GoToXY. Dans DOS, l'écran
fait 80 caractères de large et 25 caractères de haut. La hauteur et la largeur varient sur d'autres plateformes.
Vous vous souvenez peut-être des graphiques de mathématiques qui ont un axe X et un axe Y. Les coordonnées de l'écran fonctionnent dans
de manière similaire. Voici un exemple de la façon de déplacer le curseur vers la 10e colonne dans la 5e ligne.

programme Coordonnées;

utilisations
crt;

début
AllerÀXY(10,5);
Écrire('Bonjour');
fin.

Fenêtres
Windows vous permet de définir une partie de l'écran à laquelle votre sortie sera confinée. Si vous créez un
la fenêtre et effacer l'écran, cela effacera uniquement ce qui se trouve dans la fenêtre. La commande fenêtre a
4 paramètres qui sont les coordonnées en haut à gauche et les coordonnées en bas à droite.

programme Coordonnées;

utilisations
crt;

commencer
Fenêtre(1,1,10,5);
Texte de fond (Bleu);
ClrScr;
fin.

Utiliser window(1,1,80,25) remettra la fenêtre à la taille normale.

Apprendre la programmation Pascal Tutoriel Leçon 3

-Variables et constantes
Qu'est-ce que les variables ?

Les variables sont des noms donnés à des blocs de la mémoire de l'ordinateur. Les noms sont utilisés pour stocker
valeurs dans ces blocs de mémoire.

Les variables peuvent contenir des valeurs qui sont soit des nombres, soit des chaînes de caractères, soit des booléens. Nous savons déjà ce que
les chiffres sont. Les chaînes sont composées de lettres. Les variables booléennes peuvent avoir l'une des deux valeurs, soit
Vrai ou Faux.

Utiliser des variables

Vous devez toujours déclarer une variable avant de l'utiliser. Nous utilisons l'instruction var pour cela.
vous devez également choisir quel type de variable c'est. Voici un tableau des différents types de variables :

Octet 0 à 255
Mot 0 à 65535
ShortInt -128 à 127
Entier -32768 à 32767
LongInt -4228250000 à 4228249000
Réel valeurs à virgule flottante
Char 1 caractère
Chaîne jusqu'à 255 caractères
Booléen vrai ou faux
Voici un exemple de la façon de déclarer une variable entière nommée i :

programme Variables;

var
i : Entier ;

commencer
fin.

Pour attribuer une valeur à une variable, nous utilisons :=

programme Variables;

var
i : entier ;

commencer
i := 5;
fin.

Vous pouvez créer 2 variables ou plus du même type si vous séparez leurs noms par des virgules.
Vous pouvez également créer des variables d'un type différent sans avoir besoin d'une autre déclaration de variable.

programme Variables;

var
i, j: Entier;
s: Chaîne;

début
fin.

Lorsque vous assignez une valeur à une variable de chaîne, vous devez la mettre entre des guillemets simples. Booléen
les variables ne peuvent se voir attribuer que les valeurs Vrai et Faux.

programme Variables;

var
i: Entier;
s: Chaîne;
b: Booléen;

début
i := -3;
Bonjour
b := Vrai;
fin.

Calculs avec des variables

Les variables peuvent être utilisées dans des calculs. Par exemple, vous pourriez attribuer la valeur à une variable et
ajoutez ensuite le numéro 1. Voici un tableau des opérateurs qui peuvent être utilisés :

+ Ajouter
- Soustraire
* Multiplier
/ Division flottante
div Division entière
mod Reste de la division entière

L'exemple suivant montre quelques calculs qui peuvent être effectués :

programme Variables;

var
Num1

commencer
Ans := 1 + 1;
Num1 := 5;
Ans := Num1 + 3;
Num2 := 2;
Ans := Num1 - Num2;
Ans := Ans * Num1;
fin.

Les chaînes contiennent des caractères. Les caractères comprennent les lettres de l'alphabet ainsi que des caractères spéciaux.
caractères et même des chiffres. Il est important de comprendre que les nombres entiers et les chaînes
les nombres sont des choses différentes. Vous pouvez également ajouter des chaînes ensemble. Tout ce qui se passe, c'est qu'il les joint.
2 chaînes. Si vous ajoutez les chaînes '1' et '1', vous obtiendrez '11' et non 2.

programme Variables;

var
Chaîne;

début
s := '1' + '1';
fin.

Vous pouvez lire des valeurs à partir du clavier dans des variables en utilisant Readln et ReadKey. ReadKey est
à partir de l'unité CRT et ne lit qu'un caractère. Vous constaterez que ReadKey fonctionne différemment de
Lisez

programme Variables;

utilise crt;

var
i : entier ;
 s: Chaîne;
c: Char;

début
Lire(i);
Lireln(s);
c := LireTouche;
fin.

L'impression des variables à l'écran est tout aussi facile. Si vous souhaitez imprimer des variables et du texte avec le
réécrire alors les séparer par des virgules.

programme Variables;

var
i : Entier ;
Chaîne
commencer
i := 24;
Bonjour
Écrivez(i);
Écris(s, ' monde');
fin.

Constantes
Les constantes sont comme des variables sauf que leurs valeurs ne peuvent pas changer. Vous assignez une valeur à un
constant lorsque vous le créez. const est utilisé à la place de var lors de la déclaration d'une constante. Les constantes sont
utilisé pour des valeurs qui ne changent pas comme la valeur de pi.

programme Variables;

const
Réel = 3,14

var
c, d : Réel ;

début
d := 5;
c := pi * d;

Apprenez la programmation Pascal Tutoriel Leçon 4

Gestion et conversions de chaînes
Gestion des chaînes
Vous pouvez accéder à un caractère spécifique dans une chaîne si vous mettez le numéro de la position de celui-ci.
caractère entre crochets derrière une chaîne.
programme Chaînes;

var
s : Chaîne ;
c : Char;

commencer
Bonjour
c := s[1];{c = 'H'}
fin.

Vous pouvez obtenir la longueur d'une chaîne en utilisant la commande Length.

programme Chaînes;

var
Chaîne;
l : Entier ;

commencer
Bonjour
l := Longueur(s);{l = 5}
fin.

Pour trouver la position d'une chaîne dans une chaîne, utilisez la commande thePos.
Paramètres :
1: Chaîne à trouver
2 : Chaîne à rechercher

programme Chaines;

var
Chaine
p : Entier ;

commencer
Bonjour le monde
p := Pos('monde',s);
fin.

La commande Supprimer enlève des caractères d'une chaîne.

Paramètres :
Chaîne à supprimer des caractères
2 : Position à partir de laquelle commencer la suppression
3 : Nombre de caractères à supprimer

programme Chaines;

var
s : Chaîne ;

commencer
Bonjour
 Supprimer(s,1,1);{s = 'ello'}
fin.

La commande Copy est semblable aux crochets, mais peut accéder à plus d'un seul caractère.
Paramètres :
Chaîne à copier des caractères de
Position à copier depuis
3 : Montant de caractères à copier

programme Chaînes;

var
s, t : Chaîne ;

commencer
Bonjour
t := Copier(s,1,3);{t = 'Hel'}
fin.

Insertwill insérera des caractères dans une chaîne à une certaine position.
Paramètres :
1 : Chaîne qui sera insérée dans l'autre chaîne
2 : Chaîne dans laquelle des caractères seront insérés
3 : Position pour insérer des caractères

programme Chaînes;

var
Chaîne

commencer
Hlo
Insérer('el',s,2);
fin.

La commande TheParamStr vous donnera les paramètres de ligne de commande qui ont été passés à un
[Link] vous indiquera combien de paramètres ont été passés au programme.
Le paramètre 0 est toujours le nom du programme et à partir de 1, ce sont les paramètres qui ont été
taper par l'utilisateur.

programme Chaines;

var
s : Chaîne ;
i : entier ;

début
s := ParamStr(0);
i := CompteParam;
fin.
Conversions
La commande Str convertit un entier en chaîne.

programme Convert;

var
Chaîne;
i : entier ;

début
i := 123;
Str(i,s);
fin.

La commande Val convertit une chaîne en entier.

programme Convert;

var
Chaîne
i: Entier;
e : Entier ;

commencer
s := '123';
Val(s,i,e);
fin.

Je vais vous donner le nombre avant la virgule dans un nombre réel.

programme Convert;

var
r: Réel;

début
r := Int(3,14);
fin.

Frac vous donnera le nombre après la virgule dans un nombre réel.

programme Convert;

var
r: Réel;

commencer
r := Frac(3,14);
fin.

Roundwill arrondit un nombre réel à l'entier le plus proche.

programme Convert;

var
i : Entier ;

début
i := Arrondi(3.14);
fin.

Trunc donnera le nombre avant la virgule d'un nombre réel sous forme d'entier.

programme Convert;

var
i : Entier ;

début
i := Trunc(3.14);
fin.

Les ordinateurs utilisent les chiffres de 0 à 255 (1 octet) pour représenter les caractères en interne et ceux-ci sont
appelés caractères ASCII. La commande Ord convertira un caractère en nombre et le Chr
La commande convertira un nombre en un caractère. Utiliser un # devant un nombre le convertira également.
à un personnage.

programme Convert;

var
Octet
c : Char;

commencer
c := 'a';
b := Ord(c);
c := Chr(b);
c := #123;
fin.

La commande UpCase change un caractère d'une lettre minuscule en une lettre majuscule.

programme Convert;

var
c: Char;

commencer
c := 'a';
c := Majuscule(c);
fin.

Il n'y a pas de commande pour les minuscules, mais vous pouvez le faire en ajoutant 32 à la valeur ordinale d'un
lettre majuscule puis revenir à un caractère.
Extras
La commande aléatoire vous donnera un nombre aléatoire de 0 au nombre que vous lui donnez - 1. Le
Randomcommand génère les mêmes nombres aléatoires chaque fois que vous exécutez un programme, donc le
La commande Randomize est utilisée pour les rendre plus aléatoires en utilisant l'horloge du système.

programme Rand;

var
i : Entier ;

début
Randomiser;
i := Aléatoire(101);
fin.
5. Apprendre la programmation Pascal

Décisions
Si alors sinon
L'instruction if permet à un programme de prendre une décision en fonction d'une condition. Le suivant
L'exemple demande à l'utilisateur d'entrer un nombre et vous dit si le nombre est supérieur à 5 :
programme Décisions;

var
i : Entier ;

commencer
Écrivez 'Entrez un numéro';
Lire(i);
si i > 5 alors
Écrire('Supérieur à 5');
fin.
Voici un tableau des opérateurs qui peuvent être utilisés dans les conditions :

> Plus grand que

< Moins de
>= Plus grand que ou égal à
inférieur ou égal à
= Égal à
pas égal à

L'exemple ci-dessus ne vous indique que si le nombre est supérieur à 5. Si vous voulez qu'il vous dise que cela
n'est pas supérieur à 5 alors nous utilisons else. Lorsque vous utilisez else, vous ne devez pas mettre de point-virgule à la fin.
fin de la commande avant elle.

programme Décisions;

var
i : Entier ;

début
Écrivez('Entrez un nombre');
Lire(i);
si i > 5 alors
Écrire('Plus grand que 5')
sinon
Écrire('Pas plus grand que 5');
fin.
Si la condition est vraie, alors la partie 'then' est choisie, mais si elle est fausse, alors la partie 'else' est choisie.
C'est parce que des conditions telles que i > 5 sont une équation booléenne. Vous pouvez même attribuer le résultat.
d'une équation booléenne à une variable booléenne.

programme Décisions;

var
i : Entier ;
b: Booléen;

commencer
Entrez un nombre
Lire(i);
b := i > 5 ;
fin.
Si vous souhaitez utiliser plus d'une condition, vous devez mettre chaque condition entre parenthèses. Pour joindre
les conditions que vous pouvez utiliser sont soit ET soit OU. Si vous utilisez ET, alors les deux conditions doivent être vraies
mais si vous utilisez OU, alors seulement 1 ou les deux conditions doivent être vraies.
programme Décisions;

var
i : entier ;

début
Écrivez('Entrez un numéro');
Lire(i);
si (i > 1) et (i < 100) alors
Écrivez('Le nombre est entre 1 et 100');
fin.
Si vous souhaitez mettre 2 commandes ou plus pour une instruction anif pour les deux parties alors et sinon
vous devez utiliser commencer et finir ; pour les regrouper. Vous verrez que cette fin a un point-virgule
après cela au lieu d'un point.
programme Décisions;

var
i : Entier ;

commencer
Écrivez('Entrez un nombre');
LireLn(i);
si i > 0 alors
commencer
Écrivez('Vous avez entré ',i);
Écrire('C'est un nombre positif');
fin;
fin.
Devoir
Vous pouvez également utiliser des instructions if à l'intérieur d'autres instructions if.
 Affaire
La commande case est comme une instruction if mais vous pouvez avoir plusieurs conditions avec des actions pour
chacun.
programme Décisions;
utilisations
crt;
var
Choix : Char;
début
Écrivez('Lequel de ceux-ci aimez-vous ?');
Écrivez('a - Pomme:');
Écrire('b - Banane :');
Écrivez 'c - Carotte :';
Choix := LireTouche;
cas de choix de
ÉcrisLn('Tu aimes les pommes')
Vous aimez les bananes
ÉcrivezLn('Vous aimez les carottes')
sinon
Écrivez('Vous avez fait un choix invalide');
fin;
fin.
Apprendre le tutoriel de programmation Pascal leçon 6 - Boucles
Les boucles sont utilisées lorsque vous souhaitez répéter du code plusieurs fois. Par exemple, si vous vouliez imprimer
« Bonjour » sur l'écran 10 fois, vous auriez besoin de 10 commandes Writeln. Vous pourriez faire de même.
mettre 1Writelncommande à l'intérieur d'une boucle qui se répète 10 fois.
Il existe 3 types de boucles : la boucle for, la boucle while et la boucle repeat-until.

Boucle for
La boucle for utilise une variable de compteur de boucle, à laquelle elle ajoute 1 à chaque itération, pour boucler à partir d'un premier
numéro à un dernier numéro.
programme Boucles;
var
i : entier ;
début
pour i := 1 à 10 faire
Écrivez('Bonjour');
fin.
Si vous souhaitez avoir plus d'une commande à l'intérieur d'une boucle, vous devez les placer entre abegin
et une fin.

programme Boucles;
var
Entier
début
pour i := 1 à 10 faire
début
Ecris('Bonjour');
Écrire('Ceci est une boucle ', i);
fin;
fin.

Boucle while
La boucle while se répète tant qu'une condition est vraie. La condition est testée en haut de la boucle et
pas à tout moment pendant que la boucle s'exécute comme son nom l'indique. Une boucle while n'a pas besoin d'un
variable de boucle mais si vous voulez en utiliser une, vous devez d'abord initialiser sa valeur avant d'entrer dans le
boucle.

programme Boucles;

var
i : Entier ;

commencer
i := 0;
tant que i <= 10
début
i := i + 1;
Écris('Bonjour');
fin;
fin.

Boucle de répétition jusqu'à

La boucle repeat untilloop est comme la boucle whileloop sauf qu'elle teste la condition en bas.
boucle. Il n'est pas non plus nécessaire d'avoir un début et une fin s'il y a plus d'une commande à l'intérieur.

programme Boucles;

var
i : Entier;

début
i := 0;
répéter
i := i + 1;
Écrivez('Bonjour');
jusqu'à i = 10;
fin.

Si vous souhaitez utiliser plus d'une condition pour les boucles while ou repeat, alors vous devez
mettez les conditions entre parenthèses.

programme Boucles;

var
i : entier ;
Chaîne;

début
i := 0;
répéter
i := i + 1;
Entrez un nombre :
Lireln(s);
 jusqu'à (i = 10) ou (s = 0);
fin.

Arrêter
La commande Break sortira d'une boucle à tout moment. Le programme suivant ne imprimera rien
car il sort de la boucle avant d'y arriver.

programme Boucles;

var
i : entier ;

commencer
i := 0;
répéter
i := i + 1 ;
Pause;
Écris(i);
jusqu'à i = 10;
fin.

La commande Continue sautera en haut d'une boucle. Cet exemple ne s'imprimera également pas.
tout sauf contrairement à l'exemple de laPause, cela comptera jusqu'à 10.

programme Boucles;

var
i: entier;

commencer
i := 0;
répéter
i := i + 1;
Continuer;
Écris(i);
jusqu'à i = 10;
fin.

Apprendre la programmation Pascal Tutoriel Leçon 7

- Tableaux
Les tableaux sont des variables qui sont constituées de plusieurs variables du même type de données mais n'en ont qu'un seul.
nom. Voici une représentation visuelle d'un tableau avec 5 éléments :

1 valeur 1
2 valeur 2
3 valeur 3
4 valeur 4
5 valeur 5

Les tableaux sont déclarés presque de la même manière que les variables normales, sauf que vous
vous devez indiquer combien d'éléments vous souhaitez dans le tableau.

programme Tableaux;

var
a : tableau[1..5] d'Entier;

commencer
fin.

Nous accédons à chacun des éléments en utilisant le numéro des éléments qui le précède entre crochets.

programme Tableaux;

var
a: tableau[1..5] d'Entier;

début
a[1] := 12;
a[2] := 23;
a[3] := 34;
a[4] := 45;
a[5] := 56;
fin.

Il est beaucoup plus facile d'utiliser une boucle pour accéder aux valeurs d'un tableau. Voici un exemple de
lire 5 valeurs dans un tableau :

programme Tableaux;

var
a : tableau[1..5] d'Entier ;
i : Entier ;

commencer
pour i := 1 à 5 faire
Lire(a[i]);
fin.

Triage des tableaux

Vous voudrez parfois trier les valeurs d'un tableau dans un certain ordre. Pour ce faire, vous pouvez utiliser
un tri à bulles. Un tri à bulles est seulement l'une des nombreuses façons de trier un tableau. Avec un tri à bulles, le
les plus grands nombres sont déplacés à la fin du tableau.
Vous aurez besoin de 2 boucles. Une pour parcourir chaque nombre et une autre pour pointer vers l'autre nombre.
qui est en cours de comparaison. Si le nombre est plus grand, il est échangé avec l'autre. Vous allez
vous devez utiliser une variable temporaire pour stocker les valeurs pendant que vous les échangez.

programme Tableaux;

var
a: tableau[1..5] d'Entiers;
i, j, tmp : Entier ;

début
a[1] := 23;
a[2] := 45;
a[3] := 12;
a[4] := 56;
a[5] := 34;

pour i := 1 à 4 faire
pour j := i + 1 à 5 faire
si a[i] > a[j] alors
début
tmp := a[i];
a[i] := a[j];
a[j] := tmp;
fin;

pour i := 1 à 5 faire
writeln(i, ': ', a[i]);
fin.

tableaux 2D
Les tableaux peuvent avoir 2 dimensions au lieu d'une seule. En d'autres termes, ils peuvent avoir des lignes et
colonnes au lieu de simplement des lignes.

123
1123
2456
3789

Voici comment déclarer un tableau 2D :

programme Tableaux;

var
a : tableau [1..3,1..3] d'Entier;

début
fin.
Pour accéder aux valeurs d'un tableau 2D, vous devez utiliser 2 numéros dans les crochets. Les tableaux 2D également
requiert 2 boucles au lieu d'une seule.

programme Tableaux;

var
r, c: Entier;
a: tableau [1..3,1..3] d'Integer;

début
pour r := 1 à 3 faire
pour c := 1 à 3 faire
Lire(a[r,c]);
fin.

Vous pouvez obtenir des tableaux multidimensionnels qui ont plus de 2 dimensions, mais ceux-ci ne sont pas utilisés.
très souvent, donc vous n'avez pas besoin de vous en inquiéter.

Apprendre la programmation Pascal Tutoriel Leçon 8 - Types

Enregistrements et ensembles

Types

Il est possible de créer vos propres types de variables en utilisant l'instruction type. Le premier type que vous pouvez
fait des enregistrements. Les enregistrements sont 2 ou plusieurs variables de types différents en un. Un exemple de comment
cela pourrait être utilisé pour un étudiant qui a un numéro d'étudiant et un nom. Voici comment vous créez
un type :

programme Types;

Type
Étudiant
Numéro
Chaine
fin;

commencer
fin.

Après avoir créé le type, vous devez déclarer une variable de ce type pour pouvoir l'utiliser.

programme Types;

Type
DossierÉtudiant
Nombre
Chaîne
fin;

var
Étudiant
commencer
fin.

Pour accéder aux parties Numéro et Nom de l'enregistrement, vous devez faire ce qui suit :

programme Types;

Type
DossierÉtudiant
Nombre
Chaîne
fin;

var
Étudiant

commencer
É[Link]éro := 12345;
John Smith
fin.

L'autre type est un ensemble. Les ensembles ne sont pas très utiles et tout ce que vous pouvez faire avec un ensemble peut être fait
tout aussi facilement d'une autre manière. Ce qui suit est un exemple d'un ensemble appelé Animal qui comprend le chien,
chat et lapin comme les données qu'il peut stocker :

programme Types;

Tapez
ensemble de (chien, chat, lapin)

var
MonAnimal: Animal;

début
chien
fin.

Vous ne pouvez pas utiliser Readln ou Writeln sur des ensembles, donc la façon ci-dessus de l'utiliser n'est pas très utile. Vous pouvez
créer une plage de valeurs sous forme d'ensemble allant de 'a' à 'z'. Ce type d'ensemble peut être utilisé pour tester si une valeur est
dans cette plage.

programme Types;

utilisations
crt;

Taper
'a'..'z'

var
Lettre : ensemble d'Alpha ;
c : Char;
commencer
c := LireTouche;
si c dans [Lettre] alors
Vous avez entré une lettre
fin.

Apprendre la programmation Pascal Tutoriel Leçon 9

- Procédures et Fonctions
Procédures
Les procédures sont des sous-programmes qui peuvent être appelés depuis la partie principale du programme. Les procédures
sont déclarées en dehors du corps principal du programme en utilisant le mot-clé procédure. Les procédures doivent
doivent également avoir un nom unique. Les procédures ont leur propre début et fin. Voici un exemple de
Comment créer une procédure appelée Bonjour qui affiche "Bonjour" à l'écran.

programme Procédures;

procédure Bonjour;
commencer
Écrire('Bonjour');
fin;

commencer
fin.

Pour utiliser une procédure, nous devons l'appeler en utilisant son nom dans le corps principal.

programme Procédures;

procédure Bonjour;
commencer
Écrivez('Bonjour');
fin;

début
Bonjour;
fin.

Les procédures doivent toujours être au-dessus de l'endroit d'où elles sont appelées. Voici un exemple d'une procédure
qui appelle une autre procédure.

programme Procédures;

procédure Bonjour;
commencer
Écrire('Bonjour');
fin;

procédure BonjourAppel;
début
Bonjour;
fin;

début
BonjourAppel;
fin.

Les procédures peuvent avoir des paramètres tout comme les autres commandes que nous avons utilisées. Chacune
le paramètre est donné un nom et un type et est ensuite utilisé comme n'importe quelle autre variable. Si vous voulez
utilisez plus d'un paramètre, ils doivent alors être séparés par des points-virgules.

programme Procédures;

procedure Imprimer(s: Chaîne; i: Entier);

commencer
Écrivez(s);
Écris(i);
fin;

début
Imprimer('Bonjour', 3);
fin.

Variables globales et locales

Les variables que nous avons utilisées jusqu'à présent ont été globales car elles peuvent être utilisées à tout moment.
pendant le programme. Les variables locales ne peuvent être utilisées que dans les procédures, mais la mémoire qu'elles utilisent
est libéré lorsque la procédure n'est pas utilisée. Les variables locales sont déclarées juste en dessous de
déclaration de nom de procédure.

programme Procédures;

procédure Imprimer(s : Chaîne) ;

var
i : entier ;
début
pour i := 1 à 3 faire
Écrire(s);
fin;

commencer
Print('Bonjour');
fin.

Fonctions
Les fonctions sont comme des procédures sauf qu'elles renvoient une valeur. Le mot-clé 'function' est utilisé à la place de
procédure lors de la déclaration d'une fonction. Pour indiquer quel type de données doit être la valeur de retour, vous devez
utilisez un deux-points et le nom du type après le nom de la fonction.
programme Fonctions;

fonction Ajouter(i, j: Entier): Entier;

commencer
fin;

commencer
fin.

Affecter la valeur d'une fonction à une variable rend la variable égale à la valeur de retour. Si vous
utilisez une fonction dans quelque chose comme Writeln cela imprimera la valeur de retour. Pour définir la valeur de retour juste
donnez au nom de la fonction la valeur que vous souhaitez renvoyer.

programme Fonctions;

var
Réponse : Entier ;

fonction Ajouter(i, j: Entier): Entier;

commencer
Ajoutez := i + j;
fin;

début
Réponse := Ajouter(1,2);
Écrire(Add(1,2));
fin.

Vous pouvez quitter une procédure ou une fonction à tout moment en utilisant la commande Exit.

programme Procédures;

procédure GetName;
var
Chaîne
début
Écrivez('Quel est votre nom ?');
Lire(Nom);
si Nom = '' alors
Sortie;
Écris('Votre nom est ', Nom);
fin;

début
ObtenirNom
fin.

Apprendre le tutoriel de programmation Pascal Leçon

10 - Fichiers texte
Vous devriez maintenant savoir qu'un fichier texte est un fichier contenant des lignes de texte. Lorsque vous souhaitez accéder à un
Dans Pascal, vous devez d'abord créer une variable de fichier.

fichiers de programme;

var
Texte

commencer
fin.

Après que la variable a été déclarée, vous devez lui assigner le nom du fichier.

fichiers de programme;

var
f : Texte ;

commencer
Assigner(f,'[Link]');
fin.

Pour créer un nouveau fichier vide, nous utilisons la commande Rewrite. Cela écrasera tous les fichiers qui existent.
avec le même nom.
fichiers de programme;

var
f : Texte ;

commencer
Assigner(f, '[Link]');
Réécrire(f);
fin.

Les commandes Write et Writeln fonctionnent sur des fichiers de la même manière qu'elles fonctionnent à l'écran, sauf que
que vous devez utiliser un paramètre supplémentaire pour lui indiquer d'écrire dans le fichier.

Fichiers de programme;

var
f: Texte;

commencer
Assigner(f, '[Link]');
Réécrire(f);
Écris(f, 'Une ligne de texte');
fin.

Si vous souhaitez lire à partir d'un fichier qui existe déjà, vous devez utiliser Reset au lieu de Rewrite.
Utilisez ReadInt pour lire des lignes de texte à partir du fichier. Vous aurez également besoin d'une boucle while qui se répète jusqu'à ce que cela

arrive à la fin du fichier.

fichiers de programme;

var
Texte;
Chaîne

commencer
Affecter(f,'[Link]');
Réinitialiser(f);
tant que ce n'est pas la fin du fichier (f) faire
Lireln(f,s);
fin.

Append ouvre un fichier et vous permet d'ajouter plus de texte à la fin du fichier.

Fichiers de programme;

var
f: Texte;
s : Chaîne;

commencer
Attribuer(f,'[Link]');
Ajouter(f);
Ecris(f, 'Un peu plus de texte');
fin.

Peu importe lequel des 3 types d'accès que vous choisissez, vous devez toujours fermer un fichier lorsque vous êtes
fini de l'utiliser. Si vous ne le fermez pas, certaines des données qui y ont été écrites pourraient être perdues.

fichiers de programme;

var
f : Texte ;
Chaîne;

début
Affecter(f, '[Link]');
Ajouter(f);
Écrivez(f, 'Encore un peu de texte');
Fermer(f);
fin.

Vous pouvez changer le nom d'un fichier avec la commande Rename et vous pouvez supprimer un fichier avec la commande Erase
commande.
Fichiers de programme;

var
Texte;

début
Assigner(f,'[Link]');
Renommer(f, '[Link]');
 Effacer(f);
Fermer(f);
fin.

Pour savoir si un fichier existe, vous devez d'abord désactiver le contrôle des erreurs en utilisant le {$I-} compilateur
directive. Après cela, vous devez réinitialiser le fichier et si IOResult = 2 alors le fichier n'a pas été trouvé. Si
IOResult = 0 alors le fichier a été trouvé mais si c'est toute autre valeur alors le programme doit être terminé
avec la commande theHalt, IOResult perd sa valeur une fois qu'elle a été utilisée, donc nous devons aussi le mettre.
dans une autre variable avant de l'utiliser. Vous devez également utiliser {$I+} pour réactiver la vérification des erreurs.

fichiers de programme;

var
Texte;
Entier

début
Assigner(f, '[Link]');
{$I-}
Réinitialiser(f);
{$I+}
IOR := RésultatIO;
si IOR = 2 alors
Fichier non trouvé
sinon
si IOR <> 0 alors
Arrête;
Fermer(f);
fin.

Apprendre la programmation Pascal Tutoriel Leçon

11 - Fichiers de données
Les fichiers de données diffèrent des fichiers texte de plusieurs manières. Les fichiers de données sont un accès aléatoire, ce qui signifie
vous n'avez pas besoin de les lire ligne par ligne mais plutôt d'accéder à n'importe quelle partie du fichier à tout moment
temps. Voici comment vous déclarez un fichier de données :

programme FichiersDeDonnées;

var
f : fichier de Byte ;

commencer
fin.

Nous utilisons ensuite Assign de la même manière que nous le faisons avec un fichier texte.

programme DataFiles;

var
 f : fichier de Byte ;

début
Assigner(f, '[Link]');
fin.

Vous pouvez utiliser Rewriter pour créer un nouveau fichier ou écraser un fichier existant. La différence entre
Les fichiers texte et les fichiers de données lors de l'utilisation de Rewrite sont des fichiers de données qui peuvent être lus et écrits.

programme FichiersDonnées;

var
f : fichier de Byte ;

commencer
Affecter(f,'[Link]');
Réécrire(f);
fin.

Reset est le même que Réécrire, sauf qu'il n'écrase pas le fichier.
programme FichiersDeDonnées;

var
f : fichier d'octet ;

commencer
Affecter(f, '[Link]');
Réinitialiser(f);
fin.

Lorsque vous écrivez dans un fichier en utilisant la commande Write, vous devez d'abord mettre la valeur à écrire.
le fichier dans une variable. Avant de pouvoir écrire ou lire un fichier de données, vous devez utiliser le Seek
commande pour trouver le bon endroit pour commencer à écrire. Vous devez également vous rappeler que les fichiers de données commencent
à partir de la position 0 et non 1.

programme FichiersDeDonnées;

var
f : fichier de Byte;
Octet

début
Assigner(f,'[Link]');
Réinitialiser(f);
b := 1;
Chercher(f,0);
Écrire(f,b);
fin.

La commande Read est utilisée pour lire à partir d'un fichier de données.
programme FichiersDonnées;

var
f: fichier de Byte;
Octet

début
Assign(f,'[Link]');
Réinitialiser(f);
Chercher(f,0);
Lire(f,b);
fin.

Vous devez fermer un fichier de données lorsque vous avez terminé avec, tout comme avec les fichiers texte.

programme FichiersDeDonnées;

var
f: fichier de Byte;
b : Octet;

commencer
Attribuer(f,'[Link]');
Réinitialiser(f);
Rechercher(f,0);
Lire(f,b);
Fermer(f);
fin.

La commande FileSize peut être utilisée avec la commande FilePos pour déterminer quand vous avez
atteint la fin du fichier. FileSizeretourne le nombre réel d'enregistrements, ce qui signifie qu'il commence à
1 et pas 0. La commande FilePos vous indiquera à quelle position dans le fichier vous vous trouvez.

programme FichiersDeDonnées;

var
f : fichier de byte ;
octet

début
Assigner(f, '[Link]');
Réinitialiser(f);
tandis que FilePos(f) <> FileSize(f) faire
commencer
Lire(f,b);
Écrire(b);
fin;
Fermer(f);
fin.

La commande Truncate supprimera tout dans le fichier à partir de la position actuelle.

programme FichiersDeDonnées;
var
f : fichier d'octet ;

commencer
Affecter(f,'[Link]');
Réinitialiser(f);
Chercher(f,3);
Tronquer(f);
Fermer(f);
fin.

L'une des choses les plus utiles concernant les fichiers de données est que vous pouvez les utiliser pour stocker des enregistrements.

programme FichiersDeDonnées;

type
DossierÉtudiant
Entier
Chaîne
fin;

var
Étudiant : DossierÉtudiant ;
f : fichier de StudentRecord ;

commencer
Affecter(f, '[Link]');
Réécrire(f);
É[Link]éro := 12345;
John Smith
Écrire(f,Étudiant);
Fermer(f);
fin.

Apprendre la programmation Pascal Tutoriel Leçon

12 - Unités
Nous savons déjà que les unités, telles que l'unité crt, vous permettent d'utiliser plus de procédures et de fonctions que
les intégrés. Vous pouvez créer vos propres unités qui ont des procédures et des fonctions que vous
en ont fait.

Pour créer une unité, vous devez créer un nouveau fichier Pascal que nous appellerons [Link]. La première ligne
Le fichier doit commencer par le mot-clé 'unité' suivi du nom de l'unité. Le nom de l'unité et
le nom de fichier de l'unité doit être exactement le même.

unité MyUnit;

La ligne suivante est le mot-clé interface. Après cela, vous devez mettre les noms des procédures que
sera mis à disposition du programme qui utilisera votre unité. Pour cet exemple, nous allons être
Créer une fonction appelée NewReadln qui est comme Readln mais qui vous permet de limiter la quantité de
caractères pouvant être saisis.

unité MonUnité;

interface

fonction NewReadln(Max: Entier): Chaîne;

La ligne suivante est l'implémentation. C'est ici que vous saisirez le code complet pour les procédures et
fonctions. Nous aurons également besoin d'utiliser l'unité crt pour faireNewReadln. Nous terminons l'unité tout comme un
programme normal avec le mot clé fin.

unité MyUnit;

interface

fonction NewReadln(Max: Entier): Chaîne;

mise en œuvre

fonction NewReadln(Max: Entier): Chaine;

var
Chaîne
c: Char;
commencer
s := '';
répéter
c := LireTouche;
si (c = #8){#8 = RETOUR ARRIÈRE} et (s <> '') alors
commencer
Écrire(#8+' '+#8);
supprimer(s,longueur(s),1);
fin;
si (c <> #8) et (c <> #13){#13 = ENTRER} et (longueur(s) < Max) alors
début
Écrire(c);
s := s + c;
fin;
jusqu'à c = #13;
NouvelleLireLn := s;
fin;

fin.

Une fois que vous avez sauvegardé l'unité, vous devez la compiler. Maintenant, nous devons créer le programme qui utilise le
unité que nous venons de créer. Cette fois, nous allons taper MyUnit dans la section uses et ensuite utiliser le
Nouvelle fonction Readln.

programme MonProgramme;

utilisations
MonUnité;
var
s : Chaîne ;

commencer
s := NewReadln(10);
fin.

Apprendre le langage de programmation Pascal - Tutoriel de leçon

13 - Pointeurs
Qu'est-ce qu'un pointeur ?

Un pointeur est un type de variable qui stocke une adresse mémoire. Parce qu'il stocke une adresse mémoire
on dit qu'il pointe vers cela. Il existe 2 types de pointeurs qui sont typés et non typés. Un pointeur typé
un pointeur pointe vers une variable telle qu'un entier. Un pointeur non typé peut pointer vers n'importe quel type de
variable.

Déclaration et utilisation de pointeurs typés

Lorsque vous déclarez un pointeur typé, vous devez mettre un ^ devant le type de variable que vous souhaitez.
il pointe vers. Voici un exemple de comment déclarer un pointeur vers un entier :

programme Pointeurs;

var
p: ^entier;

début
fin.

Le signe @ peut être utilisé devant une variable pour obtenir son adresse mémoire. Cette adresse mémoire
peut alors être stocké dans un pointeur car les pointeurs stockent des adresses mémoire. Voici un exemple de
comment stocker l'adresse mémoire d'un entier dans un pointeur vers un entier :

programme Pointeurs;

var
i : entier ;
p : ^entier;

début
p := @i;
fin.

Si vous souhaitez changer la valeur stockée à l'adresse mémoire pointée par un pointeur, vous devez
d'abord, déréférez la variable pointeur en utilisant un ^ après le nom du pointeur. Voici un exemple de comment
changer la valeur d'un entier de 1 à 2 en utilisant un pointeur :
programme Pointeurs;

var
i : entier ;
p: ^entier;

commencer
i := 1;
p := @i;
p^ := 2;
writeln(i);
fin.

Vous pouvez allouer de la nouvelle mémoire à un pointeur typé en utilisant la commande new.
a un paramètre qui est un pointeur. Thenewcommand obtient la mémoire qui a la taille de la
type de variable du pointeur et ensuite définit le pointeur pour pointer vers l'adresse mémoire de celui-ci. Quand
vous avez fini d'utiliser le pointeur, vous devez utiliser la commande dispose pour libérer la mémoire.
a été alloué au pointeur. Voici un exemple :

programme Pointeurs;

var
p : ^entier;

début
nouveau(p);
p^ := 3;
writeln(p^);
disposer(p);
fin.

Déclaration et utilisation de pointeurs non typés

Lorsque vous déclarez un pointeur non typé, vous devez utiliser le type de variable appelé pointeur.

programme Pointeurs;

var
p : pointeur ;

commencer
fin.

Lorsque vous allouez de la mémoire à un pointeur non typé, vous devez utiliser la commande getmem au lieu de
thenewcommand et vous devez utiliser freemem au lieu de [Link] ont chacun
un deuxième paramètre qui est la taille en octets de la quantité de mémoire qui doit être allouée
au pointeur. Vous pouvez soit utiliser un nombre pour la taille, soit utiliser la fonction sizeof pour obtenir
la taille d'un type de variable spécifique.

programme Pointeurs;

var
 p : pointeur ;

début
getmem(p,sizeof(integer));
freemem(p, sizeof(integer));
fin.

Apprenez la Programmation Pascal Tutoriel Leçon

14 - Listes Chaînées
Qu'est-ce qu'une liste chaînée

Une liste chaînée est comme un tableau, sauf que le nombre d'éléments dans une liste chaînée peut changer contrairement.
un tableau. Une liste chaînée utilise des pointeurs pour indiquer l'élément suivant ou précédent.

Listes chaînées simples

Il existe 2 types de listes chaînées simples qui s'appellent des files d'attente et des piles.

Files
Une file d'attente est comme faire la queue devant un magasin. La première personne qui rejoint une file d'attente est la première
personne à servir. Vous devez toujours vous joindre à l'arrière de la file d'attente car si vous rejoignez l'avant
les autres personnes seront en colère. Cela s'appelle FIFO (Premier Entré, Premier Sorti).

Élément 1 --> Élément 2 --> Élément 3 --> (Jusqu'à l'élément final)

Chaque élément d'une liste chaînée est un enregistrement qui contient les données et un pointeur vers le suivant ou le précédent.
élément. Voici un exemple de la façon de déclarer l'enregistrement pour une file d'attente et un pointeur vers un enregistrement de file d'attente
ainsi que les variables nécessaires :

programme file;

type
pQueue = ^tqueue;
tQueue = enregistrement
entier
suivant : pQueue ;
fin;

var
tête, dernier, cur: pQueue;

commencer
fin.
Nous allons maintenant créer 3 procédures. La première procédure ajoutera des éléments à la liste, la seconde...
voir la liste et le troisième libérera la mémoire utilisée par la file d'attente. Avant de faire le
procédures regardons d'abord le programme principal.

commencer
head := nil;{Définir head à nil car il n'y a aucun élément dans la file d'attente}
ajouter(1){Ajoutez 1 à la file d'attente en utilisant la procédure d'ajout};
ajoute(2);
ajouter(3);
{Voir tous les éléments dans lafile d'attente}
détruire
fin.

La procédure d'ajout prendra un entier comme paramètre et ajoutera cet entier à la fin de
file d'attente.

procédure ajouter(i : entier);

commencer
nouveau(cur);{Créer un nouvel élément de file d'attente}
cur^.data := i;{Définir la valeur de l'élément de la file d'attente à i}
cur^.next := nil;{Définir le prochain élément dans la file d'attente sur nil parce que ça
n'existe pas
si head = nil alors {S'il n'y a pas de tête de la file alors}
head := cur{La tête est le nouvel en-tête car c'est le premier élément qui est
ajouté à la liste}
sinon
dernier^.suivant := cur;{Définir le dernier élément précédent comme courant car il est
le nouvel ultime élément dans la file d'attente
dernier := courant; {Faire de l'élément courant le dernier élément de la file d'attente}
fin;

La procédure de vue utilise une boucle pour afficher les données du premier élément au dernier élément de la
file d'attente.

procédure vue;
commencer
cur := tête;{Définir actuel au début de la file d'attente}
tant que cur <> nil faire {Tant qu'il y a un élément courant}
commencer
writeln(cur^.data);{Afficher l'élément actuel}
cur := cur^.next;{Définir l'actuel sur le prochain élément dans la file d'attente}
fin;
fin;

La procédure de destruction libérera la mémoire qui a été utilisée par la file d'attente.

procédure détruire;
début
cur := tête; {Définir courant au début de la file d'attente}
tant que cur <> nil faire {Tant qu'il y a un élément dans la file d'attente}
commencer
cur := cur^.next;{Stocker l'élément suivant dans courant}
dispose(head);{Libérer la mémoire utilisée par head}
 head := cur;{Définir le nouveau head de la file d'attente sur l'élément actuel}
fin;
fin;

Piles
Pour comprendre une pile, vous devez penser à une pile d'assiettes. Vous pouvez ajouter une assiette au sommet de
la pile et en prendre un du dessus mais vous ne pouvez pas ajouter ou enlever une assiette du dessous sans
toutes les assiettes tombent. Cela s'appelle LIFO (Last In First Out).

Article 1 <-- Article 2 <-- Article 3 <-- (Jusqu'au dernier article)

Lorsque vous déclarez l'enregistrement pour un élément de pile, vous devez utiliser précédent au lieu de suivant. Voici un
exemple.

programme pile;

type
pStack = ^tStack;
tStack = enregistrement
entier
préc: pStack;
fin;

var
dernier, cour: pStack;

début
dernier := nil;
ajouter(3);
ajouter(2);
ajouter(1);
vue
détruire
fin.

Vous verrez que les nombres sont ajoutés de 3 à 1 avec une pile au lieu de 1 à 3. Ceci est
car les choses doivent sortir du haut de la pile plutôt que de l'avant d'une file d'attente.

La procédure d'ajout ajoute l'élément après le dernier élément de la pile.

procédure ajouter(i : entier);

commencer
nouveau(cur);{Créer un nouvel élément de pile}
cur^.data := i;{Définir la valeur de l'élément sur la valeur du paramètre}
cur^.prev := last;{Définir l'élément précédent comme le dernier élément de la pile}
dernier := actuel;{Faites de l'élément actuel le nouvel élément dernier}
fin;

Les procédures de visualisation et de destruction sont presque les mêmes que celles d'une file d'attente, donc elles n'auront pas besoin d'être

expliqué.
procédure vue;
commencer
cur := dernier;
tant que cur <> nil faire
commencer
writeln(cur^.data);
cur := cur^.prev;
fin;
fin;

procédure détruire;
commencer
tandis que dernier <> nil faire
commencer
cur := last^.prev;
jeter(dernier);
dernier := cur;
fin;
fin;