Chapitre III. Algorithmique Et Pascal

Chapitre III.
ALGORITHMIQUE ET PASCAL ESCF
Chapitre III. Algorithmique et Pascal
1 Définition d’un algorithme .............................................................................................................. 2

1.1 Structure d’un algorithme ....................................................................................................... 2
2 Variables et constantes ................................................................................................................... 4
3 Opérations et structures ................................................................................................................. 5
3.1 Opération d’affectation ........................................................................................................... 5
3.2 Opérations d’entrée-sortie ...................................................................................................... 6
A. Opération de lecture ............................................................................................................... 7
B. Opération d’écriture ................................................................................................................ 7
3.3 Structures conditionnelles....................................................................................................... 9
A. Structures conditionnelles simples ......................................................................................... 9
B. Structures conditionnelles composées ................................................................................... 9
3.4 Boucles .................................................................................................................................. 10
A. Boucle Tant que…faire........................................................................................................... 11
B. Boucle Répéter …jusqu’à ....................................................................................................... 11
C. Boucle Pour…faire ................................................................................................................. 12
4 Introduction au PASCAL................................................................................................................. 13
4.1 Les opérations élémentaires de Pascal ................................................................................. 13
4.2 Le premier programme sous l’environnement Pascal .......................................................... 14
4.3 Les instructions de décision .................................................................................................. 15
4.4 Les instructions répétitives.................................................................................................... 16
1
Chapitre III. ALGORITHMIQUE ET PASCAL ESCF
1 DÉFINITION D’UN ALGORITHME
Un algorithme est une méthode qui sert à résoudre un problème donné. C’est une suite
ordonnée d’opérations élémentaires écrites dans un langage proche du naturel et manipulant
un ensemble de données pour réaliser une tâche déterminée (Voir la figure ci-dessous).
Données
Opérations
élémentaires
Résultats
Exemple : Le traitement qui consiste à calculer l’aire S d’un cercle selon la formule S= 
R2 nécessite l’entrée d’une information (le rayon R) et fournira après le calcul (une suite
d’opérations de multiplication) un résultat : l’aire S.
Un algorithme n’est pas directement utilisable par la machine. Il représente une phase intermédiaire
entre l’analyse du problème et le développement du programme (voir la figure ci-dessous).
1.1 Structure d’un algorithme
D’une façon générale, un algorithme est une suite d’opérations (on parlera d’instruction
lorsqu’il s’agira de programmation) élémentaires devant être exécutés dans un ordre donné,
pour accomplir une tâche donnée.
Exemple :
Avez-vous déjà ouvert un livre de recettes de cuisine ?
2
Préparation d’omelettes -------------------------------------- En-tête
Objets :œufs, sel, poêle, huile, assiette, fourneau-- Déclaration

Début
1. Laver les œufs.
2. Casser les œufs dans une assiette.
3. Battre les œufs dans une assiette
4. Verser un peu d’huile
5. dans la poêle Suite
6. Chauffer la poêle
7. Verser le contenu de l’assiette dans la poêle
d’opérations
8. Patienter quelques minutes puis tirer la poêle
9. Mettre le contenu de la poêle dans l’assiette
Fin
Nous pouvons constater dans cet exemple simple que l’ordre des opérations a de
l’importance. En effet, on ne peut intervertir les opérations 1 et 2, ou encore 2 et 3 et ainsi de
suite.
Pour construire un algorithme on a besoin de trois parties:
1- En-tête : Elle est constitué du mot clé « Algorithme » suivi de son nom « Nom-
Algorithme »
2- Déclaration : Elle est réservée pour la déclaration des différentes constantes et variables
utilisées par le traitement. Les constantes seront nommés et initialisés et les variables
seront nommés et leurs types seront indiqués.
3- Suite d’opérations: Elle représente le traitement qui est encadré par les deux mots clés
« début » et « fin ».
En générale la forme d’un algorithme se présente comme suit :
Algorithme : nom-Algorithme
Déclaration :
Déclaration des variables ;
Début
Opération 1 ;
Opération 2 ;
………..………..
Opération N ;
Fin
3
2 VARIABLES ET CONSTANTES
Dans un programme, on a besoin toujours de stocker provisoirement des valeurs : Il peut

