algorithmique

ALGORITHMIQUE
Sommaire
1.Introduction :............................................................................................................................4
Les trois grandes étapes d’un algorithme....................................................................................4
Préparation au traitement............................................................................................................4
Traitement du problème :............................................................................................................4
L’édition du résultat :..................................................................................................................4
Les commentaires :.....................................................................................................................4
Les variables :.............................................................................................................................4
Définition :..................................................................................................................................4
Déclaration des variables :..........................................................................................................5
Variables de types numériques classiques :................................................................................5
Variables de types Alphanumériques :........................................................................................5
Variables de type Booléen :......................................................................................................5
Les instructions de base :............................................................................................................6
L’instruction d’affichage :..........................................................................................................6
L’instruction de lecture :.............................................................................................................6
L’instruction d’affectation :........................................................................................................6
Expression et opérateur...............................................................................................................7
Définitions :.................................................................................................................................7
Opérateurs numériques :.............................................................................................................7
Opérateur alphanumérique : &....................................................................................................7
Opérateurs logiques (ou booléens) :............................................................................................8
Chapitre II : La structure alternative...........................................................................................9
1.Introduction :..........................................................................................................................10
La structure alternative Si … alors … Sinon …. :....................................................................10
La structure alternative Cas …… Fin cas :...............................................................................12
Chapitre III : Les structure répétitives......................................................................................14
1.Introduction :..........................................................................................................................15
La structure TantQue................................................................................................................15
La structure Répéter jusqu’à:....................................................................................................16
La structure Pour :.....................................................................................................................17
Définition :................................................................................................................................19
Déclaration d’un tableau à une dimension (vecteur):...............................................................19
Opérations sur les vecteurs :.....................................................................................................19
Chargement d’un vecteur..........................................................................................................19
Recherche du Max et du Min d’un vecteur :.............................................................................19
Somme et produit des deux vecteurs :......................................................................................19
Recherche d’un élément dans un vecteur (première occurrence).............................................20
Recherche d’un élément dans un vecteur (toutes les occurrences)...........................................20
Fusion de deux tableaux quelconques.......................................................................................20
Eclatement d’un tableau selon le signe des éléments :.............................................................20
Tri d’un vecteur :.......................................................................................................................20
Algorithme de tri par sélection :..............................................................................................20
Algorithme de tri de bulle:.......................................................................................................21
Déclaration d’un tableau à deux dimensions:...........................................................................21
Chapitre IV : Les Fonctions et procédures................................................................................22
Définitions :...............................................................................................................................23
Déclaration................................................................................................................................23
Procédures ................................................................................................................................23
ALGORITHMIQUE
Fonctions...................................................................................................................................24
Passage de paramètres et visibilité...........................................................................................24
Paramètres par valeur................................................................................................................25
Paramètres par variable.............................................................................................................26
ALGORITHMIQUE
Chapitre I : Les éléments de base de l’algorithmique
Les éléments de base de
l’algorithmique
ALGORITHMIQUE
1. Introduction :
L’algorithme est une suite d’instructions menant celui qui l’exécute à résoudre
un problème donné. C’est une description statique d’enchaînement dynamique des
différentes actions destinées à être exécutées.
Une fois l’algorithme est écris, il ’y a trois possibilité :
1. Exécuter à la main les différentes étapes de l’algorithme.
2. Faire exécuter par une machine qui comprend le langage algorithmique.
3. Traduire l’algorithme dans un langage de programmation.
Enoncé du
problème :
Données
Analyse
Algorithme
ALGORITHME
Programme
Exécution du
programme par
une machine
Résultat
Programmation
Les trois grandes étapes d’un algorithme
Préparation au traitement
Elle consiste à indiquer les différentes données nécessaires à la résolution du problème
et de vérifier leur cohérence si nécessaire.
Traitement du problème :
Consiste à résoudre le problème pas à pas, par la décomposition de celui en plusieurs
sous problème si nécessaire.
L’édition du résultat :
C’est l’affichage sur écran des résultats obtenus dans l’étape précédente afin que
l’utilisateur puisse en prendre connaissance.
Les commentaires :
Pour accroître la lisibilité la lisibilité d’un algorithme, on peut introduire des
commentaires qui ne sont pas des instructions destinées à la machine mais des indicateurs
donnés aux lecteurs de l’algorithme. Ces commentaires sont encadrés par le symbole % .
Les variables :
Définition :
Une variable est utilisée pour stocker provisoirement des données qui seront utilisées
par la suite dans un programme informatique. Avant qu’elle soit utilisée, une variable doit
d’abord être déclarée.
ALGORITHMIQUE
Déclaration des variables :
La déclaration d’une variable consiste à lui réserver un emplacement mémoire et de
préciser ce qui l’on voudra mettre dedans (le type de codage utilisé).
Variables de types numériques classiques :
Comme son l’indique, ces variables sont destinées à recevoir des nombres. Le type de
codage choisi pour un nombre va déterminer :
Les valeurs Max et Min pouvant être stockés dans la variable.
La précision de ces nombres (dans le cas des nombres décimaux).
Type Numérique
Plage
Byte (Octet)
0 à 255
Entier simple
-32 768 à 32 767
Entier double
-2 147 483 648 à 2 147 483 647
Réel simple
-3.40x1038 à -1.40x10-45 pour les valeurs négatives
1.40x10-45 à 3.40x1038
Réel double
pour les valeurs positives
-1.79x10308 à -4.94x10-324 pour les valeurs négatives
4.94x10-324 à 1.79x10308 pour les valeurs positives
Dans ce cours, on va utiliser les variables numériques de type Entier et réels. En
pseudo code de l’algorithme, une déclaration d’une variable aura ainsi cette forme :
VAR x : Entier
Ou encore
VAR Prixht, TauxTVA : Réel
Variables de types Alphanumériques :
Dans une variable de ce type, on stocke des caractères, qu’il s’agisse de lettres, de
signes de ponctuation, d’espaces, ou même de chiffres. Un groupe de caractère est souvent
appelé chaîne de caractères. En pseudo code, une chaîne de caractères est toujours notée entre
guillemets.
Le type alphanumérique est appelé également type caractère, type chaîne ou en
anglais type string. Ainsi une déclaration d’une variable alphanumérique aura cette forme :
VAR A : String.
Variables de type Booléen :
Ces variables permettent de stocker uniquement les valeurs logiques : VRAI ou FAUX
ALGORITHMIQUE
Les instructions de base :
L’instruction d’affichage :
C’est l’opération qui consiste à visualiser sur l’écran des valeurs.
Syntaxe : Ecrire (`` Bonjour tout le monde’’) ou encore Ecrire (PrixTTC)
L’instruction de lecture :
Le terme Lecture s’applique à une opération d’entrer de valeur provenant d’un
périphérique (Clavier) et diriger vers des zones mémoires.
Syntaxe : Lire (TauxTVA) ou encore Lire (nbre1, nbre2)
L’instruction d’affectation :
Elle permet d’affecter une valeur à une variable, le signe d’affectation est `  ’, on note :
Variable  Valeur ou Variable  Expression
Exemple :
PrixHT  50
PrixTTC  PrixHT * (1+TauxTVA)
Exercice 1.1 :
Quelles seront les valeurs des variables A et B après l’exécution des instructions
suivantes ?
VAR A, B : Entier
Début
A1
BA
A3
Fin
Exercice 1.2 :
Ecrire un algorithme permettant d’échanger les valeurs de deux variables, et ce quel que
soit leur contenu préalable.
Exercice 1.3 :
On dispose de trois variables A, B et C. Ecrire un algorithme transférant à B la valeur de
A, à C la valeur de B et à A la valeur de C. (toujours quels que soient les contenus préalables
de ces variables).
ALGORITHMIQUE
Expression et opérateur
Définitions :
Une expression est un ensemble de valeurs, reliées par des opérateurs, et équivalent à
une seule valeur.
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat, il dépend
toujours du type des valeurs qui sont en jeu.
Opérateurs numériques :
Ce sont les quatre opérations arithmétiques classiques à savoir :
+
–
*
/
Mod
Div
Addition
Soustraction
Multiplication
Division.
le reste de la division entière. Exemple : 10 Mod 3 = 1.
La division entière. Exemple : 10 Div 3 = 3.
N.B : La multiplication et la division ont « «naturellement » priorité sur l’addition et la
soustraction.
Exercice 1.4 :
Quelles seront les valeurs des variables A, B et C après l’exécution des instructions
suivantes ?
VAR A, B, C : Entier
Début
A5
B3
CA+B
A C - A
B  C*A
Fin
Exercice 1.5 :
Ecrire un programme qui calcule la somme de deux nombres entiers.
Exercice 1.6 :
Ecrire un algorithme permettant de calculer la surface d’un rectangle.
Exercice 1.7 :
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et affiche
le carré de ce nombre.
Opérateur alphanumérique : &
Cet opérateur permet de concaténer deux chaînes de caractères, le signe de
concaténation étant : &. On note :
A  ``IGA’’
ALGORITHMIQUE
B  ``TE’’
CA&B
C aura comme valeur à la fin de l’algorithme : ``IGATE’’.
Exercice 1.8 :
Que produit l’algorithme suivant :
VAR A, B, C: String
Début
A  ``423’’
B  ``12’’
CA+B
Exercice 1.9 :
Que produit l’algorithme suivant :
VAR A, B, C : String
Début
A  ``423’’
B  ``12’’
CA&B
Fin
Opérateurs logiques (ou booléens) :
Il s’agit des opérateurs ET, OU, NON et XOR :
AND
OR
XOR
X
Y
X AND Y
X
Y
X OR Y
X
Y
X XOR Y
False
False
False
False
False
False
False
False
False
False
True
False
False
True
True
False
True
True
True
False
False
True
False
True
True
False
True
True
True
True
True
True
True
True
True
False
NON
X
NON X
True
False
False
True
ALGORITHMIQUE
Chapitre II : La structure alternative
La structure
alternative
ALGORITHMIQUE
1. Introduction :
La structure alternative permet de contrôler l’ordre d’exécution des actions suite à la
vérification d’une variable Booléen ou une condition.
Un booléen est une expression dont la valeur est Vrai ou Faux .Cela peut donc être :
•
Une variable booléen
•
Une condition
Une condition est une comparaison de deux valeurs de même type en faisant
appel à un opérateur de comparaison. Les opérateurs de comparaison sont :
•
= égal à …
•
<> différent de ….
•
< strictement plus petit que …
•
> strictement plus grand que …
•
=< plus petit ou égal à …
•
>= plus grand ou égal à …
Une condition peut être simple, ou composée de deux ou plusieurs conditions en utilisant
les opérateurs logiques vus précédemment, à savoir : ET, OU, NON, et XOR.
Le formalisme de cette structure dans un organigramme sera comme suit :
Formalisme d’une Structure alternative
Non
Condition
Oui
Actions 2
La structure alternative Si … alors … Sinon …. :
Syntaxe :
Si Booléen alors
traitement1
Sinon
traitement2
Fsi
Actions 1
ALGORITHMIQUE
Explication :
Arrivée à la première ligne (Si…Alors) la machine examine la valeur du booléen, si la
variable Booléen est vérifiée, alors la machine va exécuter le traitement1, dés qu’il termine ce
traitement, il saute directement à la première instruction située après le « Fsi », dans le cas
contraire, la machine saute directement à la première ligne située après le « Sinon » et
exécute le traitement2.
Les traitements qui suivent le Sinon ou le Alors peuvent être :

Une simple instruction.
Si Booléen alors
traitement1
Sinon
traitement2
Fsi
 Une instruction vide :
On prend par exemple le cas où le traitement2 est vide, on notera dan ce cas :
Si Booléen alors
traitement1
Fsi.
 Une suite d’instructions :
Si le traitement1 (idem pour le traitement2) est composé de plus d’une instruction, dans ce
cas on est amené à délimiter ces instructions entre les deux mots réservés Début et Fin, on
notera alors :
Si Booléen alors
Début
instruction1
instruction2 Bloc d’instructions
instruction3
Fin
Sinon
traitement2
Fsi.
 Une autre structure alternative
La structure alternative sera notée :
Si Booléen alors
Si Booléen alors
traitement1
Sinon
Traitement2
Fsi
Sinon
Traitement3
Fsi
Exercice2.1 :
ALGORITHMIQUE
Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce
nombre est positif ou négatif (on laisse de côté le cas où le nombre vaut zéro).
Exercice2.2 :
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).Toutefois, on
dois pas calculer le produit des deux nombres.
Exercice2.3 :
Même exercice que le 2.1 en incluant cette fois le traitement du cas où le nombre vaut
zéro.
Exercice2.4 :
Même exercice que le 2.2 en incluant cette fois le traitement du cas où le produit est
nul.
Exercice 2.5 :
Ecrire un algorithme qui permet de résoudre une équation du 1er degré. L’équation est
sous la forme a*x + b = 0
Exercice 2.6 :
Ecrire un algorithme qui permet de résoudre une équation du 2er degré. L’équation est
sous la forme a*x² + b*x + c = 0
La structure alternative Cas …… Fin cas :
Syntaxe :
Cas variable parmi
Valeur1 : traitement1
Valeur2 : traitement2
Valeur 3 : traitement 3
…………………….
…………………….
Valeur N : traitement N
Autres cas : traitement
Fin cas
L’instruction cas est une instruction de sélection qui permet de choisir entre N
éventualités selon la valeur d’une variable d’un type scalaire. En effet, elle permet de
comparer une variable (ou expression) avec des valeurs de même type.
N.B :
L’instruction Cas nous permet de comparer que des variables de type scalaire avec des
constantes.
Voir le site Web : http://www.pise.info/algo/
Exemple :
ALGORITHMIQUE
Lire (Valeur)
Lire (Opérateur)
Cas Opérateur parmi
‘+’: Valeur  Valeur + Valeur
‘-‘ : Valeur  Valeur - Valeur
‘*’: Valeur  Valeur * Valeur
Fin cas.
Exercice 2.7 :
Ecrire un algorithme qui permet à une société d’établir le planning de la semaine de
telle manière suivante :

Lundi  Gestion du personnel

Mardi  Facturation

Jeudi Comptabilité

Mercredi Gestion

Vendredi  Paie
du stock
Exercice 2.8 :
Ecrire un algorithme qui permet d’effectuer trois traitements qui distincts selon qu’un
caractère lu est un chiffre, une lettre minuscule ou bien une lettre majuscule.
Exercice 2.9 :
Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il
l’informe de sa catégorie :
"Poussin" de 6 à 7 ans
"Pupille" de 8 à 9 ans
"Minime" de 10 à 11 ans
"Cadet" après 12 ans
Peut-on concevoir plusieurs algorithmes équivalents menant à ce résultat ?
Exercice 2.10
Cet algorithme est destiné à prédire l'avenir, et il doit être infaillible !
Il lira au clavier l’heure et les minutes, et il affichera l’heure qu’il sera une minute plus
tard. Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme doit répondre :
"Dans une minute, il sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la vérifier.
Exercice 2.11
De même que le précédent, cet algorithme doit demander une heure et en afficher une
autre. Mais cette fois, il doit gérer également les secondes, et afficher l'heure qu'il sera une
seconde plus tard.
Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit répondre : "Dans
une seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
ALGORITHMIQUE
Chapitre III : Les structure répétitives
Les structures
répétitives
1. Introduction :
Un programme a presque toujours pour rôle de répéter une même action un certain nombre de
fois. Pour ce faire on utilise une structure permettant de dire « Exécute telles actions jusqu’à ce que
telle condition soit remplie ».
Exemple :
Tant que le clou n’est pas enfoncé Répéter donner un coup de marteau sur sa tête.
Bien qu’une seule soit nécessaire, la plupart des langages de programmation proposent trois
types de structure répétitive à savoir :

La structure Tant que.

La structure Répéter.

La structure Pour.
La structure TantQue
Le formalisme de cette structure dans un organigramme sera comme suit :
Formalisme d’une Boucle TantQue
Condition
Non
Oui
Actions
Syntaxe :
condition
TantQue
Faire
Début
instruction1
instruction2 Bloc d’instructions
instruction3
Fin
FTant.
Explication :
Le bloc d’instructions est exécuté tant que la condition est vérifiée, dés que celle-ci
cesse d’être vérifié l’exécution de la répétitive s’arrête.
La condition peut ne pas être vérifier dés la première exécution d’une répétitive, dans
ce cas, le bloc d’instruction ne sera jamais exécute.
Exercice 3.1:
Ecrire un algorithme qui demande à l’utilisateur de fournir un nombre compris entre 1
et 4 jusqu’à ce que la réponse convienne.
Exercice 3.2:
Ecrire un algorithme qui demande un nombre compris entre 10 et 30, jusqu’à ce que la
réponse convienne. En cas de réponse supérieure à 30, on fera apparaître un message:«Plus
petit!», et inversement, «Plus grand !» si le nombre est inférieur à 10.
Exercice 3.3:
Ecrire un algorithme qui demande un nombre de départ, et qui calcule la somme des
entiers jusqu’à ce nombre.
Exercice 3.4:
Ecrire un algorithme qui demande un nombre de départ à l’utilisateur, et qui calcule
ensuite le produit et la moyenne des entiers jusqu’à ce nombre.
La structure Répéter jusqu’à:
Le formalisme de cette structure dans un organigramme sera comme suit:
Formalisme d’une Boucle Répéter jusqu’à
Actions
Condition
Oui
Syntaxe :
Répéter
Action
Jusqu’à Condition
Explication :
Non
L’action est exécutée jusqu’à ce que la condition soit vraie, autrement dite, tant que la
condition est fausse, répéter l’action.
Donc, avec l’instruction répéter, on ‘a au moins une seule exécution de l’action
Exercice 3.5:
Ecrire un algorithme permettant de calculer la somme des carrés des N premiers
entiers en utilisant la structure Répéter: 0²+1²+2²+3²+4²+………+N².
Exercice 3.6:
Ecrire un algorithme qui affiche un triangle avec le nombre de lignes qu’on va lui donner.
Exemple : n = 4
*
**
***
****
La structure Pour :
Très souvent, on utilise une structure répétitive avec un compteur et on s’arrête lorsque
le compteur a atteint sa valeur finale.
C’est pourquoi la plupart des langages de programmation offrent une structure
permettant d’écrire cette répétitive plus simplement. C’est la structure POUR :
Le formalisme de cette structure dans un organigramme sera comme suit :
Formalisme d’une Boucle Pour
POUR Variable = Valeur
initiale A Valeur finale Faire
Actions
Suivant Variable
Syntaxe :
POUR variable = DE valeur initiale A valeur finale FAIRE
Actions
Fin Pour
Exemple :
POUR i = 1 A 10 FAIRE
p
p*x
Fin Pour.
Chapitre IV: Les TABLEAUX
Les tableaux
Définition :
Lorsque les données sont nombreuses et de même nature, et pour éviter de multiplier le
nombre de variables, il est plus pratique de ranger ces données dans un tableau.
On appelle «Tableau » un ensemble de valeurs portant le même nom de variable et repérées
par un nombre dite « indice ».
Chaque fois que l’on doit désigner un élément du tableau, on fait figurer le nom du tableau,
suivi par l’indice de l’élément entre parenthèses.
Déclaration d’un tableau à une dimension (vecteur):
Syntaxe :
Var
idt_Vble : array [type d’indice] of type d’élément
Type
idt_type : array [type d’indice] of type d’élément
Var
idt_Vble : idt_type.
Opérations sur les vecteurs :
Chargement d’un vecteur
Le chargement consiste à stocker des valeurs dans le tableau au niveau de la mémoire
centrale. C’est une opération obligatoire. Sans elle, l’utilisation d’un tableau est inutile
puisqu’il sera vide.
Exercice 4.1:
Ecrire un algorithme qui déclare et remplisse un tableau contenant les six voyelles de
l’alphabet latin.
Exercice 4.2:
Ecrire un algorithme qui déclare un tableau de 9 valeurs numériques ont les mettant
toutes à 0.
Exercice 4.3:
Modifier l’exercice précédant
déclaration d’une variable constante).
pour une taille du tableau égale à 50(notion de
Recherche du Max et du Min d’un vecteur :
Exercice 4.4:
Ecrire un algorithme qui déclare un vecteur de 10 notes dont on fait ensuite saisir les
valeurs par l’utilisateur, calculer la moyenne, le maximum et le minimum des notes fournies.
Somme et produit des deux vecteurs :
Exercice 4.5:
Ecrire un algorithme constituant un tableau à partir de deux tableaux de même
longueur préalablement saisie. Le nouveau tableau sera la somme des éléments des deux
tableaux de départ.
Exercice 4.6:
Même question que l’exercice précédant mais en multipliant les éléments des deux tableaux.
Recherche d’un élément dans un vecteur (première
occurrence)
Exercice 4.7:
Ecrire un algorithme qui déclare et remplisse un vecteur, puis il recherche une valeur
fournit par l’utilisateur, on précisant l’indice du vecteur dans le quel la valeur a été trouvée.
Recherche d’un élément dans un vecteur (toutes les
occurrences)
Exercice 4.8:
Même question que l’exercice précèdent mais cette fois on recherche toutes les
occurrences.
Fusion de deux tableaux quelconques
Eclatement d’un tableau selon le signe des éléments :
Tri d’un vecteur :
La notion du tri, ou classement, se rencontre dans de nombreuses applications en
algorithme. Le tri est défini comme un processus de rangement d’un ensemble de valeurs
suivant un certain ordre ce qui permet la recherche et l’accès aux différentes données.
Algorithme de tri par sélection :
Cette méthode consiste à chercher le plus petit élément d’un vecteur « T » et à la
permuter avec T (1), puis le deuxième plus petit élément de T/ {T (1)} et le permuter avec T
(2), et ainsi de suite.
Programme tri_Selection
Const
Nmax =30
Var
T : array [1..Nmax] of réel
N, i, j : entier
Temp : réel
Début
i  0;
Tant que (i < n - 1) faire
j  i + 1;
Tant que (j < n) faire
Début
Si t[j] < t[i] alors
Début
tmp  t[j]
t[j]  t[i]
t[i]  tmp
End
jj+ 1
Fin
Ftq
i  i + 1;
Ftq
Fin
Algorithme de tri de bulle:
Un tri bulle est un tri plus astucieux, son principe est de faire remonter petit à petit un élément
trop grand vers le haut du tableau en comparant les éléments deux à deux.
Si l’élément de gauche est supérieur à son voisin de droit on les inverse et on continue avec le
suivant. Lorsque l’on est en haut du tableau on repart au début et on s’arrête lorsque tous es éléments
sont bien placés.
Déclaration d’un tableau à deux dimensions:
Un tableau à deux dimensions correspond à la notation de matrice (M x N). Il contient
des éléments tous de même type. Chaque élément du tableau est repéré à travers un couple
d’indices (lg, cl).
Syntaxe :
Var
idt_Vble : array [type d’indice, type d’indice] of type d’élément
Type
idt_type : array [type d’indice, type d’indice] of type d’élément
Var
idt_Vble : idt_type.
Chapitre IV : Les Fonctions et procédures
Les Fonctions et proc 閐
ures
Définitions :
Les procédures et les fonctions sont les sous-programmes de Turbo-Pascal. Elles sont de deux sortes :
prédéfinies et déclarées par l’utilisateur.
Les procédures et fonctions prédéfinies sont très nombreuses en Turbo- Pascal. La liste complète par
ordre alphabétique est donnée dans la partie 3. Elles n’ont pas besoin d’être déclarées et sont utilisées
telles quelles.
Les procédures et fonctions de l’utilisateur doivent être déclarées dans la section de déclarations d’un
bloc, c'est-à-dire qu’une procédure peut contenir une autre procédure. Elles se comportent alors
comme des blocs indépendants, comportant eux-même une partie déclarative et une partie exécutable.
Si on déclare une procédure ou fonction de même nom q’une procédure ou fonction prédéfinie. Il n’ y
a pas d’erreur, mais on perd l’accès à la procédure prédéfinie tant que la procédure déclarée est visible.
Déclaration
Procédures
Une procédure se déclare par un en-tête, suivi d’un bloc comprenant une section de
déclarations (qui peut être absent) et une section exécutable.
L’en-tête contient le mot réservé PROCEDURE, le nom donné à la procédure et, le cas
échéant, une liste des paramètres et leurs types.
Syntaxe :
Procédure Nom ;
Ou Procédure Nom (param1, param2 : type A….paramN : typeN) ;
Ou encore Procédure Nom (Var param1, param2 …. type A, … ; paramN : typeN) ;
Exemples :
Procédure Merveille ;
Procédure Extra (nombre : Integer ; lettre : char) ;
Procédure Bien (Var quand : Jour ; Var ou : Lieu ; Prix : Integer) ;
Les paramètres qui figurent dans l’en-tête s’appellent des paramètres formels. Lorsqu’ils sont
précédés du mot Var, les paramètres sont passés par variable (cas de Jour et Lieu ci-dessus) ;
si non, ils sont passés par valeur (voir ci-dessous).
Les types de paramètres formels sont quelconques, mai si ce des types déclarés, ils doivent
être visibles depuis la procédure. C’est le cas de Jour et Lieu dans l’exemple ci-dessus.
La partie déclaration d’une procédure est identique à celle d’un programme. Elle n’est pas
obligatoire : si la procédure ne se sert que de variables globales (peu recommandé), ou
seulement des paramètres qu’on lui passe, elle sera absente.
Si elle existe, on peut y définir des types, des constantes, des variables (qui seront locales),
ainsi que des procédures ou fonctions plus internes. Les paramètres figurant dans l’en-tête ne
doivent bien sûr pas être déclarés. Tous les objets déclarés à l’intérieur d’une procédure ou
fonction ne sont accessibles qu’à l’intérieur de leur bloc, ou de blocs plus internes.
La section exécutable doit commencer par BEGIN et se termine par END.
La syntaxe complète d’une procédure est donc( Les éléments entre crochets sont facultatifs) :
Procedure
Nom ( liste éventuelle de paramètres)
[ Section de déclaration ]
Begin
………….
………….
End
Exemple :
Pour appeler une procédure, il suffit d’invoquer son nom, accompagné des paramètres
à passer dans l’ordre de la déclaration s’il y en a.
Fonctions
Les fonctions se déclarent par le mot réservé Function, de manière identique à une
procédure, avec la seule différence qu’elles retournent une valeur dont il faut indiquer le type.
Ce dernier ne pourra être qu’un des types suivants : entier ; Char , Byte, Real, Booléen,
chaîne, énuméré, intervalle, ou pointeur.
Syntaxe :
Function
Nom (Liste de paramètres ) : Type _ résultat ;
Function
Maximum (i, j: integer) : Boolean ;
A l’intérieur de la section exécutable, le nom de la fonction doit être affecter au moins une
fois d’une valeur compatible avec le type déclaré de son résultat.
Pour invoquer une fonction, il faut affecter une variable de type compatible avec son résultat.
Exemple :
Function
Begin
Change ( var valeur : integer) : boolean ;
If
valeur 100 Then
Begin
Valeur : = 0 ;
Change : = true
End
Else change : = false ;
End ;
Cette fonction remplace le paramètre qu’on lui passe par 0 s’il est inférieur à 100 et ne le
change pas dans le cas contraire. Elle renvoie le booléen Tue si elle a changé la valeur (et
False sinon). Notez le passage du paramètre par variable : Le paramètre réel est modifié.
Passage de paramètres et visibilité
Tout ce qui suit s’applique aussi bien aux fonctions qu’aux procédures. Par conséquent, à
chaque fois que nous écrivons procédure, lisez procédure ou fonction.
Il est interdit de définir un type dans l’en-tête de procédure. S’ils ne sont pas des types
simples prédéfinis, les types des paramètres formels doivent donc avoir été définis
auparavant. Il est par exemple interdit d’écrire :
Procedure TOTO (nom: string [20] ; tab : Array [ 1..4 ] of real ) ;
Il faut d’abord définir les types:
Type
string20 = string [ 20 ] ;
Tableau = Array [1..4] of real ;
Puis déclarer la procédure :
Procedure TOTO (nom: string20 ; tab : Tableau ) ;
Lors de l’appel d’une procédure, si la déclaration comporte des paramètres formels, il faut
indiquer entre parenthèses autant de paramètres réels qu’il y a de paramètres formels dans la
déclaration. On les sépare par des virgules et ils doivent correspondre aux types mentionnés
dans la déclaration, dans le même ordre. A l’exécution, les paramètres formels seront
remplacés par les paramètres réels. Cette substitution fonctionne différemment suivant que
les paramètres sont passés par valeur (sans var) ou par variable (avec var).
Paramètres par valeur
Au moment de l’appel, la valeur du paramètre réel est calculée et est affectée à
l’identificateur du paramètre formel.
Une nouvelle variable est donc créée dans la procédure, dotée du nm du paramètre formel, et
initialisée par la valeur passée. cette nouvelle variable existera durant toute l’exécution de la
procédure, puis sera éliminée lorsqu’on quitte le bloc.
Le point capital à bien assimiler est que le paramètre réel n’est pas affecté par les
modifications faites à l’intérieur de la procédure, puisqu’il ne s’agit pas de la même variable.
C’est pourquoi on peut passer valeur toute variable,expression ou constante, de type
correspondant au paramètre attendu.
Exemple
Program
Valeur ;
Type
chaine = string[20] ;
Var
mot : chaine ;
Procedure Bonjour( Qui : chaine) ;
Begin
Qui := ’ Bonjour, ‘+Qui ;
Writeln(Qui)
End ;
Begin
Writeln(‘Quel est votre nom? ’)
Realdln( Mot) ;
Bonjour( Mot) ;
Writeln( Mot)
End.
Lorsqu’on appelle la procédure Bonjour, il se crée une variable Qui , initialisée avec la valeur
passée, c’est – à – dire le contenu de Mot. Mais il faut bien comprendre que qui et Mot sont
deux variables différentes. Bonjour modifie ensuite Qui , mais Mot n’est pas affecté, comme
le prouve le Writeln( Mot).
On aurait d’ailleurs pu passer une constante à Bonjour :
Bonjour ("Monsieur") ;
Qui affichera tout simplement Bonjour Monsieur. On peut aussi passer une expression :
Bonjour ("Monsieur"+Mot) ;
Remarques :
La variable qui est totalement inconnue du programme principal, puisqu’elle est déclarée dans
la procédure.
La variable Mot est globale ; elle est donc visible depuis la procédure, dans laquelle on peut
l’utiliser ou la modifier. Ces modifications seront conservées à la sortie de la procédure. Dans
l’exemple simple ci-dessus, si on rajoute la ligne suivante à la procédure Bonjour :
Mot : = "Plus personne !" ;
L’exécution donnera :
Quel est votre nom ?
Martin
Bonjour, Martin
Plus personne !
Mais la procédure perd alors de sa lisibilité, puisqu’elle fait appel à un identificateur extérieur.
Le programme principal aussi, puisque l’une de ses variables est modifiée par une procédure,
ce qui n’apparaît pas à sa lecture.
Le passage par valeur n’est économique ni en temps ni en mémoire. En effet, la création
d’une nouvelle variable dans la pile et recopie de la valeur transmise prennent une place et un
temps qui deviennent non négligeables dés que le paramètre dépasse une certaine taille. C’est
particulièrement fréquent pour les tableaux ou les enregistrements.
Le passage par valeur permet la récursivité : à chaque nouvel appel de la procédure, les
variables sont recrées avec une nouvelle valeur (voir plus loin)/
Résumé :
Le passage par valeur ne modifie pas les paramètres réels ; il donne des procédures très
lisibilités et indépendantes les unes des autres. Il clarifie le programme. Mais il est gourmand
en temps et en mémoire.
Paramètres par variable
Les choses sont très différentes lors du passage par variable. Comme son nom l’indique, le
paramètre réel que l’on passe doit être une variable. Dans ce cas, la procédure ne crée pas de
nouvelle variable, mais utilise directement celle qu’on lui passe. Il est donc évident que les
modifications faites par la procédure seront répercutées sur le paramètre réel.
Exemple :
Program
Par_Variable ;
Type
Chaine = String [40] ;
Var
Mot : Chaine ;
Procédure
Bonjour (Var Qui : Chaine) ;
Begin
Qui := ’ Bonjour, ‘ + Qui ;
Writeln(Qui) ;
Qui : = ‘ Au Revoir ; ‘ + Copy (Qui, 10,40) + ‘ ! ‘ ;
End ;
Begin
Writeln (‘Quel est votre nom? ’)
Realdln ( Mot) ;
Bonjour ( Mot) ;
Writeln ( Mot)
End.
Cette fois, la procédure Mot modifie réellement la variable Mot.
En structurant correctement le programme, l’utilisation du passage par variable peut permettre
de s’affranchir presque entièrement des variables globales :
Program
Sans_globale ;
Type
Chaine = String [40] ;
Procédure
Bonjour (Var Qui : Chaine) ;
Begin
Qui := ’ Bonjour, ‘ + Qui ;
End ;
Procedure
Salut ;
Var
Begin
Mot : Chaine ;
Writeln (‘Quel est votre nom? ’)
Realdln ( Mot) ;
Bonjour ( Mot) ;
Writeln ( Mot)
End ;
Begin
Salut
End.
Cette fois, la variable Mot est déclarée dans la procédure Salut et bonjour est appelée depuis
Salut. Comme Mot est passé par variable, il est modifié par Bonjour et est correctement
affiché par Salut. Il n’y a plus de variable globale et on en tire un gain de place et de lisibilité.
CHAPITRE VII : Procédures
Les procédures et fonctions sont des sortes de sous-programmes écrits avant le
programme principal mais appelés depuis ce programme principal, d'une autre procédure ou
même d'une autre fonction. Le nom d'une procédure ou d'une fonction (ou comme celui d'un
tableau, d'une variable ou d'une constante) de doit pas excéder 127 caractères et ne pas
contenir d'accent. Ce nom doit, en outre, être différent de celui d'une instruction en Pascal.
L'appel d'une procédure peut dépendre d'une structure de boucle, de condition, etc.
1. Procédure simple
2. Variables locales et sous-procédures
3. Procédure paramétrée
4. Syntaxe Var
1. Procédure simple
Une procédure peut voir ses variables définies par le programme principal, c'est-à-dire
que ces variables sont valables pour tout le programme et accessible partout dans le
programme principal mais aussi dans les procédures et fonctions qui auront été déclarées
après. La déclaration des variables se fait alors avant la déclaration de la procédure pour
qu'elle puisse les utiliser. Car une procédure déclarée avant les variables ne peut pas connaître
leur existence et ne peut donc pas les utiliser.
Syntaxe :
Program nom de programme ;
Var variable : type ;
Procedure nom de procédure ;
Begin
...
commandes
...
End;
BEGIN
nom de procédure ;
END.
Program exemple9a;
Uses crt;
Var a, b, c: real;
Procedure maths;
Begin
a := a + 10 ;
b := sqrt(a) ;
c := sin(b) ;
End;
BEGIN
Clrscr;
Write('Entrez un nombre :') ;
Readln(a) ;
Repeat
maths;
Writeln (c);
Until keypressed ;
END.
Ce programme exemple9a appelle une procédure appelée maths qui effectue des
calculs successifs. Cette procédure est appelée depuis une boucle qui ne se stoppe que
lorsqu'une touche du clavier est pressée (instruction keypressed). Durant cette procédure, on
additionne 10 à la valeur de a entrée par l'utilisateur, puis on effectue le carré (sqrt) du nombre
ainsi obtenu, et enfin, on cherche le sinus (sin) de ce dernier nombre.
2. Variables locales et sous-procédures
Une procédure peut avoir ses propres variables locales qui seront réinitialisées à
chaque appel. Ces variables n'existent alors que dans la procédure. Ainsi, une procédure peut
utiliser les variables globales du programme (déclarées en tout début) mais aussi ses propres
variables locales qui lui sont réservées. Une procédure ne peut pas appeler une variable locale
appartenant à une autre procédure. Les variables locales doivent porter des noms différents de
celles globales si ces dernières ont été déclarées avant la procédure. Enfin, on peut utiliser
dans une procédure, un nom pour une variable locale déjà utilisé pour une autre variable
locale dans une autre procédure.
Une procédure, étant un sous-programme complet, peut contenir ses propres
procédures et fonctions qui n'existent alors que lorsque la procédure principale est en cours.
Un sous-procédure ne peut appeler d'autres procédures ou fonctions que si ces dernières font
parti du programme principal ou de la procédure qui contient la sous-procédure.
Syntaxe :
Procedure nom de procédure ;
Var variable : type ;
Procedure nom de sous-procédure ;
Var variable : type ;
Begin
...
End ;
Begin
...
commandes
...
End ;
3. Procédure paramétrée
On peut aussi créer des procédures paramétrées (dont les variables n'existent que dans
la procédure). Ces procédures là ont l'intérêt de pouvoir, contrairement aux procédures
simples, être déclarée avant les variables globales du programme principal ; elles n'utiliseront
que les variables passées en paramètres ! Le programme principal (ou une autre procédure qui
aurait été déclarée après) affecte alors des valeurs de variables à la procédure en passant des
variables en paramètres. Et ces valeurs s'incorporent dans les variables propres à la procédure
(dont les identificateurs peuvent ou non êtres identiques, ça n'a aucune espèce d'importance).
La déclaration des variables se fait alors en même temps que la déclaration de la
procédure, ces variables sont des paramètres formels car existant uniquement dans la
procédure. Lorsque que le programme appelle la procédure et lui envoie des valeurs de type
simple (car celles de type complexe ne sont pas acceptées, voir chapitre 20 sur les types),
celles-ci sont appelées paramètres réels car les variables sont définies dans le programme
principal et ne sont pas valables dans la procédure.
A noter qu'on peut passer en paramètre directement des valeurs (nombre, chaînes de
caractères...) aussi bien que des variables.
Syntaxe :
Program nom de programme ;
Procedure nom de procédure( noms de variables : types ) ;
Begin
...
commandes
...
End ;
BEGIN
nom de procédure ( noms d'autres variables ou leurs valeurs ) ;
END.
Note : on peut passer en paramètre à une procédure des types simples et structurés.
Attention
néanmoins à déclarer des types spécifiques de tableau à l'aide de la syntaxe Type (voir
Chapitre 20
sur les "Types simples et structurés") car le passage d'un tableau en tant que type
Array à une procédure est impossible.
Program exemple9b ;
Uses Crt ;
Procedure maths ( param : Real ) ;
Begin
WriteLn('Procédure de calcul. Veuillez patienter.') ;
param := Sin(Sqrt(param+10)) ;
WriteLn(param) ;
End ;
Var nombre : Real ;
BEGIN
ClrScr ;
Write('Entrez un nombre :') ;
ReadLn(nombre) ;
maths (nombre) ;
ReadLn ;
END.
Ce programme exemple9b appelle une procédure paramétrée appelée maths qui
effectue les mêmes calculs que le programme exemple9a. Mais ici, la variable est déclarée
après la procédure paramétrée. Donc, la procédure ne connaît pas l'existence de la variable
nombre, ainsi, pour qu'elle puisse l'utiliser, il faut le lui passer en paramètre !
4. Syntaxe Var (procédures et fonctions)
Il est quelquefois nécessaire d'appeler une procédure paramétrée sans pour autant avoir
de valeur à lui affecter mais on souhaiterait que ce soit elle qui nous renvoie des valeurs
(exemple typique d'une procédure de saisie de valeurs par l'utilisateur) ou alors on désire que
la procédure puisse modifier la valeur de la variable passée en paramètre. Les syntaxes
précédentes ne conviennent pas à ce cas spécial. Lors de la déclaration de variable au sein de
la procédure paramétrée, la syntaxe Var (placée devant l'identificateur de la variable )
permet de déclarer des paramètres formels dont la valeur à l'intérieur de la procédure ira
remplacer la valeur, dans le programme principal, de la variable passée en paramètre. Et
lorsque Var n'est pas là, les paramètres formels doivent impérativement avoir une valeur lors
de l'appel de la procédure.
Pour expliquer autrement, si Var n'est pas là, la variable qu'on envoie en paramètre à la
procédure doit absolument déjà avoir une valeur (valeur nulle acceptée). De plus, sans Var, la
variable (à l'intérieur de la procédure) qui contient la valeur de la variable passée en
paramètre, même si elle change de valeur n'aura aucun effet sur la valeur de la variable (du
programme principal) passée en paramètre. C'est à dire que la variable de la procédure
n'existe qu'à l'intérieur de cette dernière et ne peut absolument pas affecter en quoi que ce soit
la valeur initiale qui fut envoyée à la procédure : cette valeur initiale reste la même avant et
après l'appel de la procédure. Car en effet, la variable de la procédure est dynamique : elle est
créée lorsque la procédure est appelée et elle est détruite lorsque la procédure est finie, et ce,
sans retour d'information vers le programme principal. La procédure paramétrée sans Var
évolue sans aucune interaction avec le programme principal (même si elle est capable
d'appeler elle-même d'autres procédures et fonctions).
Par contre, si Var est là, la valeur de la variable globale passée en paramètre à la
procédure va pouvoir changer (elle pourra donc ne rien contenir à l'origine). Si au cours de la
procédure la valeur est changée (lors d'un calcul, d'une saisie de l'utilisateur...), alors la
nouvelle valeur de la variable dans la procédure, une fois la procédure terminée, ira se placer
dans la variable globale (du programme principal) qui avait été passée en paramètre à la
procédure.
Donc, si on veut passer une variable en paramètre dont la valeur dans le programme
principal ne doit pas être modifiée (même si elle change dans la procédure), on n'utilise pas le
Var. Et dans le cas contraire, si on veut de la valeur de la variable globale placée en
paramètre change grâce à la procédure (saisie, calcul...), on colle un Var.
Program Exemple9c ;
Uses Crt ;
Procedure Saisie ( var nom : String ) ;
Begin
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
End ;
Procedure Affichage ( info : String ) ;
Begin
WriteLn('Voici votre nom : ', info) ;
End ;
Var chaine : String ;
BEGIN
ClrScr ;
Saisie(chaine) ;
Affichage(chaine) ;
END.
Ce programme exemple9c illustre l'utilisation de la syntaxe Var. En effet, le programme
principal appelle pour commencer une procédure paramétrée Saisie et lui affecte la valeur de
la variable chaine (c'est-à-dire rien du tout puisque qu'avant on n'a rien mis dedans, même pas
une chaîne vide). Au sein de la procédure paramétrée, cette variable porte un autre nom : nom,
et comme au début du programme cette variable n'a aucune valeur, on offre à la procédure la
possibilité de modifier le contenu de la variable qu'on lui envoie, c'est-à-dire ici d'y mettre le
nom de l'utilisateur. Pour cela, on utilise la syntaxe Var. Lorsque cette procédure Saisie est
terminée, la variable chaine du programme principal prend la valeur de la variable nom de la
procédure. Ensuite, on envoie à la procédure Affichage la valeur de la variable chaine (c'estdire ce que contenait la variable nom, variable qui fut détruite lorsque la procédure Saisie se
termina). Comme cette dernière procédure n'a pas pour objet de modifier la valeur de cette
variable, on n'utilise pas le mot clé Var, ainsi, la valeur de la variable chaine ne pourra pas
être modifiée par la procédure. Par contre, même sans Var, la valeur de la variable info
pourrait varier au sein de la procédure si on le voulait mais cela n'aurait aucune influence sur
la variable globale chaine. Comme cette variable info n'est définie que dans la procédure, elle
n'existera plus quand la procédure sera terminée.
Il faut savoir qu'une procédure paramétrée peut accepter, si on le désire, plusieurs
variables d'un même type et aussi plusieurs variables de types différents. Ainsi, certaines
pourront êtres associées au Var, et d'autres pas. Si l'on déclare, dans une procédure
paramétrée, plusieurs variables de même type dont les valeurs de certaines devront remplacer
celles initiales, mais d'autres non ; il faudra déclarer séparément (séparation par une virgule ;)
les variables déclarées avec Var et les autres sans Var. Si on déclare plusieurs variables de
types différents et qu'on veut que leurs changements de valeur affectent les variables globales,
alors on devra placer devant chaque déclaration de types différents un Var.
Syntaxes :
Procedure identifiant(Var var1, var2 : type1 ; var3 : type1) ;
Begin
...
End ;
Procedure identifiant (Var var1 : type1 ; Var var2 : type2) ;
Begin
...
End ;
CHAPITRE VIII : Fonctions
Quant aux fonctions, elles sont appelées à partir du programme principal, d'une
procédure ou d'une autre fonction. Le programme affecte des valeurs à leurs variables
(comme pour les procédures paramétrées, il faudra faire attention à l'ordre d'affectation des
variables). Ces fonctions, après lancement, sont affectées elles-mêmes d'une valeur
intrinsèque issue de leur fonctionnement interne. Il faut déclarer une fonction en lui donnant
tout d'abord un identifiant (c'est-à-dire un nom d'appel), en déclarant les variables locales dont
elle aura besoin et enfin, il faudra préciser le type correspondant à la valeur que prendra en
elle-même la fonction (string, real, etc.). Attention, on ne peut pas affecter un type
complexe (array, record) à une fonction : seuls les types simples sont acceptés (voir
chapitre 20 sur les types simples et complexes). De plus, comme le montre les syntaxes
suivantes, on peut fabriquer une fonction sans paramètre (ex: random). Il ne faut surtout pas
oublier, en fin (ou cours) de fonction, de donner une valeur à la fonction c'est-à-dire d'affecter
le contenu d'une variable ou le résultat d'une opération (ou autre...) à l'identifiant de la
fonction (son nom) comme le montrent les syntaxes suivantes.
Syntaxes :
Function nom de fonction (variable : type ) : type ;
Var déclaration de variables locales ;
Begin
...
commandes
...
nom de fonction := une valeur ;
End ;
Function nom de fonction : type ;
Var déclaration de variables locales ;
Begin
...
commandes
...
nom de fonction := une valeur ;
End ; >
Program exemple10 ;
Uses crt ;
Function exposant ( i , j : integer ) : integer ;
Var i2 , a : integer ;
Begin
i2 := 1 ;
For a := 1 To j Do i2 := i2 * i ;
exposant := i2 ;
End ;
Var resultat, x, n : integer ;
BEGIN
Write ('Entrez un nombre : ') ;
Readln (x) ;
Write('Entrez un exposant : ') ;
Readln (n) ;
resultat := exposant ( x , n ) ;
Writeln ( resultat ) ;
Readln ;
END.
FONCTIONS ET PROCEDURES
--------------------------------------------FONCTION:
Une fonction est un module de programme qui réalise des traitements et renvoie une valeur.
Syntaxe:
----------function <ident> : type;
OU
function <ident> (parameters) : type;
Description:
---------------L'entête de fonction mentionne l'identificateur de fonction, la liste des paramètres formels (s'il
y a lieu), et le type renvoyé.
Les types valides pour les résultats sont ordinal, real, string, et pointeur
Une fonction est activée par l'évaluation d'un appel de fonction dans une expression.
L'en-tête de fonction est suivi de :
-une partie déclarative qui déclare des éléments locaux;
-un bloc d'instructions qui indique les instructions à exécuter suite à l'appel de fonction.
Le bloc d'instructions doit contenir au moins une instruction qui affecte une valeur à
l'identificateur de la fonction. Le résultat de la fonction est la dernière valeur qui a été affectée
à cet identificateur.
A la place d'une partie déclarative et d'un bloc d'instructions, une déclaration de fonction peut
comporter une directive forward
Exemple:
-----------(* Déclaration de fonction *)
function UpCaseStr(S: string): string;
var
I: Integer;
begin
for I := 1 to Length(S) do
if (S[I] >= 'a') and (S[I] <= 'z') then
S[I]:=S[I]- 32;
UpCaseStr := S;
end;
PROCEDURE :
Une procédure est un morceau de programme qui réalise une action particulière. Cette action
est généralement basée sur les paramètres qui sont fournis en entrée.
Syntaxe:
-----------procedure <identificateur>;
OU
procedure < identificateur> ( parametres );
Description:
----------------L'entête de la procédure comporte l'identificateur de la procédure et la liste des paramètres
formels (s'il y en a).
La procédure est appelée au moyen d'une instruction de procédure.
L'entête de procedure est suivi de:
-une partie déclarative qui déclare les objets locaux à la procédure;
-un bloc d'instructions délimité par begin et end qui décrit les actions à exécuter lors de
l'appel.
A la place des parties déclaratives et d'instructions, la déclaration peut comporter une
directive forward.
Exemple:
-----------{ Declaration de procédure }
procedure WrStr(X, Y: integer; S: string);
var
SaveX, SaveY: Integer;
begin
SaveX := WhereX;
SaveY := WhereY;
Aller_a(X, Y);
Write(S);
Aller_a(SaveX, SaveY);
end;