s’agir des données ou bien des résultats obtenus par le programme, intermédiaires ou
définitifs. Ces valeurs sont des grandeurs qui sont susceptibles de varier, car un algorithme de
traitement a vocation à pouvoir traiter, de manière répétitive, toutes sortes de valeurs
différentes. On les appelle pour cette raison des variables. On trouvera également, dans les
algorithmes, des grandeurs dont la valeur est fixée définitivement (par exemple  qui vaut
toujours 3.14159…). Ce sont des constantes.
Il faut noter qu’une variable est un emplacement mémoire accessible par une adresse
(l’étiquette de la variable) qui contient une valeur qui varie durant l’exécution du programme
alors qu’une constante est un emplacement dont la valeur ne varie pas.
Une variable ou une constante doit toujours posséder un nom appelé identificateur qui doit
être aussi explicite que possible. La règle consiste à construire les noms de variables et de
constantes en n’utilisant que des caractères alphabétiques, des chiffres et le symbole de
soulignement « _ ». Un identificateur doit toujours commencer par une lettre et ne doit jamais
contenir d’espace.
Exemple :
Rayon, surface, Pi sont des noms corrects.
Prix ttc, 27xyz sont des noms incorrects car le premier contient un espace et le deuxième
commence par des chiffres.
Les variables peuvent être de différents types, nous étudions seulement ceux les plus simples.
Voir le tableau suivant pour des exemples sur les types et leurs tailles dans la RAM.
Type exemple Taille mémoire

Entier -2 0 1 2 3 16 bit
Réel -2 0 1 2.25 3.6 2.15 E3 32 bit
Caractères A b c ? 1 6,! 8 bit
Booléen vrai, faux 1 bit
Exemple :
Constantes
Pi= 3.14159 ;
Variables
Rayon, surface : réels ;
4
3 OPÉRATIONS ET STRUCTURES
3.1 Opération d’affectation
Dans un algorithme, on est appelé à sauvegarder les données et les résultats

intermédiaires dans des variables. On parle d’opération d’affection qui permet d’attribuer une
valeur à une variable. Elle est notée par le signe ←
Syntaxe :
Variable ← expression ;
Exemple : Pour la formule surface =  × rayon2 on écrira :
surface ←  × rayon2 ;
Remarque : une instruction d’affectation ne modifie que la variable qui est situé à
gauche de la flèche.
Exercice 1 (avec solution) : Quelles seront les valeurs des variables A et B après
l’exécution des instructions suivantes?
Remarque : les instructions sont numérotées pour utiliser ces numéros dans le tableau
d’exécution.
Algorithme Exo1 ;
A, B : Entier ;
Début
1 A←1;
2 B←A+3;
3 A←A+1;
4 B←A–4;
Fin
Exécution de l’algorithme de l’exercice 1
Variables
Instructions A B
1 1 \
2 1 4
3 2 4
4 2 -2
5
Donc les valeurs de A et B après l’exécution de l’algorithme sont : 2 et -2 respectivement
Exercice 2 : L’algorithme suivant contient deux erreurs. Lesquelles ?
Algorithme Exo2 ;
A, B, C : Entier ;
Début
A←5;
C←A+B;
A←2;
C←C–A;
A← 2.5 ;
Fin
Repense
Ligne de l’erreur explication

C←A+B; B a été utilisé dans la partie droite d’une
affectation sans être initialisée.
A← 2.5 ; Une valeur réelle est affectée à une
variable entière.
Exercice 3 :
L’algorithme suivant est-il correct ? Si votre réponse est ‘non’, proposez les
corrections possibles.
Algorithme Exo3
Variable
A, B, C, D : chaine de caractères ;
Début
A ← ‘Bonjour’ ;
B ← ‘A’ ;
C←A;
D ← Bonjour ;
Fin
3.2 Opérations d’entrée-sortie
Dans n’importe quel programme, des échanges d’informations ont lieu entre l’utilisateur et la
machine. Ces échanges sont appelés opérations d’entrée-sortie. La saisie de données
6
correspond à une entrée d’information (lecture) faite généralement par le clavier. L’affichage
à l’écran des résultats du traitement de ces données correspond à une sortie (écriture).
Exemple :
Pour le calcul de l’aire d’un cercle, il faut :
1. Saisir le rayon du cercle (lecture).

2. Affecter à la variable surface, le résultat de l’expression  × rayon2 .
3. Afficher la surface (écriture).
A. Opération de lecture
Pour introduire des valeurs à l’ordinateur via le clavier, on utilise l’instruction de lecture qui
a la syntaxe suivante :
Syntaxe :
lire (liste-variables) ;
Où liste-variables est une variable ou une suite de variables séparées par des virgules.
Exemple :
Lire (x) ;
Lire (x, y) ;
B. Opération d’écriture
Pour afficher les résultats et les commentaires du programme, on fait appel à l’instruction
d’écriture dont la syntaxe est la suivante :
Syntaxe :
Ecrire (expression) ;
Où expression peut être une chaine de caractères (du texte), une constante, une variable,
ou une combinaison de ces derniers.
La chaine de caractères doit être délimitée par deux apostrophes ‘ ‘ .
Exemple :
Ecrire (5) ;
L’écran affiche : 5.
7
Ecrire (x) ;
L’écran affiche le contenu de la variable x. Si x contient la valeur 12, l’écran affiche: 12.
Ecrire (‘y = ’, 10) ;
L’écran affiche : y = 10.
Ecrire (‘ceci est un test d’’affichage’) ;
L’écran affiche : ceci est un test d’affichage.
Ecrire (‘le produit de ’, x, ‘fois’, y, ‘est égal à’, x*y) ;
Si x=10 et y=20, L’écran affiche : le produit de 10 fois 20 est égal à 200.
Exercice 4 (avec solution): Quel résultat produit l’algorithme suivant en supposant que
l’utilisateur a entré le nombre 10?
Algorithme : test
Déclaration val, C : entier ;
Début
1 Lire (Val) ;
2 C ← Val * Val ;
3 Ecrire (Val) ;
4 Ecrire (‘Le carré de’, VAL, ‘est ’, C) ;
Fin
If faut exécuter l’algorithme pour connaitre son résultat. Le tableau d’exécution doit
inclure la partie écran si l’algorithme contient des opérations de lecture/écriture.
Variables
Instructions Val C Écran
Saisi par l’utilisateur
1 10 \ 10
2 10 100 10 Affichés par
3 10 100 Le carré de 10 est 100 l’instruction écrire
8
4 10 100
Selon le tableau d’exécution l’algorithme ‘test’ affiche le carré d’un nombre entré par
l’utilisateur. Dans l’exécution ci-dessus il a affiché 100 car le nombre entré par l’utilisateur
est 10.
Exercice 5 : Ecrire un algorithme qui calcul la somme de deux nombres entiers entrés par
l’utilisateur .
3.3 Structures conditionnelles
Tous les langages de programmation possèdent des instructions permettant d’exécuter une
suite d’opérations (séquence) si une condition est vérifiée. Cette séquence est composée d’une
ou plusieurs instructions. La condition s’exprime sous la forme d’une expression logique
(booléenne) simple (avec des opérateurs relationnelles <, <=, >, >=, =, ) ou combinée
(plusieurs conditions composées avec des opérateurs logiques ET, OU, et NON).
A. Structures conditionnelles simples
La structure conditionnelle simple se présente sous la forme suivante :

Syntaxe :
Si (condition) Alors
Séquence ;
Fin Si
Si la condition est vérifiée (vraie) alors la séquence s’exécute. Dans le cas contraire, ne
rien faire.
Exemple :
Si (x>y) alors
Ecrire (x, ‘est supérieur à’, y) ;
Fin si
Exercice 6 : Ecrire un algorithme qui lit un nombre puis vérifie s’il est positif, négatif
ou nul.
B. Structures conditionnelles composées
La structure conditionnelle composée se présente sous la forme suivante :
9
Syntaxe :
Si (condition) Alors
Séquence 1 ;
Sinon
Séquence 2 ;
Fin Si
Si la condition est vérifiée (vraie) alors la séquence 1 s’exécute. Dans le cas contraire,
c’est la séquence 2 qui s’exécute.
Exemple :
Si (x>y) alors
Ecrire (x, ‘est supérieur à ’, y) ;
Sinon
Ecrire (y, ‘est supérieur à’, x);
Fin si
Exercice 7 : Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe

ensuite si leur produit est négatif ou positif (on laisse de côté le cas où le produit est nul).
Attention: on ne doit pas calculer le produit des deux nombres.
3.4 Boucles
Dans un algorithme, il arrive souvent qu’une ou plusieurs opérations doivent s’exécuter

plusieurs fois dans une structure répétitive appelée boucle.
Dans une boucle, le nombre de répétition peut être soit :
- Connu
- Fixé par l’utilisateur
- Dépendre d’une condition
permettant l’arrêt et la sortie de la boucle
Il existe trois types de boucles :
1) Boucle Tant que….faire

2) Boucle Répéter ….jusqu’à
10
3) Boucle Pour….faire
A. Boucle Tant que…faire
Syntaxe :
Tant que (condition) faire

Séquence ;
Fin tant que
Cette structure permet la répétition d’une ou plusieurs instructions tant qu’une condition est
satisfaite.
Principe :
1) Évaluer la condition.
2) Si la condition est vraie alors :
a. Exécuter la séquence.
b. à la rencontre du mot clé « Fin Tant que », revenir à 1).
3) si la condition est fausse alors :
- exécuter l’instruction qui vient après Fin tant que
Exercice 8: Écrire un algorithme qui demande un nombre compris entre 10 et 20,

jusqu’à ce que la réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un
message : « Plus petit ! », et inversement, « Plus grand ! » si le nombre est inférieur à 10. Si
le nombre est compris entre 10 et 20 on fera apparaitre le massage « votre nombre est compris
entre 10 et 20 »
B. Boucle Répéter …jusqu’à
Syntaxe
Répéter
Séquence ;
Jusqu'a (condition)
Cette structure permet la répétition d’une ou plusieurs instructions jusqu’à ce qu’une

condition soit vérifiée.
Principe
1- exécuter -sans condition- la séquence.
2- évaluer la condition.
2-1- Si elle est fausse, revenir à 1.
2-2- Si la condition est vraie sortir de la boucle et exécuter l’instruction qui
vient après Jusqu’à (condition).
Remarque :
11
Dans cette structure, contrairement à la structure « Tant que…faire », lorsqu’une

condition est vérifiée, le traitement s’arrête. De plus, la condition n’est testée qu’après
une première exécution de la séquence définie. Les instructions sont donc exécutées au
moins une fois, même si la condition n’est pas vérifiée.
Exercice 9:
Ecrire un algorithme qui permet de calculer le factoriel d’un nombre entier positif N.
C. Boucle Pour…faire
A la différence des deux boucles précédemment présentées, la boucle Pour…faire

permet de répéter seulement une séquence un nombre connu de fois.
Syntaxe :
Pour indice Val-Init à Val-fin faire
Séquence;
Fin Pour
Où Val-Init : valeur initiale.

Val-fin : valeur finale.
Indice : le compteur de la boucle.
Indice est une variable de type entier
Val-Init et Val-Fin sont des constantes ou des variables de type entier.
Principe :
1- A la rencontre du mot clé Pour, la variable indice est initialisée à valeur initiale
(indice  Val-Init).
2- Si indice <= Val-fin alors
2-1- la séquence est exécuté.
2-2- à la rencontre du mot clé Fin Pour, l’indice est incrémenté par 1
(indiceindice+1)
2-3- retourner à 2-
3- Sinon (indice > Val-Fin), sortir de la boucle et exécuter l’instruction qui vient après
fin pour.
Exercice 10:
Ecrire un algorithme qui permet d’afficher la table de multiplication par 7 comme suit :
1*7=7
2*7=14
………….
12
4 INTRODUCTION AU PASCAL
Pascal est un langage de programmation évolué orienté vers les calcules

scientifique. Grâce à sa simplicité et sa structuration, il est le langage le mieux adapté à
l’enseignement de la programmation.
Un programme pascal est constitué de trois parties essentielles :
- La partie entête. « comporte le nom du programme »

- La partie déclarative. « déclaration des variables d’entée/sortie »
- La partie traitement. « corps du programme »
1- La partie entête :
L’entête du programme pascal est défini par le mot clé « program » et le nom du
programme suivi d’un point virgule
Exemple : program monprogramme ;
2- La partie déclarative :
- La déclaration des variables est définie par le mot clé « Var »

Exemple : var a, b : integer ;
X : real ;
- La déclaration des constante est définie par le mot clé « Const »

Exemple : const n=10 ; car=’A’ ;
3- Partie traitement :
Commence par le mot clé ‘Begin’ et se termine par le mot clé ‘End.’
4.1 Les opérations élémentaires de Pascal
1- L’affectation :
En pascal l’affectation est faite de la manière suivante :
S := A+ B ; sachant que A, B et S sont de même type.
2- La lecture :
La lecture peut se faire de deux manières :
- Read (A) ; lire une valeur et la mettre dans la variable A.
- Readln (A) ; lire une valeur et la mettre dans la variable A et revenir à la ligne.
13
3- L’écriture :
Plusieurs choses peuvent s’afficher sur l’écran : la valeur d’une variable ou d’une
constante, un message, une ligne vide… selon ce qu’on veut afficher, il faut utiliser l’une
des manières suivantes :
- Write (S) ; afficher la valeur de la variable S.
- Writeln (S) ; afficher la valeur de la variable S et revenir à la ligne.
- Writeln (‘S=’, S) ; afficher le message « S= » suivi de la valeur de la variable S et

revenir à la ligne
- Writeln ; sauter une ligne sur l’écran.
4.2 Le premier programme sous l’environnement Pascal
Ecrire un programme qui affiche le message : Bonjour le monde.

- Lancer Turbo Pascal
- Une fenêtre d’édition s’affichera su votre écran, sur cette fenêtre, écrive le
programme ci-dessous :
Program Bonjour;
Begin
Write (‘Bonjour le monde’);
End.
- Sauvegarder le programme sous le nom : Bonj.Pas, pour cela exécuter la
commande save ou save as du menu File ou simplement utiliser la touche F2
du clavier.
- Compiler le programme, pour cela sélectionner le menu Compile et exécuter la
commande Compile ou simplement utiliser le raccourci Alt+F9. Dans cette
étape le programme est traduit en langage machine (binaire), et est vérifié
syntaxiquement (et non pas sémantiquement), dans le cas où il ya des erreurs,
le compilateur affiche un message d’erreur.
- Une fois le programme compilé il reste qu’à voir le résultat du programme
(l’exécution), pour cela, sélectionner le menu Run puis la commande Run ou
simplement le raccourci Ctrl+F9 pour exécuter le programme.
Vous remarquez qu’un écran noir apparait pendant quelque secondes, puis
disparait.
- Revenir au programme Bonjour, et ajouter l’instruction Readln ; après
l’instruction Write.
- Recompiler le programme et ré-exécuter le, l’écran d’exécution s’affiche, il
disparaitra lorsqu’on appuie sur n’importe quelle touche du clavier, c’est l’effet
de l’instruction Readln.
14
Exercice 11 : écrire un programme pascal qui permet de calculer la surface et le

périmètre d’un rectangle.
4.3 Les instructions de décision
1- L’instruction de décision : Si…..Fin Si
Algorithmique Pascal
Si (condition) Alors If (condition) then

Bloc d’instruction Bloc d’instruction
Fin si
Remarque :
Si le bloc d’instruction contient plus d’une instruction, il faut le délimiter par un

« Begin …end ; »
Exemple :
Le bloc d’instruction contient une seule instruction :
Si (A>B) Alors if (A>B) then

Ecrire (A, ‘est supérieur à ‘, B) ; Write (A, ‘est supérieur à’, B) ;
Fin Si
Le bloc d’instruction contient plusieurs instructions :
Si (B0) Alors If (B<> 0) then

X-A/B ; Begin
Ecrire (‘x=’, X) ; X: = -A/B;
Fin Si Write (‘X=’, X);
End;
2- L’instruction de décision alternée: si….sinon…..fin si
Si (condition) alors if (condition) then

Bloc d’instruction1 Bloc d’instruction1
Sinon else
Bloc d’instruction2 Bloc d’instruction2
Fin si
Remarque :
15

Exercice 12: écrire un programme pascal qui permet de résoudre une équation du
1er degré.
4.4 Les instructions répétitives
1- La boucle Tant Que :
Tant Que (conditio) faire while (condition) do

Fin tant que
2- La boucle Pour :
Pour iValinit à Valfin faire For i: = Valinit to Valfin Do

Fin pour
3- La boucle Répéter:
Répéter Repeat
Jusqu’à (condition) Until (condition) ;
Remarque :

Exercice 13: écrire un programme pascal qui permet de calculer la somme des N
premiers nombres entiers.
Références
1. Algorithmique et structures de données, S. graine, édition l'abeille, 2001
2. Algorithmique et programmation en Pascal. M.c Belaid, édition Pages Bleues, 2008
3. Cours d'algorithmique et exercices avec solutions. S. Bellout, 2008
16

Chapitre III. Algorithmique Et Pascal

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre III. Algorithmique Et Pascal

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre III.

ALGORITHMIQUE ET PASCAL ESCF

Chapitre III. Algorithmique et Pascal

1 Définition d’un algorithme .............................................................................................................. 2

1 DÉFINITION D’UN ALGORITHME

1.1 Structure d’un algorithme

Préparation d’omelettes -------------------------------------- En-tête

Objets :œufs, sel, poêle, huile, assiette, fourneau-- Déclaration

Pour construire un algorithme on a besoin de trois parties:

En générale la forme d’un algorithme se présente comme suit :

Déclaration des variables ;

Dans un programme, on a besoin toujours de stocker provisoirement des valeurs : Il peut

Rayon, surface, Pi sont des noms corrects.

Type exemple Taille mémoire

Rayon, surface : réels ;

3.1 Opération d’affectation

Dans un algorithme, on est appelé à sauvegarder les données et les résultats

Exemple : Pour la formule surface =  × rayon2 on écrira :

Exécution de l’algorithme de l’exercice 1

Donc les valeurs de A et B après l’exécution de l’algorithme sont : 2 et -2 respectivement

Exercice 2 : L’algorithme suivant contient deux erreurs. Lesquelles ?

Ligne de l’erreur explication

3.2 Opérations d’entrée-sortie

Pour le calcul de l’aire d’un cercle, il faut :

1. Saisir le rayon du cercle (lecture).

La chaine de caractères doit être délimitée par deux apostrophes ‘ ‘ .

Ecrire (‘y = ’, 10) ;

L’écran affiche : y = 10.

Ecrire (‘ceci est un test d’’affichage’) ;

L’écran affiche : ceci est un test d’affichage.

Ecrire (‘le produit de ’, x, ‘fois’, y, ‘est égal à’, x*y) ;

Si x=10 et y=20, L’écran affiche : le produit de 10 fois 20 est égal à 200.

Déclaration val, C : entier ;

4 Ecrire (‘Le carré de’, VAL, ‘est ’, C) ;

3.3 Structures conditionnelles

A. Structures conditionnelles simples

La structure conditionnelle simple se présente sous la forme suivante :

B. Structures conditionnelles composées

La structure conditionnelle composée se présente sous la forme suivante :

Exercice 7 : Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe

Dans un algorithme, il arrive souvent qu’une ou plusieurs opérations doivent s’exécuter

Dans une boucle, le nombre de répétition peut être soit :

permettant l’arrêt et la sortie de la boucle

Il existe trois types de boucles :

1) Boucle Tant que….faire

A. Boucle Tant que…faire

Tant que (condition) faire

- exécuter l’instruction qui vient après Fin tant que

Exercice 8: Écrire un algorithme qui demande un nombre compris entre 10 et 20,

B. Boucle Répéter …jusqu’à

Cette structure permet la répétition d’une ou plusieurs instructions jusqu’à ce qu’une

Dans cette structure, contrairement à la structure « Tant que…faire », lorsqu’une

A la différence des deux boucles précédemment présentées, la boucle Pour…faire

Où Val-Init : valeur initiale.

Pascal est un langage de programmation évolué orienté vers les calcules

Un programme pascal est constitué de trois parties essentielles :

- La partie entête. « comporte le nom du programme »

Exemple : program monprogramme ;

- La déclaration des variables est définie par le mot clé « Var »

- La déclaration des constante est définie par le mot clé « Const »

4.1 Les opérations élémentaires de Pascal

En pascal l’affectation est faite de la manière suivante :

S := A+ B ; sachant que A, B et S sont de même type.