Support de Cours Algorithmique

Catalogue
Chapitre 1 Concepts généraux······································································································································ 1

Chapitre 2 Concepts-et-instructions de-Base-de-l-Algorithmique··················································································4
Chapitre 3 Les structures algo de controle et itératives-······························································································ 11
Chapitre 4 Les sous programmes································································································································ 19
Chapitre 5 LES TABLEAUX·········································································································································28
Chapitre 6 Les_types_structures_et_les_enregistrements·························································································· 36
Chapitre 7 Problèmes de recherche et de tri··············································································································· 42
Chapitre 8 Les fichiers················································································································································· 56
Chapitre 9 Applications sur un langage algorithmique Pascal····················································································· 66
Chapitre 10 Les pointeurs············································································································································ 82
Chapitre 1 : Les concepts fondamentaux
1. Historique et définitions
L'algorithmique a été Découvert par le mathématicien Al Kwarizmi (780-850), auteur d'un ouvrage
décrivant des méthodes de calculs algébriques (ainsi que d'un autre introduisant les chiffres Arabes et
le zéro). Son nom donna au moyen-âge le nom "algorisme" qui devint algorithme avec lady Ada
Lovelace, fille de lord Byron et assistante de Charles Babbage (1792-1871).
Définitions
L'algorithme est le résultat d'une démarche logique de résolution d'un problème pour la mise en
œuvre pratique sur ordinateur et afin d'obtenir des résultats concrets il faut passer par l'intermédiaire
d'un langage de propagation.
Un algorithme décrit une succession d'opérations qui, si elles sont fidèlement exécutées, produiront le
résultat désiré.
Un algorithme est une suite d'actions que devra effectuer un automate pour arriver en un temps fini, à
un résultat déterminé à partir d'une situation donnée. La suite d'opérations sera composée d'actions
élémentaires appelées instructions.
2. Objectifs
Aujourd'hui, il est indispensable pour tout ingénieur d'avoir eu un premier contact avec l'informatique.
L'intérêt d'une telle Unité de Valeur est de permettre aux futurs ingénieurs de mieux comprendre la
façon de réaliser des programmes, afin de pouvoir plus facilement utiliser l'ordinateur pour résoudre
des problèmes scientifiques, techniques ou organisationnels.
L'objectif de cet enseignement est d'une part de familiariser l'étudiant à l'utilisation de l'ordinateur et
d'autre part, de commencer l'apprentissage de l'algorithmique et de la programmation.
L'étudiant devra ainsi apprendre à trouver la solution d'un problème à l'aide d'une forme algorithmique
et savoir programmer cette solution algorithmique en un langage structuré.
Il s'agit d'un premier contact avec la programmation. L'étudiant apprend à réaliser des algorithmes puis
à les transformer en petits programmes réels.
3. Ordinateurs et programmes
Un programme, c’est un algorithme codé dans un langage compréhensible par ordinateur à l’aide d’un
compilateur.
L'informatique intervient aujourd'hui dans de nombreux secteurs d'activité. Parmi les applications
courantes on peut citer la bureautique, la gestion, le calcul scientifique, la communication, l'accès à
des ressources d'information (au travers d'internet en particulier), le multimédia, les jeux etc.
Ces applications ne sont possibles que grâce à un ordinateur. Cependant, l'ordinateur seul ne suffit pas.
Pour chaque application, il est nécessaire de lui fournir un logiciel (ou programme) adapté.
La programmation est donc une activité fondamentale en informatique. La programmation peut être
vue comme l'art de déterminer un algorithme (une démarche) pour résoudre un problème et d'exprimer
cet algorithme au moyen d'un langage de programmation.
4. Données et résultats d’un programme
Ce cours présente plusieurs structures de données. Une structure de données est un moyen de stocker
et organiser des données pour faciliter l’accès à ces données et leur modification. Il n’y a aucune
structure de données qui réponde à tous les besoins, de sorte qu’il importe de connaître les forces et
limitations de plusieurs de ces structures.
A partir de l'énoncé du problème, nous recherchons la solution par une démarche en 2 phases.
 On doit comprendre comment le résoudre manuellement,
 Définir ce qu'on a besoin comme données, quelles est la démarche à suivre (formules de calcul)
pour arriver aux résultats.
Les résultats représentent ici la solution au problème à résoudre dont les étapes de résolution ne
sont pas uniques.
5. Fonctionnement de l’ordinateur
En première approche, un ordinateur est constitué des éléments suivants :
- une unité centrale (contenant le processeur),
- une mémoire centrale,
- des organes périphériques permettant :
✓ la communication avec l'utilisateur : écran, clavier, souris, imprimante ...
✓ le stockage : disque dur, lecteurs de cd, de dvd, de bandes, ...
- des composants matériels divers : cartes son, vidéo, cartes d'acquisition ...
Un ordinateur ne peut pas fonctionner seul. Il doit être doté d'un système d'exploitation. (Ex :
windows, unix, mac os, linux, ...)
Le système d'exploitation est le programme de base d'un ordinateur.
Ce programme permet notamment :
- la gestion de la mémoire,
- la gestion des périphériques,
- l'exécution des programmes,
- la gestion des fichiers.
Les programmes (ou logiciels) d'application s'exécutent généralement en s'appuyant sur le
système d'exploitation.
6. Comment parler à l’ordinateur
L’exécution des programmes permettent de parler à l’ordinateur en outre les périphériques d’entrées
usuelles. Un ordinateur est un puissant calculateur dont la mise sur pied des programmes améliore la
qualité des résultats recherchés. Il y a deux étapes importantes pour communiquer avec un ordinateur :
Ecriture du programme
Après avoir déterminé l'algorithme, il faut écrire le programme source en respectant une syntaxe très
précise, définie par des règles de grammaire dépendant du langage utilisé. Le programme source peut
être écrit à l'aide d'un éditeur de texte tel que le bloc-notes de windows. On préférera cependant utiliser
un EDI ou « environnement de développement intégré ». Un EDI facilite l'écriture, la mise au point et
l'exécution des programmes.
Compilation
Un programme appelé « compilateur » verifie que le programme source respecte la grammaire du
langage et le traduit en langage objet, plus proche de la machine. Un second programme appelé «
éditeur de liens » rend ensuite le programme exécutable par la machine.
7. Pratique de l’algorithmique
L'algorithme est un moyen pour le programmeur de présenter son approche du problème à d'autres
personnes. En effet, un algorithme est l'énoncé dans un langage bien défini d'une suite d'opérations
permettant de répondre au problème. Un algorithme doit donc être :
− lisible: l'algorithme doit être compréhensible même par un non informaticien de haut niveau:
l'algorithme doit pouvoir être traduit en n'importe quel langage de programmation, il ne doit donc pas
faire appel à des notions techniques relatives à un programme particulier ou bien à un système
d'exploitation donné.
− précis: chaque élément de l'algorithme ne doit pas porter à confusion, il est donc important de lever
toute ambiguïté.
− concis: un algorithme ne doit pas dépasser une page. Si c'est le cas, il faut décomposer le problème
en plusieurs sous problèmes.
− structuré: un algorithme doit être composé de différentes parties facilement identifiables.
En d’autres termes, un algorithme :
- ne doit pas être ambigu
- doit être une combinaison d'opérations élémentaires
- doit fournir un résultat en un nombre fini d'opérations, quelles que soient les
données d'entrée.
Pour mieux cerner les contours d’un algorithme, il faudrait suivre cette démarche méthodologique :
- Définir clairement le problème
- Etablir l'algorithme au moyen d'une analyse descendante
- Déterminer une séquence d'instructions de niveau supérieur (sans entrer dans les détails)
- Ecrire chaque instruction de niveau supérieur à l'aide d'instructions élémentaires
- Ecrire le programme et la documentation
- Tester
- Revenir sur les étapes précédentes si nécessaire
8. Les problèmes fondamentaux en algorithme
Un algorithme se compose de deux parties étroitement liées :
− les données (i.e. les matériaux sur lesquels on agit).
− le processus de calcul, composé d’une suite d’instructions.
La complexité d’un algorithme est fonction de cet algorithme et des paramètres fournis à celui-ci.
Souvent, un calcul exact de la complexité s’avère très difficile, voire impossible.
On s’oriente en général vers les calculs suivants :
• La complexité en pire cas consiste à calculer la quantité égale au maximum des complexités pour
toutes les données de taille N.
• La complexité en moyenne consiste à associer aux données X de taille N une probabilité, et à
considérer la moyenne de la complexité de l’algorithme sur toutes ces données.
Chacune de ces deux complexités est importante. La complexité en pire cas est rassurante. Elle nous
affirme que jamais l’algorithme ne se comportera de façon imprévue. La complexité en moyenne nous
dit que certains algorithmes, même s’ils s’avèrent peu intéressants sur certaines données, peuvent se
comporter de façon tout à fait correcte en général.
En bref, on peut résumer les complexités de l’algorithme par :
- Durée du temps d’exécution : se termine en un temps fini
- Ressources matérielles allouées à son exécution numérique :
- Résultats fiables : solution proposée correcte ou pas
- Complétude : donnera-t-il toujours des propositions de solutions.
Chapitre 2 – Concepts et instructions de base de l'algorithmique
Page 1/7
Chapitre 2 – CONCEPTS ET INSTRUCTIONS DE BASE DE
L'ALGORITHMIQUE
1. Les types de données de base
En algorithmique, on distingue cinq types de base:
- caractère (lettre, chiffre, ponctuation, espace, retour chariot,… et plus généralement toutes les
touches que l'on peut trouver sur une machine à écrire)
- chaîne de caractères (suite de 0 ou plusieurs caractères)
- entier (les nombres entiers positifs ou négatifs)
- réel (les nombres réels positifs ou négatifs)
- booléen (les variables booléennes n’ont que deux valeurs possibles: soit VRAI, soit FAUX)
A partir de ces types de base, on peut définir des types plus complexes appelés types composés.
2. Notions de variable et de constante
2-1. Variable
Les variables sont des données manipulées par le programme lors de son exécution. Elles
correspondent à des emplacements situés dans la mémoire vive de l’ordinateur et permettant de
stocker des valeurs.
Une variable est caractérisée par

- l’endroit où elle se trouve en mémoire : c’est son adresse,
- la nature de l’information (nombre, caractère, …) qu'elle contient: c’est son type,
- son contenu : c’est sa valeur.
La valeur d’une variable peut être modifiée durant l'exécution du programme.
2-2. Constante
Une constante est, comme une variable, un emplacement de la mémoire mais sa valeur ne peut pas
changer au cours de l'exécution du programme.
2-3. Déclaration des variables et des constantes
Toute variable ou constante doit être déclarée avant sa première utilisation.
2-3-1. Déclaration d'une variable
La déclaration d’une variable consiste à la réservation d’un emplacement mémoire, auquel on

donne un nom unique appelé identificateur et par lequel on peut accéder à sa valeur.
La syntaxe de déclaration d’une variable est:
identificateur : type
M. MBADJOUN / JFN-IT
Page 2/7
Exemple
a : entier
permet de réserver un emplacement mémoire pour le stockage d’un entier qui sera nommé a
dans la suite du programme.
On peut déclarer en même temps plusieurs variables de même type en séparant les identificateurs
par des virgules.
Exemple
x, y, z : entier
2-3-2. Déclaration d'une constante
La déclaration d’une constante est toujours associée à son initialisation (première valeur).
La syntaxe de déclaration d’une constante est:
identificateur : type = valeur
Exemple
MAX : entier = 32767
3. Structure générale d’un algorithme
Programme nom du programme

Type
Définition de types
Constante
Déclaration de constantes
Variable
Déclaration de variables
Définition de sous programmes
Début
instructions
Fin
Un algorithme commence par le mot Programme suivi de son identificateur (le nom du
programme).
Ensuite viennent la définition de types annoncée par le mot Type, la déclaration de constantes,
annoncée par le mot Constante puis celle de variables, annoncée par le mot Variable et la
définition de procédures et de fonctions.
Le corps du programme commence par Début et se termine par Fin.
On peut insérer des commentaires, soit entre les balises /* */, soit après // jusqu'à la fin de la ligne.
Remarque:
Les types de base font partie du langage et n'ont pas à être définis par le programmeur.
Page 3/7
4. Les opérations de l’algorithmique
opérateur ou mot clé

Type Exemples de valeurs opérations possibles
correspondant
addition, soustraction,
+, -, *, /,
réel -15.69 , 0.36 multiplication, division,
    = = 
comparaison
addition, soustraction,
+, -, *, div, mod,
entier -10 , 0 , 3 , 689 multiplication, division, modulo,
, , , , = =, 
comparaison
successeur, prédécesseur, ordre, suc, pred, ord, car,

caractère 'B' , 'h' , '£' , '?'
caractère, comparaison , , , , = =, 
"Bonjour" , "93000",
longueur, concaténation, longueur , + ,
chaîne "toto@caramail.com"
comparaison , , , , = =, 
booléen VRAI , FAUX négation, conjonction , disjonction NON , ET , OU
Remarques
- Pour les entiers, la division est notée div. Elle est nommée division entière et ne donne que le
chiffre avant la virgule du résultat (elle renvoie un entier).
Les entiers supportent une opération supplémentaire appelée modulo, notée mod et qui renvoie le
reste de la division entière.
Exemple:
7 div 2 donne 3
7 mod 2 donne 1
- Une valeur de type caractère doit être ente apostrophes (sinon le compilateur pourrait la confondre
avec un nom de variable).
- Une valeur de type chaîne doit être entre guillemets (sinon le compilateur pourrait la confondre
avec un nom de variable).
- Les caractères sont comparés selon l’ordre du code ASCII. C’est ainsi qu’on peut comparer tous
les caractères entre eux. Par exemple le caractère 'Z' (majuscule), de code ASCII 90 est inférieure
au caractère 'a' (minuscule) de code ASCII 97.
Soit la variable c de type caractère:
succ(c) permet d’obtenir le caractère qui suit le caractère c selon le code ASCII
pred(c) permet d’obtenir le caractère qui précède le caractère c selon le code ASCII
ord(c) permet d’obtenir code ASCII du caractère c.
car(n) permet d’obtenir le caractère correspondant au code ASCII n.
Par exemple :
ord(‘A’) vaut 65
succ(‘A’) vaut ‘B’
pred(‘A’) vaut @
Page 4/7
car(65) donne ‘A’
- Pour le type chaîne, L’opérateur + sert à concaténer des chaînes de caractère, ce qui signifie
transformer plusieurs chaînes en une seule en les ajoutant les unes à la suite des autres.
Exemples :
 Bonjour  +  à tous  donne  Bonjour à tous 
longueur(Bonjour) donne le nombre de caractères de la chaîne Bonjour, c’est à dire 7.
- Pour le type booléen, les deux seules valeurs possibles sont Vrai et FAUX. Les opérateurs de base
ET, OU, NON sont définies par la table de vérité suivante (étant données deux variables A et B de
type booléen) :
A B A ET B A OU B NON A
VRAI VRAI VRAI VRAI FAUX
VRAI FAUX FAUX VRAI FAUX
FAUX VRAI FAUX VRAI VRAI
FAUX FAUX FAUX FAUX VRAI
5. Notion d'expression
Une expression est:

- soit une variable ou une constante,
- soit une valeur (par exemple : "bonjour", 45),
- soit une combinaison de variables, de constantes, de valeurs et d'opérateurs (par exemple : 2 * r *
3.14)
Elle est évaluée durant l’exécution du programme, et possède une valeur (son évaluation) et un
type.
Par exemple, supposons que rayon soit une variable de valeur 5. Alors l'expression 2 * rayon * 3.14
vaut 31.4
6. Les expressions conditionnelles
Une expression conditionnelle (ou expression logique ou expression booléenne ou condition) est
une expression dont la valeur est soit VRAI soit FAUX. On peut donc affecter une expression
conditionnelle à une variable booléenne. Il existe plusieurs types d’expressions conditionnelles.
6-1. Les conditions simples
Une condition simple est une comparaison de deux expressions de même type.
Exemples
a<0
op = =‘s’
(a + b - 3) * c = = (5 * y –2) / 3
Pour les comparaisons de caractères, on utilise l'ordre ASCII, qui respecte l’ordre alphabétique. Une
lettre placée avant une autre dans l'ordre alphabétique sera inférieure à l'autre. Par exemple: ‘a’ est
Page 5/7
inférieur à ‘b’, mais ‘s’ est supérieur à ‘m’.
6-2. Les conditions complexes
Les conditions peuvent aussi être complexes, c'est à dire formées de plusieurs conditions simples ou
variables booléennes reliées entre elles par les opérateurs logiques ET, OU, NON.
Exemples
(a < 0) ET (b < 0)
( (a +3 = = b) ET (c < 0) ) OU ( (a = = c *2) ET (b c) )
Une condition composée de deux conditions simples reliées par ET est vraie si les deux conditions
sont vraies.
Exemple: (a < 0 ) ET (b < 0) est vraie si a < 0 est vraie et si b < 0 est vraie
Une condition composée de deux conditions simples séparées par OU est vraie si au moins l'une des
conditions simples est vraie.
Exemple: (a <0) OU (b < 0) est vraie si a < 0 ou si b < 0 ou si a et b sont négatifs.
Une condition précédée par NON est vraie si la condition simple est fausse et inversement.
Exemple: NON (a < 0) est vraie si a >=0
L'usage des parenthèses permet de régler d'éventuels problèmes de priorité des opérateurs logiques.
7. Les instructions de base
Les instructions élémentaires les plus courantes sont :

- l'affectation: le fait de donner une valeur à une variable
- la lecture au clavier
- l'écriture à l'écran
7-1. L’affectation
L’affectation consiste à mettre une valeur dans une variable (ce qui revient à changer le contenu de
cette variable). La nouvelle valeur est évaluée à partir d'une expression.
En algorithmique, pour représenter l’opération d’affectation, on va utiliser le symbole =
Exemples
x=5
x=y
x=5+8
x=5+y
L'instruction d’affectation est formée de deux parties :

- A gauche du symbole = on trouve toujours le nom d’une variable destinée à recevoir une valeur.
- A droite, on trouve l’expression qui va donner la valeur qu’on veut affecter à la variable en
question.
L’instruction d’affectation agit en deux temps :
Page 6/7
- Tout d’abord elle détermine la valeur de l’expression située à droite du symbole =
- puis elle range le résultat dans la variable située à gauche.
Remarques
- On ne peut affecter de valeur qu’à une variable. Il est impossible d’affecter une valeur à une
constante ou à une expression. Par exemple, l’instruction a + 5 = b n’a pas de sens.
- Il est possible de retrouver la même variable à droite et à gauche de l’expression. Par exemple,
l’instruction a = a + 3 a un sens. Cela signifie que l’on évalue a + 3 avec l'ancienne valeur de a et
qu’on range le résultat dans a. La valeur de a sera donc augmentée de 3 par cette opération.
7-2. La lecture
L’instruction de lecture permet au programme de lire des données entrées au clavier par l'utilisateur.
Cette instruction affecte les valeurs entrées au clavier à des variables du programme..
Syntaxe
Lire(variable1 , variable2, …, variableN)
Exemples
Lire(x)
Cette instruction lit la valeur entrée au clavier et l'affecte à la variable x
Lire(x, y)
Cette instruction lit la première valeur entrée au clavier et l'affecte à x, puis lit la deuxième valeur
et l'affecte à y
7-3. L'écriture
L'instruction d'écriture permet d'afficher des expressons à l'écran.
Syntaxe
Ecrire(expression1, expression2, ..., expressionN)
Exemples
Ecrire(ch)
Cette instruction permet d'afficher la valeur de la variable ch à l'écran
Si ch est une chaîne qui vaut "toto", cette instruction affichera toto à l'écran
Ecrire("Bonjour!")
Celle-ci permet d'afficher la chaîne Bonjour! à l'écran
Ecrire(a, b)
Si a vaut 5 et b vaut 10, on obtient alors à l'écran:
5 10
Page 7/7
On peut mélanger l'affichage de valeurs littérales et de variables. Cela est particulièrement utile si
on veut voir apparaître un libellé (texte accompagnant la saisie des données ou l'édition des
résultats, permettant de guider l'utilisateur).
Exemple
Ecrire("Voici les résultats : x = ", x, " et y = ", y)

Nous aurons à l’écran (en supposant que les valeurs de x et y sont respectivement 5 et 10) :
Voici les résultats : x = 5 et y = 10
8. Exemple d'algorithme
Algorithme pour échanger le contenu de deux variables saisies au clavier par l'utilisateur.
Programme Echange
Variable
x , y : entier
tmp : entier
Début
Ecrire("Donner la valeur de l'entier x:")
Lire(x)
Ecrire("Donner la valeur de l'entier y:")

Lire(y)
Ecrire("Avant échange: x vaut ",x, "et y vaut ",y)
tmp = x
x=y
y = tmp
Ecrire("Après échange: x vaut ",x, "et y vaut ",y)

Fin
Chapitre 3 : LES STRUCTURES ALGORITHMIQUES DE CONTROLE ET ITERATIVES
CHAPITRE 3: LES STRUCTURES ALGORITHMIQUES DE CONTROLE ET

ITERATIVES
LES STRUCTURES DE CONTROLE CONDITIONNELLES :
1- Introduction :
Les structures de contrôle conditionnelles sont utilisées pour exécuter un traitement
parmi d’autres suivant la valeur de la condition . On distingue trois types de structures de
contrôle conditionnelles : complète, généralisée et à choix
2- La structure conditionnelle
simple a. Activité :
Qu'est ce qu'une condition ?
Constatation
Une condition est une expression booléenne qui peut prendre la valeur vrai ou faux.
b. Syntaxe :
Syntaxe en algorithmique Syntaxe en Pascal
If
conditions then
Si conditions alors Begin
Traitement1 Traitement 1.1;
Traitement 1.2;
Sinon End
Traitement 2 Else
Begin
Fin si Traitement 2;
End;
Si la condition est vraie, le programme exécute le premier traitement, sinon, il saute
pour exécuter le deuxième traitement.
c. Définition :
La structure conditionnelle simple est une structure algorithmique qui exécute un
traitement parmi deux et ce suivant le résultat de l’évaluation de la condition.
Remarques :
La condition peut être composée.
Si le traitement2 est vide, on parlera de structure conditionnelle simple réduite qui
aura la syntaxe suivante :
MBADJOUN/JFN-IT 1
3- La structure conditionnelle généralisée

a. Activité :
Qu'est ce qu'une condition généralisée ?
Constatation
La structure conditionnelle généralisée est utilisée dans le cas où la solution d'un
traitement conditionnelle fait appel à plus que deux situations.
b. Syntaxe :
IF
condition_1 THEN
Begin
Traitement_1
SI condition_1 ALORS
End ;
Traitement_1 ELSE IF condition_2 THEN
SINON SI condition_2 ALORS Begin
Traitement_2 Traitement_2
SINON SI End ;
…. ELSE IF
SINON SI condition_n-1 ALORS ………
ELSE IF condition_n-1 THEN
Traitement_n-1
Begin
SINON Traitement_n-1
Traitement_n End ;
FIN SI ELSE
Begin
Traitement_n
End ;
L’exécution d’une telle structure commence par l’évaluation de la condition_1, deux
états peuvent se reproduire
Si condition_1 est vérifiée alors le traitement_1 qui sera exécuté
Si condition_1 n’est pas vérifiée alors il y a un passage automatique pour vérifier la
condition suivante et ainsi de suite pour chacune des conditions.
Si aucune condition n’est vérifiée alors le traitement_n qui sera exécuté.
c. Définition :
La structure conditionnelle généralisée est une structure algorithmique qui fait appel
à plus que deux traitements. L’exécution d’un traitement donné dépend de la condition à
vérifier.
MBADJOUN/ JFN-IT 2
4- La structure à choix
a. Activité :
Qu'est ce qu'une condition à choix ?
Constatation
La structure conditionnelle à choix permet de faire un choix parmi plusieurs choix
proposés. Le sélecteur permet de définir le choix du traitement à effecteur.
b. Syntaxe :
La structure conditionnelle à choix aura la syntaxe suivante :
Selon sélecteur faire CASE sélecteur OF
Valeur_1 : traitement_1 Valeur_1 : traitement_1
Valeur_2 : traitement_2 Valeur_2 : traitement_2
…. ….
…. ….
Valeur_n-1 : traitement_n-1 Valeur_n-1 : traitement_n-1
Sinon ELSE
traitement_n traitement_n
Fin selon End ;
c. Définition :
La structure conditionnelle à choix est une structure algorithmique utilisée dans des
structures à plusieurs traitements selon des conditions. L’exécution d’un traitement
entraîne automatiquement la non exécution des autres. Le choix d’un traitement se fait
suivant la valeur d’un sélecteur.
Remarques
Le sélecteur doit être de type scalaire discret et non réel.
Comme dans le cas des autres structures conditionnelles, chaque traitement peut
comporter une ou plusieurs instructions.
Valeur_i peut être un ensemble de valeurs qui seront séparées par des virgules ou un
intervalle de valeurs [Vi.. Vf]
Si la valeur du sélecteur est différente des valeurs proposées alors c'est le traitement
qui suit la clause sinon qui sera exécuté.
La clause sinon et son traitement sont facultatifs dans la structure.
MBADJOUN/JFN-IT 3
II. LES STRUCTURES DE CONTROLE ITERATIVES

1- La structure itérative complète
a. Introduction
Activité 1 :
1. Exécuter le fichier "rep.exe" se trouvant dans "C:\TPW\"
Cas 1 : taper la valeur 4
2. Quel est la tache réaliser par le programme "rep.exe "
3. L’affichage du message « Bonjour » est il un traitement répétitif ?
4. Quelle est la structure de traitement répétitif adéquate pour ce type de traitement ?
b. Syntaxe
La structure POUR…FAIRE est représentée comme suit :

Initialisation (s) FOR Cp :=Vi To Vf do
POUR Cp de Vi à Vf FAIRE Begin
instruction 1 instruction 1 ;
… …
instruction n instruction n;
FIN POUR End ;
Activité 2 :
1. Ouvrir le fichier "Rep.pas" se trouvant dans "C:\TPW\"
2. En se basant sur le code source du fichier "Rep.pas" et on vos aidons des exécutions
du fichier "Rep.exe" déterminer le principe de fonctionnent de la structure répétitive
complète POUR…FAIRE
Constatation
La structure répétitive complète POUR…FAIRE réalise les actions suivantes :
Action 1 : initialiser le compteur de la boucle Cp à la borne Vi

Action 2 : incrémenter de un le compteur à chaque répétition
Action 3 : exécuter les instructions du traitement répétitif
Action 4 : vérifier que la valeur du compteur ne dépasse pas la valeur finale Vf
Remarques
1. Le compteur de la boucle est de type scalaire.
2. Le pas est par défaut de 1.
3. Si le pas est de -1, la syntaxe en pascal devient
FOR Cp := Vi DOWNTO Vf do
4. Le changement de la valeur du compteur est automatique, le pas est de 1 ou de -1
MBADJOUN/JFN-IT 4
c. Applications
Application 1
Ecrire un algorithme d’un programme qui chercher puis afficher le nombre de lettres
NL, le nombre de chiffres NC et le nombre de symbole NS dans une chaîne de
caractères CH saisie au clavier.
Application 2
Ecrire une analyse d’un programme qui permet d’effectuer la multiplication de deux
entiers positifs P et Q données en utilisant uniquement l’addition entière.
Application 3
Ecrire un algorithme d’un programme qui permet de remplir un tableau T par N

chiffres et d’afficher en suite tout les éléments de T.
2- Les structures de contrôle itératives à condition d’arrêt

i. La structure REPETER…JUSQU'A
a. Introduction
Activité 1 :
1. Exécuter le fichier " StrRep.exe" se trouvant dans "C:\TPW\"
Cas 1 : taper les valeurs -1, 22, 15
Cas 2 : 25,8
Cas 3 :12
2. Quel est la tâche réalisée par le programme " StrRep.exe "
3. Le traitement réalisé par le programme " StrRep.exe " est il un traitement répétitif ?
4. Quelle est la structure de traitement adéquate pour ce type de traitement ?
Réponse :
2. Le programme "StrRep.exe " demande à l’utilisateur de donner une valeur compris
entre 0 et 20 si l’utilisateur donne une valeur invalide le programme répète sa
demande jusqu'à à ce que l’utilisateur donne une valeur valide.
3. La saisie des valeurs données par l’utilisateur est un traitement répétitif dont le
nombre de répétition n’est pas connu à l’avance il s’agit d’un traitement répétitif à
condition d’arrêt?
4. Le traitement répétitif doit être exécuté au moins une seule fois en plus le nombre de
répétition n’est pas connu à l’avance on doit donc utiliser la structure répétitive à
condition d’arrêt REPETER…JUSQU'A
b. Définition
La structure REPETER…JUSQU'A... est utilisée quand il s'agit de répéter un traitement
un nombre de fois Inconnu à l’avance et qu’on est sûr que le traitement itératif
s'exécutera au moins une fois.
MBADJOUN/JFN-IT 5
c. Syntaxe
Activité 2 :
En se basant sur le code source du fichier " StrRep.pas" déterminer la syntaxe de la
structure répétitive à condition d’arrêt REPETER…JUSQU'A
La structure REPETER…JUSQU'A est représentée comme suit :

Initialisation (s)
REPETER REPEAT
… …
JUSQU'A (condition d’arrêt) UNTIL (condition d’arrêt);
Remarques :
1. La condition d'arrêt est considérée comme une condition de sortie de da la boucle.
2. La condition d'arrêt de la boucle peut être simple ou composée.
3. les caractéristiques de la boucle REPETER…JUSQU'A en font une structure adaptée
pour le contrôle de la saisie des données. On répète la saisie jusqu'à à ce que les
contraintes spécifiées dans l’énoncé du problème soient respectées.
d. Applications
Application 1 : Stocker une série d’éléments dans un vecteur de 100 éléments au maximum
compris entre 1 et 50. Le zéro est admis comme fin de saisie. Rechercher ensuite et afficher le
minimum et le maximum des nombres entrés
Application 2 : Ecrire un programme permettant de :
Saisir les éléments d’un tableau T de N entiers formés chacun de trois chiffres 5 ≤ N ≤ 20
Afficher les éléments du tableau T dont la permutation des chiffres donne la valeur du
premier élément du tableau T
ii. La structure TANTQUE…FAIRE

a. Introduction
1. Exécuter le fichier "While.exe" se trouvant dans "C:\TPW\"
Cas 1 : taper les valeurs 4, 8, 2, 13, 10, 7
Cas 2 : 4, 8, 0
Cas 3 : 0
2. Quel est la tâche réaliser par le programme "while.exe "
3. La sauvegarde des valeurs données par l’utilisateur est il un traitement répétitif ?
4. Quelle est la structure de traitement répétitif adéquate pour ce type de traitement ?
MBADJOUN/JFN-IT 6
Réponse :
2. Le programme "while.exe " sauvegarde puis affiche les 5 premiers valeurs tapées par
l’utilisateur (cas 1) ou les N valeurs tapées avec N <= 5 le sauvegarde s’arrêt lorsque
l’utilisateur tape un zéro (cas 2), Si dès le départ l’utilisateur tape un zéro le
traitement répétitif n’aura pas lieu et l’exécution passe directement à l’affichage du
résultat (cas 3).
3. La sauvegarde des valeurs données par l’utilisateur est un traitement répétitif à
condition d’arrêt
4. Le traitement répétitif peut ne pas avoir lieu (cas 3) lorsque l’utilisateur tape un zéro
dès le départ on ne peut pas alors utiliser la structure répétitive à condition d’arrêt
REPETER…JUSQU'A il faut utiliser la structure répétitive à condition d’arrêt
TANTQUE…FAIRE
b. Définition
La structure TANT QUE...FAIRE... est utilisée quand il s'agit de répéter un traitement un
nombre de fois inconnu à l’avance et que le traitement itératif peut ne pas s'exécuter.
Activité :
1. Ouvrir le fichier "While.pas" se trouvant dans "C:\TPW\"
2. En se basant sur le code source du fichier "While.pas" et on vos aidons des exécution
du fichier "While.exe" déterminer le principe de fonctionnent de la structure
répétitive à condition d’arrêt TANTQUE…FAIRE
Constatation
Le principe de fonctionnement de cette boucle est simple : Quand le programme atteint la

ligne du TANTQUE. Il examine alors la valeur de la condition. SI cette valeur est VRAIE, Le
programme exécute les instructions qui suivent, jusqu'à ce qu'il rencontre la ligne FIN
TANTQUE.
Il retourne ensuite sur la ligne du TANTQUE, procède au même examen, et ainsi de suite.
Le traitement ne s'arrête que lorsque la condition prend la valeur FAUSSE.
c. Syntaxe
La structure TANTQUE…FAIRE est représentée comme suit :

Initialisation (s) WHILE condition(s) DO
TANTQUE condition(s) FAIRE Begin
… …
Fin TANTQUE End ;
MBADJOUN/JFN-IT 7
Remarques :
1. La condition d'arrêt est considérée comme une condition d'entrée dans la boucle car,
une fois qu'elle n'est pas vérifiée, on quitte la boucle sinon on itère encore jusqu'à sa
non vérification.
2. La condition d'entrée dans la boucle peut être simple ou composée.
Applications
Application 1
1. Traduire l’algorithme cet algorithme en pascal et enregistrez le programme source

sur le nom "Ap1.pas"
0) début algorithme choix
1) lire (c)
2) tant que (C<>5) faire
si (C MOD 2= 0) alors
écrire (2*C)
sinon
écrire (C*C)
fin si
lire (c)
fin tant que
3) fin choix
2. Exécutez le programme pour chacune des valeurs suivantes de la variable C.
C=7
C=4
C=5
Application 2
On se propose d’écrire un algorithme qui permet de saisir une suite d’entiers qui se
termine par -1 puis de calculer et d’afficher la somme de ces valeurs sauf la dernière.
Exemple : si la suite saisie est 5, 6, 7, -4, -1 la valeur affichée est 14
MBADJOUN/JFN-IT 8
Les sous programmes
1. Généralités.
2. Avantages des sous programmes.
3. Structure d'un programme .
4. Procédure et fonction .
5. Déclaration de procédure simple.
6.Procédure simple avec des variables locales.
7.Procédure paramétrée.
8. Communication entre procédures.
9. Mode de passage de Paramètres.
10. Les fonctions.
****************************************************
1°) GENERALITES.
Lors de la conception d’un programme résolvant un problème général, il est nécessaire de décomposer le problème en
différent sous-problèmes moins complexe à résoudre : Démarche ascendante.
Ces différents sous-problèmes peuvent être résolus grâce à des sous-programmes particuliers : Procédures et fonctions.
Exemple : Écrire un programme qui affiche en ordre croissant les notes d'une promotion suivies de la note la plus faible,
de la note la plus élevée et de la moyenne
Revient à résoudre les problèmes suivants :
- Remplir un tableau de réels avec des notes saisies par l'utilisateur
- Trouver le plus petit réel d'un tableau
- Trouver le plus grand réel d'un tableau
- Calculer la moyenne d'un tableau de réels.
Donc écrire un programme qui résout un problème revient toujours à écrire des sous-programmes qui résolvent des
sous parties du problème initial
Un sous-programme est obligatoirement caractérisé par un nom (un identifiant) unique
Lorsqu'un sous programme a été explicité (on a donné l'algorithme), son nom devient une nouvelle instruction, qui peut
être utilisé dans d'autres (sous-)programmes
Le (sous-)programme qui utilise un sous-programme est appelé (sous-)programme appelant.
2°) Avantages des sous programmes.
● Les sous programmes permettent de ne pas répéter plusieurs fois une même séquence d’instructions au sein du
programme.
● La mise au point du programme est plus rapide en utilisant des sous programmes. En effet, elle peut être réalisée
en dehors du contexte du programme.
● Un sous programmes peut être intégré à un autre programme, ou elle pourra être rangée dans une bibliothèque
d’outils ou il pourra être utilisé par n’importe quel programme.

Exemple de problème
Écrire un algorithme qui calcule et affiche la moyenne des valeurs absolues de trois nombres A,B,C, sachant qu'on n'a
pas la fonction ABS.
Algorithme MoyValAbsolu ;
Déclaration
A,B,C,A1,B1,C1 : entier ;
moy : réel ;
Début
· valeur absolue a été effectué 3 fois de la même
· manière pour A, pour B et pour C.
· il serait préférable de prévoir un module ou sous
· programme consacré au calcul ou traitement de la
· valeur absolue isolée.
· Aussi on peut écrire un sous programme pour le
Fin
Dans cet algorithme le calcul de la valeur absolue a été effectué 3 fois de la même manière
è Il est préférable d’écrire un sous programme consacré au calcul de la valeur absolue.
è On peut aussi écrire un sous programme pour le calcul de la moyenne de 3 nombres.
Algorithme MoyValAbsoluVers2
déclaration
A,B,C:entier ; M : réel
fonction Absolu(X :entier) :entier
Début
Si X < 0 alors
Absolu← -X
Sinon
Absolu ← X
Fin si
Fin
fonction Moyenne(X :entier ; Y :entier ; Z :entier):réel ;
Début
Moyenne ← (X+Y+Z)/3
Fin
Début
Lire(A,B,C)
M ← Moyenne(Absolu(A),Absolu(B),Absolu(C))
Écrire(M)
Fin .
3°)Structure d'un programme :
Un programme doit suivre la structure suivante :
Programme nom du programme
Définition des constantes
Définition des types
Déclaration des variables globales
Définition des sous-programmes
début
instructions du programme principal
fin
4°) Procédure et fonction :

On perçoit un programme comme un programme principal et un ensemble de procédure/fonctions. Ce découpage est à la
base de la programmation structurée.
Procédures : Une procédure est un sous-programme exécutant une suite d'actions. Elle ne retourne aucun résultat, elle
peut être perçue comme une boîte noire exécutant une tâche donnée.
Deux types de procédures :
- La procédure simple
- La procédure paramétrée
Fonctions : Une fonction est un sous-programe qui retourne obligatoirement une valeur.
4 .1 Exemples de procédures et fonctions standards :
Procédures standard : readln ;
Fonctions standard : ord( i) ;
4.2 Sous programmes défini par l’utilisateur :
4.2.1 Déclaration de procédure simple :
Ce type de sous-programme exécute une tâche précise. Cette tâche est indépendante des autres sous programmes et donc
ne permet pas de partager des informations.
Exemple :
Procédure afficher ( );
Début
Ecrire(‘ mot de passe incorrect, veuillez entrer un nouveau mot de passe’) ;
Fin
Définition d'une procédure simple :
procédure nom_procédure ( ) ;
Déclaration
//variables locales
Début
// Actions
Fin
Les variables locales sont utilisées uniquement dans la procédure.
La procédure simple ne doit utiliser que les variables locales.
Appel d'une procédure simple
Pour exécuter le contenu d'une procédure simple, on écrit le nom de la procédure comme si elle était une action connue.
Une procédure peut-être appelée à partir d'un programme ou d'un autre sous- programme.
Exemple
Algorithme mot-passe ;
Déclaration
mot : entier ;
Procédure afficher ( );
Début
Ecrire(‘ mot de passe incorrect’) ;
Fin
début
lire ( mot) ;
tant que mot < > ‘27122008’ faire
afficher ( ) ;
lire (mot) ;
FinTQ
Fin
Principe de fonctionnement :
Prg appelant prg appelé
Afficher( )
Début
--
--
--
Fin.
(mot-passe )
--
--
Afficher( ) ;
--
--
4.2.2 Procédure simple avec des variables locales :
Exemple :
Écrire une procédure qui "saute trois lignes" sur l'écran
Version 1 Version 2 Version 2bis

Procedure Saute3Lignes; Procedure Saute3Lignes; Procedure Saute3Lignes;
Begin Var i : Integer; Const N = 3;
WriteLn; Begin Var i : Integer;
WriteLn; For i:= 1 To 3 Do Begin
WriteLn Begin For i:= 1 To N Do WriteLn
End; WriteLn End;
End
Pas d’évolutivité End;
Sans paramètres Plus évolutif car Mieux "Paramétré"
4.2.3 Procédure paramétrée :

Déclaration de la procédure paramétrée
Procédure NomProcédure (Paramètres Formels avec leur Types)
déclaration
Déclaration des variables locales
Débuts
[…]
Instructions
[…]
Fin
Outils locaux et globaux

Définitions :
- La portée d’une variable est l’ensemble des sous-programmes où cette variable est connue (les instructions de ces
sous-programmes peuvent utiliser cette variable)
- Une variable définie au niveau du programme principal (celui qui résouds le problème initial, le problème de plus
haut niveau) est appelée variable globale
Sa portée est totale : tout sous-programme du programme principal peut utiliser cette variable
- Une variable définie au sein d’un sous programme est appelée variable locale
La portée d’une variable locale est uniquement le sous-programme qui la déclare
Lorsque le nom d’une variable locale est identique à une variable globale, la variable globale est localement masquée
Dans ce sous-programme la variable globale devient inaccessible
Les déclarations locales. Peuvent être :
è des déclarations de constantes (blocs const)
è de variables (blocs var)
è ou d'autres procédures.
CONSEIL :
Il faut éviter au maximum les variables globales (sauf les constantes) : trop d’espace mémoire
Exemple :
X de A
Y de A
Y de B
X d'Essai
Y d'essai
I : erreur , inaccessible
Les paramètres formels/effectifs :

•les paramètres formels sont des identificateurs de variables fictives utilisées pour introduire des données dans la
procédure ou sortir des résultats dans la procédure
•Un paramètre effectif est une variable ou constante (numérique ou définie par le programmeur)
Le paramètre formel et le paramètre effectif sont associés lors de l’appel du sous-programme
Le paramètre formel et effectif doivent donc être de même type.
4.2.4 Communication entre procédures :

On entend par communication, l’échange d’informations, la communication entre procédure se fait au moyen de
variables globales ou locales :
a) Communications par variables globales :
Exemple :
Program afficher ;
Var
N : integer ;
Procedure SauteLignes ( );
Var i : Integer;
Begin
For i:= 1 To n Do
Begin
WriteLn;
End
End;
Begin
Writeln(‘ entrez le nombre de lignes à sauter’) ;
Readln( n) ;
Sautlignes() ;
Fin.
C’est une communication implicite et bilatérale car les variables globales peuvent être modifiées par la procédure et le
programme principal, c’est la seule alternative pour les procédures sans paramètres.
b) Communications par paramètres :
Le besoin de paramétrer une procédure se fait senti quand cette même procédure peut être exécutée avec valeurs
différentes :
Notation : procedure nom-proc ( paramètres formels : type ) ;
Exemple : Procedure SauteLignes ( x : integer );
Les paramètres formels : la déclaration des paramètres formels à l’entête de procédure décrit les données attendus par la
procédure pour s’exécuter, ce sont des variables locales à la procédures.
Les paramètres effectifs : ce sont les données communiquées à la procédure au moment de son appel, les paramètres
effectifs sont substitués par les paramètres formels ; et doivent correspondre en nombre , en type et en ordre aux
paramètres formels.
Exemple :
Procedure ligne ( c ;char , i : integer) ;
Var j: integer;
Begin
For j := 1 to I do
Write ( c);
End;
Ligne ( * , 2 ) affichera : **.
Ligne ( Z, X) ou x = 5 affichera : ZZZZZ .
A l’appel d’une procédure les actions suivantes sont réalisées :

- faire correspondre à chaque paramètre formel son paramètre effectif.
- Exécuter les actions de la procédure appelée.
- Revenir à la procédure appelante et reprendre l’exécution des instructions restantes.
4.2.5 Mode de passage de Paramètres

En Pascal, il y en 2 :
- passage par valeur
- passage par référence ou adresse.
a) Passage par valeur :

-Les instructions du sous-programme ne peuvent pas modifier le paramètre effectif
En fait c’est la valeur du paramètre effectif qui est copiée dans le paramètre formel
-C’est le seul passage de paramètre qui admet l’utilisation d’une constante
-Ce type de transmission ne permet pas de transmettre des résultats à un autre module
(procédure ou fonction) ou au programme principal par l’intermédiaire du paramètre effectif, étant donné que le contenu
de celui-ci n’est pas modifié au retour de la procédure.
-La déclaration d’un paramètre par valeur s’effectue selon le format suivant :
PROCEDURE NomProcedure(parametre : TypeParametre);
Exemple : Notons que, dans la procédure SautLigne de l’exemple précédent le paramètre nblignes est déclaré par valeur.
b)Passage par variable ou par adresse :
Lors de l’appel :
- Le paramètre effectif doit être une variable de type compatible.
- Son adresse sera envoyée à la procédure
- La procédure travaillera donc directement sur sa valeur.
- Donc toute modification sera définitive
- La procédure peut le consulter et le modifier
La déclaration d’un paramètre par variable s’effectue selon le format suivant :
PROCEDURE NomProcedure(VAR parametre : TypeParametre);
On notera le recours au mot clé VAR pour introduire le ou les paramètres que l’on veut transmettre par variable.
Exemple :
PROGRAM Progperm;
VAR
val1, val2 : REAL;
PROCEDURE Permuter(X, Y : REAL); {En-tete de la procedure}
VAR
tampon : REAL;
BEGIN {Debut de la procedure}
tampon := X;
X := Y;
Y := tampon;
END; {Fin de la procedure}
BEGIN {Debut du programme principal}
Val1 := 100 ; val2 := 400 ;
Permuter(val1, val2); résultat : X= 100 , Y= 400
WRITELN('X = ', val1 : 4, 'Y = ', val2 : 4);
END. {Fin du programme principal}
Les paramètres X et Y doivent être transmis par variable, ce qui aura pour effet de rendre disponibles, à la sortie de la
procédure, les nouvelles valeurs effectives de ces paramètres.
PROGRAM Progpermut;
VAR val1, val2 : REAL;
PROCEDURE Permuter(VAR X, Y : REAL); {En-tete de la procedure}
VAR
tampon : REAL;
BEGIN {Debut de la procedure}
tampon := X;
X := Y; a résultat : X= 400 , Y= 100
Y := tampon;
END; {Fin de la procedure}
BEGIN {Debut du programme principal}
val1 := 100 ; val2 := 400;
Permuter(val1, val2);
WRITELN('VAL1 = ', val1 : 4, 'VAL2 = ', val2 : 4);
END. {Fin du programme principal}
Mentionnons enfin qu’une procédure peut elle-même appeler d’autres procédures : c’est ce qu’on appelle l’imbrication
de procédures.
Program essai ;
Procedure Incrementer (X : integer ; Var Y : integer) ;
Var K : integer ;
{1}
Begin
K := 2 ; X := X + K ; Y := Y + K ;
writeln ('X=',X,' & Y=',Y, '&K=', K); {2}
End ;
Var A, B, K : integer ;
Begin
A := 3 ; B := 2 ; K := 3 ;
Incrementer (A, B) ;
writeln ('A=',A,' & B=',B, ' & K=', K)
End.
4.2.3. Les fonctions :

- Une fonction est un sous-programe qui retourne obligatoirement une valeur.
- Lors d'un appel, une fonction est considérée comme une expression du type de la valeur retournée (exemple : si la
fonction retourne un entier, on considère la fonction comme une expression entière).
a)Généralités
On distingue deux catégories de fonctions : les fonctions standards et les fonctions non standards.
- Par fonction standard, on entend toute fonction connue du langage. C’est le cas, entre autres, des fonctions ABS,
TRUNC, ROUND, SQR, SQRT, PRED, SUCC que nous avons déjà vues.
- Par fonction non standard, on entend toute fonction non connue du langage et qui, par conséquent, nécessite une
définition préalable à son utilisation.
b)Les fonctions paramétrées
Une fonction avec paramètres a pour format :
fonction nom de la fonction (paramètre(s) de la fonction) : type de la valeur retournée
Déclaration variable locale 1 : type 1; . . .
début
instructions de la fonction
fin
fonction abs (unEntier : Entier) : Entier
début
si unEntier >0 alors
abs← unEntier
sinon
abs← -unEntier
finsi
fin
En pascal : FUNCTION NomFonction(ListeDeParametres) : TypeFonction;
où ListeDeParametres désigne la liste (non vide) déclarée des paramètres formels de la fonction, et TypeFonction le type
de la fonction, c’est-à-dire celui du résultat calculé ou généré par cette fonction.
Exemple :
Program addition ;
Var X, Y,Moy :real ;
FUNCTION Somme(nombre1, nombre2 : REAL); Real; {En-tete de la fonction}
BEGIN {Debut de la fonction}
Somme := nombre1 + nombre2;
END;{Fin de la fonction}
Begin
Readln ( X ,Y ) ;
Moy := somme ( X, Y) / 2 ;
Writeln( ‘ la moyenne : ‘ ,moy) ;
End.
- le passage de paramètre est uniquement par valeur
Chapitre 5: Les tableaux
I- Tableau à une dimension

1. Définition
La taille du tableau est donc max_indice-min_indice+1.

Pour accéder à un élément d'un tableau T d'indice I, on écrit T[I]. La
complexité de l'accès à un élément du tableau est O(1).
Notation Soit min_indice<i<j<max_indice, notera T[i..j] la séquence des
éléments de T (T[i],T[i+1],...,T[j]).
Beaucoup d'algorithmes peuvent être décrits sans préciser un type particulier.
Dans ce cas, on écrira à la place de type_prédéfini le mot élément et on
précisera les valeurs possibles pour élément.
Exemple 1.
Soit deux tableaux
TC=tableau[1..10]de car;
TE=tableau[1..10]d'entiers;
2. Déclaration dans les tableaux
Déclaration du type tableau
Initialisation du tableau
Déclaration du type tableau
Pour déclarer une variable du type tableau, il est préférable que le type soit déclaré auparavant.
3. Opération sur les tableaux
Ecriture dans un tableau
4. Exemples Pascal d’écriture d’un tableau

Création des tableaux d’enregistrement et des enregistrements qui contiennent les tableaux
Exemple de passages des paramètres : on écrit une procédure affichant un eleve_t
Produit scalaire de deux vecteurs entrés par l’utilisateur.

Codage d’une chaiine de caractère
On code une chaiine de caractère telle que ’bonjour’ dans un objet de type
string.
II- Tableaux à plusieurs dimensions
JFN-IT GI 1
Chapitre 6: les types structurés et les enregistrements
Introduction
Contrairement aux tableaux qui sont des structures de données dont tous les éléments sont de même type, les
enregistrements sont des structures de données dont les éléments peuvent être de type différent et qui se rapportent à
la même entité (au sens de Merise)
Les éléments qui composent un enregistrement sont appelés champs.
Avant de déclarer une variable enregistrement, il faut avoir au préalable définit son type, c'est à dire le nom et le type
des champs qui le compose. Le type d'un enregistrement est appelé type structuré. (Les enregistrements sont parfois
appelé structures, en analogie avec le langage C)
Préalable: déclaration d'un type structuré
Jusqu'à présent, nous n'avons utilisé que des types primitifs (caractères, entiers, réels, chaînes) et des tableaux de types
primitifs. Mais nous pouvons créer nos propres types puis déclarer des variables ou des tableaux d'éléments de ce type.
Pour créer des enregistrements, il faut déclarer un nouveau type, basé sur d'autres types existants, qu'on appelle type
structuré Après avoir défini un type structuré, on peut l'utiliser comme un type normal en déclarant une ou plusieurs
variables de ce type. Les variables de type structuré sont appelées enregistrements.
La déclaration des types structurés se fait dans une section spéciale des algorithmes appelée Type, qui précède la section
des variables (et succède à la section des constantes).
Syntaxes :
(notation inspirée du Pascal) (notation inspirée du C)
Type ou Type
nom_type = enregistrement Structure nom_type
nom_champ1: type_champ1 nom_champ1: type_champ1
… …
nom_champn: type_champn nom_champN: type_champN
finenreg FinStruct
Exemple:
Type ou Type
tpersonne = enregistrement Structure tpersonne
nom : chaîne nom : chaîne
prénom : chaine prénom : chaîne
âge : entier âge : entier
finenreg FinStruct
I. Déclaration d'un enregistrement à partir d'un type structuré
Une fois qu'on a défini un type structuré, on peut déclarer des variables enregistrements exactement de la
même façon que l'on déclare des variables d'un type primitif.
1
JFN-IT GI 1
Syntaxe
Var
nom_var : nom_type
Exemple:
Var
pers1, pers2, pers3 : tpersonne
Représentation:
les enregistrements sont composés de plusieurs zones de données, correspondant aux champs
pers1.nom pers1.age
pers1
pers2.nom pers2.age
pers2
Exemple:
Soit l'entité suivante: PRODUIT légende:
code code: code alphanumérique du produit
lib lib: libéllé
paht paht: prix d'achat hors taxes
pvht pvht: prix de vente hors taxes
txtva txtva: taux de TVA applicable
Voici comment déclarer deux occurrences (variables enregsitrements) du type structuré correspondant
à cette entité.
// Il faut d'abord définir le type structuré correspondant:

Type ou Type
produit = enregistrement Structure produit
code: chaîne code: chaîne
lib: chaîne lib: chaîne
paht: réel paht: réel
pvht: réel pvht: réel
txtva: réel txtva: réel
finenreg FinStruct
// Ensuite il est possible de déclarer deux variables de ce type

Var
prod1, prod2 : produit
II. Manipulation d'un enregistrement
La manipulation d'un enregistrement se fait au travers de ses champs. Comme pour les tableaux,
il n'est pas possible de manipuler un enregistrement globalement, sauf pour affecter un enregistrement
à un autre de même type. Par exemple, pour afficher un enregistrement il faut afficher tous ses champs
uns par uns.
2
JFN-IT GI 1
A. Accès aux champs d'un enregistrement
Alors que les éléments d'un tableau sont accessibles au travers de leur indice, les champs d'un
enregistrement sont accessibles à travers leur nom, grâce à l'opérateur '.'
nom_enregistrement . nom_champ
représente la valeur mémorisée dans le champ de l'enregistrement
Par exemple, pour accéder à l'âge de la variable pers2, on utilise l'expression:

pers2.âge
Attention : le nom d'un champ est TOUJOURS précédé du nom de l'enregistrement auquel il
appartient. On ne peut pas trouver un nom de champ tout seul, sans indication de l'enregistrement.
Les champs d'un enregistrement, tout comme les éléments d'un tableau, sont des variables à qui on
peut faire subir les mêmes opérations (affectation, saisie, affichage,…).
Exemple 1:
Programme de saisie des données concernant les personnes pers1 et pers2, puis affichage de la
différence d'âge entre ces deux personnes
Programme Exemple
Type
Structure tpersonne
nom : chaîne
prénom : chaîne
âge : entier
FinStruct
Var
pers1, pers2 : tpersonne
Début
Aff "Entrez le nom puis l'age de la personne 1"
Saisir pers1.nom, pers1.age // il est impossible d'écrire Saisir pers1
Aff "Entrez le nom puis l'âge de la personne 2"
Saisir pers2.nom, pers2.age
Aff "La différence d'âge entre ", pers1.nom, " et ", pers2.nom, " est de "
Si pers1.age > pers2.age
Alors Aff pers1.age – pers2.age, " ans "
Sinon Aff pers2.age – pers1.age, " ans "
FinSi
Fin
B. Passage d'un enregistrement en paramètre d'un sous-programme
Il est possible de passer tout un enregistrement en paramètre d'une fonction ou d'une procédure (on
n'est pas obligé de passer tous les champs uns à uns, ce qui permet de diminuer le nombre de
paramètres à passer), exactement comme pour les tableaux.
Exemple :
Voilà une fonction qui renvoie la différence d'age entre deux personnes
3
JFN-IT GI 1
Fonction différence (p1, p2 : tpersonne)

Début
Si pers1.age > pers2.age
Alors Retourne ( pers1.age – pers2.age )
Sinon Retourne ( pers2.age – pers1.age )
FinSi
FinFonct
Exemple 2 :
Voilà une procédure qui permet de modifier le prix de vente hors taxes d'un produit passé en
paramètre. Cette procédure commence par afficher le libellé et l'ancien prix de vente hors taxes du
produit puis saisit le nouveau prix de vente entré par l'utilisateur.
Procédure majpv (E/S x: produit)

Début
Aff "produit: ", x.lib
Aff "prix de vente hors taxe actuel: ", x.pvht
Aff "Entrez le nouveau prix de vente: "
Saisir x.pvht
Aff "le nouveau prix de vente est: ", x.pvht
FinProc
B. L'imbrication d'enregistrements
Supposons que dans le type personne, nous ne voulions plus l'âge de la personne, mais sa date de
naissance. Une date est composée de trois variables (jour, mois, année) indissociables. Une date
correspond donc à une entité du monde réel qu'on doit représenter par un type enregistrement à 3
champs.
Si on déclare le type date au préalable, on peut l'utiliser dans la déclaration du type personne pour le
type de la date de naissance.
Un type structuré peut être utilisé comme type pour des champs d'un autre type structuré
TYPE
Structure date
jour: entier
mois: chaîne
année: entier
FinStuct
Structure personne
nom: chaîne
ddn: date
FinStruct
Pour accéder à l'année de naissance d'une personne, il faut utiliser deux fois l'opérateur '.'
pers1.ddn.année
Il faut lire une telle variable de droite à gauche : l'année de la date de naissance de la personne 1.
4
JFN-IT GI 1
Exemple Complet
Un produit (cf. ex précédents) est livré par un seul fournisseur. Un fournisseur est caractérisé par son code, sa
raison sociale et son numéro de téléphone.
Type
Structure adresse
num : entier
rue: chaîne
cp: chaîne
ville: chaîne
FinStruct
Structure fournisseur
code_frs : chaine
raison_sociale: chaine
ad_frs: adresse
tel: chaine
FinStruct
Structure Produit
code: chaîne
lib: chaîne
paht: réel
pvht: réel
txtva: réel
frs: fournisseur
FinStruct
Var
p: produit
Voilà l'instruction qui permet d'afficher le numéro de téléphone du fournisseur du produit p.frs.tel
Aff "téléphone du fournisseur de ", p.lib, " : ", p.frs.tel
Voilà le MCD correspondant. Déduisez en la correspondance entre l'imbrication des enregistrements

et le type d'association entre 2 entités.
FOURNISSEUR
PRODUIT
code code_frs
1,1 raison_sociale
lib 0,n
paht est livré par tel
pvht
txtva
Fournisseur qui est en dépendance fonctionnelle sur produit est imbriqué dans produit.
De façon générale, une entité 1 en dépendance fonctionnelle sur une autre entité 2 est représentée en
programmation par un type structuré imbriqué dans le type structuré correspondant à l'entité 1.
5
JFN-IT GI 1
III. Les tableaux d'enregistrement (ou tables)

Il arrive souvent que l’on veuille traiter non pas un seul enregistrement mais plusieurs. Par exemple,
on veut pouvoir traiter un groupe de personne. On ne va donc pas créer autant de variables du type
personne qu’il y a de personnes. On va créer un tableau regroupant toutes les personnes du groupe. Il
s’agit alors d’un tableau d’enregistrements.
Const
NP = 20 // nombre de personnes du groupe
Type
Structure personne
nom: chaîne
age: entier
FinStruct
Var
groupe: tableau[1..NP] de personnes
Chaque élément du tableau est un enregistrement, contenant plusieurs variables de type différent. On
accède à un enregistrement par son indice dans le tableau.
groupe[2] représente la deuxième personne du groupe
groupe[2].nom représente le nom de la deuxième personne du groupe
nom âge nom des champs
1
indices du tableau
Attention!
groupe.nom[3] n'est pas valide.
Pour accéder au nom de la troisième personne du tableau, il faut écrire g roupe[3].nom
6
Chapitre 7 : Problèmes de recherche et de tri
I- Problème de tri
1. Définition d’un algorithme de Tri
Les tableaux permettent de stocker plusieurs éléments de même type au sein d’une seule
entité, Lorsque le type de ces éléments possède un ordre total, on peut donc les ranger en
ordre croissant ou décroissant,
Trier un tableau c’est donc ranger les éléments d’un tableau en ordre croissant ou décroissant
Dans ce cours on ne fera que des tris en ordre croissant
Il existe plusieurs méthodes de tri qui se différencient par leur complexité d’exécution et leur
complexité de compréhension pour le programmeur.
Examinons tout d’abord : le tri par minimum successif
Commençons par évoquer la procédure échange.
• La procédure échanger...
Tous les algorithmes de tri utilisent une procédure qui permet d’échanger (de permuter) la
valeur de deux variables Dans le cas où les variables sont entières, la procédure échanger est
la suivante : procédure échanger (E/S a,b : Entier )
Déclaration temp : Entier
Début
temp ← a
a←b
b ← temp
fin
• Tri par minimum successif...

Principe
Le tri par minimum successif est
- un tri par sélection : Pour une place donnée, on sélectionne l’élément qui doit y être
positionné
De ce fait, si on parcourt le tableau de gauche à droite, on positionne à chaque fois le plus
petit élément qui se trouve dans le sous tableau droit
- Ou plus généralement : Pour trier le sous-tableau t[i..nbElements] il suffit de
positionner au rang i le plus petit élément de ce sous-tableau et de trier le sous-tableau
t[i+1..nbElements]
• Fonction indiceDuMinimum...
• Tri par minimum successif...

Recherche du minimum sur un tableau de taille n
→ Parcours du tableau
• Le tri à bulles
Principe de la méthode : Sélectionner le minimum du tableau en parcourant le tableau de la
fin au début et en échangeant tout couple d’éléments consécutifs non ordonnés.
Exemples :
• Le tri rapide
• Tri par sélection
- Algorithme de tri par sélection
• Tri par insertion (joueur de cartes)

- Algorithme par tri par insertion
Tri fusion
• La partition
II- Algorithme de recherche

• Algorithme de recherche d’un élément dans un tableau
Algorithme
Entrée : un tableau tab de taille taille et un élément e.
Sortie : i tel que tab[i] = e ou NonTrouvé (ex : -1).
pour i de 0 à taille-1 faire
si tab[i] = e alors
retourner i
retourner NonTrouvé
Pour aller plus vite, on peut utiliser les tableaux triés et la dichotomie (méthode
«diviser pour régner») :
Retenir (Idée)
Si le tableau tab est trié, pour tout indice i,
les éléments e ≤ tab[i] sont d’indice ≤ i ;
les éléments e > tab[i] sont d’indice > i.
On essaye avec i au milieu du tableau.
• Recherche dichotomique
Algorithme (RechDichoRec : recherche dans un tableau trié)
Entrée : un tableau trié tab, un intervalle [min; max] avec
0 ≤ min ≤ max < taille et un élément e.
Sortie : i tel que tab[i] = e ou NonTrouvé (ex : -1).
si min = max alors
si tab[min] = e alors retourner min
sinon retourner NonTrouvé
mid <- (min + max) / 2
si tab[mid] < e alors
retourner RechDichoRec(tab, mid+1, max, e)
sinon
retourner RechDichoRec(tab, min, mid, e)
• Recherche dichotomique itérative

Remarque : La recherche dichotomique est récursive terminale.
Algorithme (RechDichoIt recherche dichotomique itérative)
min <- 0;
max <- taille - 1
tant que min < max faire
si tab[mid] < e alors
min <- mid+1
sinon
max <- mid
On peut stopper la recherche plus tôt si l’on a trouvé !

Algorithme (Recherche dichotomique variante)
min <- 0;
max <- taille - 1
tant que min < max faire
si tab[mid] = e alors retourner mid
sinon si tab[mid] < e alors
min <- mid+1
sinon
max <- mid-1
Chapitre 8 : Les fichiers
1. Introduction
• programme Pascal = données en mémoire physique
Ces données sont volatiles risques ?
Ces données ne sont pas persistantes problèmes ?
• nécessité d’un moyen de stockage permanent :
Disque dur, disquettes, Cdroms …
• notion de fichier :
Enregistrement de données sur support physique permanent
un fichier :
• un identifiant (nom)
• un emplacement (lié au support)
• un contenu (données)
2. Précisions sur la notion de fichier
• la notion d’identifiant de fichier
nom externe : c’est le nom du fichier pour le système de fichier du système d’exploitation considéré,
par exemple : mon_fichier.dat
nom interne : c’est le nom du fichier connu par le programme, il est déclaré par le programme, par
exemple : Fichier_de_données
nécessité d’associer le fichier physique à sa représentation interne : commande Assign
• le « repère » de position
Il permet de savoir où l’on se trouve dans un fichier lorsque l’on accède à celui-ci dans l’ordre de ses
enregistrements (accès séquentiel).
C’est aussi lui qui détermine le résultat des opérations telles que : Eof ou Eoln.
3. Différents types de fichiers
• Un fichier informatique est organisé en enregistrements, chaque enregistrement contenant une
collection d'unités logiques d'informations encore appelées rubriques. Souvent les enregistrements ont
la même structure.
• Une rubrique est la plus petite unité logique d'information ayant un sens en tant que tel. La
taille d'une rubrique s'exprime en nombre de caractères et peut être fixe ou variable.
• La façon selon laquelle ces rubriques et enregistrements sont organisés dans le fichier
détermine le type de fichier :
• ordre physique = ordre logique : organisation séquentielle (naturelle à Pascal)
• enregistrements de taille fixe, portant un numéro qui est relatif au début du fichier :
organisation relative
• chaque enregistrement est associé à une clé : organisation indexée
4. Méthodes d’accès aux données
• Les méthodes par lesquelles on lit ou on écrit un enregistrement d'un fichier sont appelées les
méthodes d'accès.
• La méthode d'accès que l'on veut utiliser doit être spécifiée au moment de l'ouverture du
fichier. Un même fichier peut être accédé par des méthodes différentes selon son organisation qui elle
a été définie au moment de sa création.
• Les différentes méthodes d’accès :

• accès séquentiel : enregistrements traités en séquence
• accès direct : accès direct par le numéro d’enregistrement
• accès indexé : accès par l’ordre des clés d’accès
Rq : on ne peut utiliser que la méthode d’accès séquentielle avec une organisation de fichier
séquentielle (Turbo Pascal permet également la méthode d’accès direct)
5. Rappels de typage en Pascal : enregistrements
• Rappel :
Un enregistrement est un type complexe, composé (généralement) de plusieurs champs ou rubriques.
Cela permet de définir un élément contenant plusieurs informations de types éventuellement différents.
• Déclaration d’un enregistrement :
• accès aux champs d’un enregistrement :
• Déclaration d’une chaîne de caractères :
• Opérations principales sur une chaîne :

• Remarques additionnelles sur les chaînes :
✓ une chaîne ne peut pas dépasser 255 caractères
✓ un caractère est une chaîne de taille 1
✓ la chaîne vide existe : ’’
6. Utilisation des fichiers d’enregistrements
Rq : il existe deux variables fichiers prédéfinies, input et output de type text qui n’ontpas besoin d’être
déclarées
• Assignation physique :
Principales commandes sur les fichiers

• Indicateur de fin de fichier :
• Exemples d’associations par assign:
• Opérations d’ouverture / fermeture :
• Opérations de lecture / écriture (Pascal):
• Opérations de lecture / écriture (TurboPascal):
Exemple d’utilisation d’un fichier typé :

Lecture d’un fichier de nombres réels et calcul de leur somme
Copie d’un fichier binaire dans un autre

7. Cas particulier : les fichiers de texte
• Les fichiers de texte sont des cas particuliers de fichiers. Un fichier de texte est formé
d'éléments bien connus : les caractères. Chacun a déjà manipulé de tels fichiers : un programme
(Pascal ou autre) est en fait un fichier de texte!
• Les caractères contenus dans un fichier de texte sont organisés en lignes, chacune terminée par
une marque de fin de ligne. Après la dernière ligne, le fichier se termine par une marque de fin de
fichier.
• Tout ce qui a été dit est valable pour les fichiers de texte. Précisons simplement qu’un fichier
est un fichier de texte s'il est déclaré au moyen du type prédéfini text .
Rq : Un fichier de type text n'est généralement pas équivalent à un fichier de "type" :
file of char qui, lui, ne possède pas une structure de lignes !
• Déclaration d’un fichier de texte :
8. Lecture dans un fichier
Exemple sur les fichiers de texte : copie de fichier

Copie de fichier texte avec lecture par caractère
Compléments : fichiers externes / internes
Compléments : fichiers input / output

Compléments : directives de compilation
Compléments : accès direct

Accès direct à un enregistrement dans un fichier par la commande seek
Compléments : recherche dichotomique
Initiation à l’algorithmique et au langage Pascal
Chapitre 9: Applications sur un langage algorithmique:

PASCAL
1 Introduction
1.1 Quelques mots sur l’algorithmique
De nos jours, l’algorithmique est associée à la programmation informatique. Cependant, elle ne
date pas d’hier puisque les premiers algorithmes remontent à environ 1800 ans avant J.C avec les
babyloniens, ensuite Euclide (PGCD) et beaucoup d’autres. Contrairement à ce que l’on pourrait penser,
les algorithmes ne se traitent pas qu’avec des nombres ; il en existe énormément qui traitent d’autres
données, comme l’algorithme génétique (ADN), les algorithmes de sortie d’un labyrinthe, les algorithmes
de jeux, . . .
Les algorithmes ne se décrivent pas avec un langage de programmation contrairement aux idées reçues
et donc ne nécessitent pas un ordinateur pour les écrire. Nous allons donc apprendre à résoudre des
problèmes par le biais d’algorithmes et ensuite à les appliquer en deux étapes :
• Ecriture d’un algorithme c’est à dire une méthode permettant de trouver une solution à partir des
données d’un problème.
• Ecriture d’un programme qui consiste à traduire un algorithme pour une machine dans un langage
de programmation donné, ici le Pascal.
Définition 1.1. Un algorithme est une description finie d’un calcul qui associe un résultat à des
données. Il est composé de 3 parties :
• son nom
• sa spécification qui décrit quels sont les paramètres en entrée et quel est le résultat en sortie.
Elle décrit le problème résolu par l’algorithme (la fonction résolu par l’algorithme).
• son corps qui décrit la démarche de résolution d’un problème dans un langage algorithmique,
il fournit divers objets et instructions primitives ainsi que des moyens de les composer, mais
ne nous empêche pas de faire appel à un algorithme dans un autre.
Remarque : Par le terme langage algorithmique il ne faut pas entendre quelque chose de normé
mais d’évolutif car la syntaxe est propre à l’auteur, mais si l’on fonctionne de cette manière, il y a
de forte chance de ne pas se faire comprendre par les autres d’où la nécessité d’utiliser les mêmes
notations par pure lisibilitée pour les autres.
Exemple : Un exemple d’algorithme permettant de définir si un entier a est pair :
Algorithme 1: estPair
Données : a ∈ N
Résultat : VRAI si a est pair, FAUX sinon
début
si a modulo 2 = 0 alors
renvoyer VRAI
sinon
renvoyer FAUX
fsi
fin
2
Explications : ici modulo sert à renvoyer le reste de la division euclidienne de a par 2. La
division euclidienne de a par b s’écrit d’une manière unique a = b × q + r avec q le quotient et r
le reste tels que 0 ≤ r < b.
Une fois un algorithme écrit, on l’utilise par application à des arguments.
Exemple : Fonctionnement de l’algorithme précédent avec l’exécution de estPair(21) :

• Substituer 21 à a dans le corps de estPair
• Si (21 mod 2) = 0 alors on va renvoyer true
• Sinon renvoyer f alse.
Le résultat de cette exécution est f alse.
Par analogie avec les mathématiques, un algorithme est semblable a une fonction f , les objets x sur
lesquels agit f portent là aussi le nom de variables, et leurs images y = f (x) car elles peuvent servir
de nouvelles variables sur lesquelles faire agir une autre fonction g. Dans un souci de simplification, on
admet généralement que les constantes sont des cas particuliers de variables.
Plus précisément, une variable est une donnée désignée par un nom précis et immuable, mais dont la
valeur est susceptible de changement au cours du déroulement de l’algorithme.
Reprenons l’analogie avec les mathématiques : une fonction f définie sur un ensemble E, est à valeurs
dans un ensemble F très souvent distinct de E.
L’algorithmique fait un grand usage du cas où F ne possède que deux éléments, appelés selon le contexte
0 et 1, oui et non, vrai ou faux. On appelle alors variables booléennes, ou indicateurs booléens
les variables dont les images (leurs valeurs) sont nécessairement vrai ou faux.
Dans la pratique, il s’agit toujours de propositions logiques simples, souvent dépendant d’un ou plusieurs
paramètres, auxquels les mathématiques donnent une valeur de vérité : ainsi la proposition “a est un
nombre pair” est vraie si a = 3 et fausse si a = 4.
Définition 1.2. En informatique, il faut différencier deux types de variables :

• paramètre formel que l’on nommera dans la suite du cours paramètre : il s’agit de la
variable utilisée dans le corps de l’algorithme (par ex : si on avait déclaré une variable dans
le corps de l’algorithme estPair elle serait un paramètre formel).
• paramètre effectif que l’on nommera dans la suite du cours argument : il s’agit de la
variable (ou valeur) fournie lors de l’appel d’un algorithme (par ex : dans l’algorithme estPair
a en est un car c’est une valeur donnée à l’algorithme lors de son appel pour savoir si elle
est pair ou non).
On obtient sa valeur en substituant dans le corps de l’algorithme les arguments (par exemple
21) aux paramètres de l’algorithme (ici a) et en appliquant le corps substitué de l’algorithme
obtenu dans l’étape précédente ; la valeur résultat est celle donnée par l’instruction renvoyer.
1.2 Quelques mots sur le langage Pascal

Le langage de programmation Pascal1 a été inventé par Niklaus Wirth dans les années 1970.
C’est un langage de programmation dit impératif. Il a été conçu pour servir à l’enseignement de la
programmation de manière rigoureuse mais simple, il se caractérise par une syntaxe claire et facilitant
la structuration des programmes. C’est pourquoi, il vous sera demander d’écrire les différents al-
gorithmes en suivant la syntaxe de ce langage.
Aujourd’hui, lorsque l’on parle du langage Pascal, on l’associe au Turbo Pascal, créé par Borland
1
dont le nom vient du mathématicien français Blaise Pascal
3
en 1986. Mais attention, ce dernier n’est pas un langage de programmation, c’est un environnement de
dévolopement intégré2 assez complet pour le langage Pascal.
2
un EDI est un programme regroupant un éditeur de texte, un compilateur, des outils automatiques de fabrication,
et souvent un débogueur.
4
2 Structure d’un programme en Pascal
1. Déclaration du programme.
C’est l’entête du programme. Sa syntaxe est :
PROGRAM nom;
2. Déclaration des objets.
On déclare tous les objets utilisés dans le programme : constantes puis variables.
Sa syntaxe est :
CONST a=2;
vrai=TRUE;
VAR i,k,n : integers {i,k,n sont de types entier}
x,a,b : real {x,a,b de type réel}
test : boolean {variable de type booléenne : }
{ sa valeur est true ou false}
liste : array [1..10] of integer {variable de type tableau}
Remarque : Avant la déclaration des objets, si l’on utilise une bibliothèque particulière, il
faut l’indiquer avec la syntaxe suivante : uses la bibliothèque ;.
Les bibliothèques sont différentes en fonction de l’environnement utilisé et permettent d’uti-
liser des fonctions particulières.
Par exemple, afin de pouvoir effacer l’écran sous l’environnement DOS on inclut dans le pro-
gramme la bibliothèque crt. La fonction a utilisée dans le programme pour effacer l’écran est
alors : clrscr ;.
3. Définition des procédures et fonctions.
Les fonctions et procédures seront vues ultérieurment.
La structure d’un programme simple est : 1.2.4. ; celle d’un programme structuré comporte cette
3˚ partie.
4. Programme principal.
C’est le corps du programme : on liste les instructions à exécuter.
Sa syntaxe est :
BEGIN instructions END.
Sauf mention contraire, chaque ligne de commande et instruction se finit par un ;.
Afin de faciliter la lisibilité du programme, on peut y ajouter des commentaires pour expliquer
certaines instructions ou nom de variable. Ces commentaires peuvent être insérées n’importe où du
moment qu’ils sont placés entre accolades.
A noter que que le code source brut d’un programme Pascal peut porter les extensions3 .pas,
le plus courant, .p ou encore .pp.
3
L’extension d’un fichier est ce qui permet d’identifier son format, elle se situe après un ’.’ : par exemple image.jpg,
.jpg indentifie un fichier de type image de format jpeg dont le nom est image ou alors texte.txt qui correspond à
un fichier texte donc le nom est texte.
5
3 Objets et actions élémentaires
3.1 Les objets
Les objets sont des données constantes ou variables :
• une donnée constante est une donnée dont la valeur est fixée par le programmeur et qui reste
inchangée au cours de l’exécution du programme.
Un exemple important est la constante “chaı̂ne de caractères” (ou string) : ’bonjour’ ou
’rerevgeetr’ . . . Pour définir une chaı̂ne de caractères, il suffit de mettre une suite caractères à
l’intérieur de ’ ’.
• une donnée variable est une donnée dont la valeur est initialisée par le programmeur ; cette
valeur peut-être modifiée au cours de l’exécution du programme.
Tous ces objets vont avoir des noms définis par le programmeur : ces noms s’appellent des identi-
ficateurs. Ces derniers ne peuvent pas être des mots réservés, i.e. des mots dont la signification est
prédéfinie par le logiciel, tels que REAL, BEGIN, . . .
Il y a quelques règles supplémentaires : il ne peut y avoir ni espaces, ni lettres accentuées dans un
identificateur, et le premier caractère ne doit pas être un chiffre.
Le compilateur Pascal ne distinguant pas les majuscules des minuscules, les identificateurs IDEM, Idem,
iDEm, idem sont confondus.
Chaque identificateur devra être déclaré en 2. pour être compris.
3.1.1 Principaux types de données

• type entier : integer
Ils doivent être compris entre -32768 et +32767.
• type réel : real
• type booléen : boolean
Il définit deux valeurs logiques : vrai ou faux.
Exemple : Si x est connu, la variable (x > 0) est de type booléen.
• type tableau : array
Il faut alors préciser le type des éléments du tableau qu’il doit prendre en compte. On verra ce
type plus en détail dans une prochaine partie.
Cette liste correspond aux types qui nous serons utiles dans ce cours, à noter qu’il existe les types
caractères (char) et chaı̂ne de caractères (string).
3.1.2 Déclaration des objets et initialisation des variables

Comme on l’a vu précédemment, une donnée constante doit être déclarée en 2., et ce avant la
déclaration des variables. Sa syntaxe est :
const nom_de_la_constante_1 = valeur;
nom_de_la_constante_2 = valeur;
...
Exemple :
const a=100; {constante de type entier}
ch=’au revoir’; {constante de type cha^
ıne de caractères}
Les variables sont également déclarées en 2. (après la déclaration des constantes), et doivent être
initialisées en 4.. Pour les initialiser, il y a deux moyens possibles :
6
• pour les variables d’entrée : par lecture
Exemple :
writeln(’écrire les valeurs de a et b’);
Quand le programme s’exécute, il s’affiche sur l’écran : écrire les valeurs de a et b.
writeln() ; est une commande d’écriture.
readln(a,b);
les deux valeurs alors écrites par l’utilisateur sont affectées aux variables a et b. readln() ;
est une commande de lecture.
Remarques :
• On aurait pu utiliser les commandes write() ; et read() ; : la seule différence est que
dans ce cas, le curseur de l’écran d’affichage ne passe pas à la ligne suivante à la fin de la
commande : il n’y a pas de saut de ligne.
• Complément sur l’instruction write() :
L’instruction write(expression 1,...,instruction n) ; permet d’afficher une liste d’ex-
pressions (ici n expressions) sur l’écran de sortie du programme. Une expression peut être
un nombre, une variable numérique, le résultat numérique entre plusieurs variables, ou une
chaı̂ne de caractères quelconque (qui peut comporter des lettres accentuées et des espaces) :
dans ce dernier cas, il est nécessaire de mettre la chaı̂ne entre deux apostrophes.
• Complément sur l’instruction read() :
L’instruction read(x1 , . . . , xn ) ; permet d’affecter aux variables x1 , . . . , xn préalablement
déclarées, n données numériques entrées au clavier. Ces données doivent être séparées par
un caractère espace ou un retour à la ligne.
• pour les variables de sorties : par affectation
Exemple :
x := 1;
Ou si a et b ont déjà été initialisées :
x := (a+b)/2;
! Si l’on écrit a := b, il faut que les variables a et b soient de même type.
Ne pas confondre également le ’:=’ de l’affectation et le ’=’ réservé aux données
constantes et au symbole de comparaison.
3.2 Opération entre les objets

Ces opérations dépendent du type des objets.
! Les opérations sont à effectuer entre des objets de même type !
7
3.2.1 Opérateurs et fonctions arithmétiques
opérateurs entrée(s) sortie commentaires

+-* réel / entier réel / entier opérations élémentaires
/ réel / entier réel le type de sortie peut donc être différent du type d’entrée
div mod entier entier quotient et reste de la division euclidienne
exp ln sqrt réel / entier réel sqrt est la racine carrée
sqr réel / entier réel / entier carré
trunc réel entier partie entière
abs réel / entier réel / entier valeur absolue
round réel entier entier le plus proche
3.2.2 Opérateurs logiques

Il y en a 3 : not, or et and. Les entrées comme les sorties sont de type booléen.
Les tables de vérité suivantes donnent le résultat de ces opérations ; on notera V pour vrai, F pour faux.
x not x or V F and V F
V F V V V V V F
F V F V F F F F
3.2.3 Opérateurs relationnels

=, <> pour 6=, <= pour ≤, >= pour ≥.
Les variables d’entrées sont de type entier / réel ; la variable de sortie est de type booléen.
Ces opérations sont principalement utilisés dans les instructions conditionnelles (que l’on verra
ultérieurement).
8
4 Instructions et instructions conditionnelles
4.1 Instructions
Une instruction peut être simple, i.e. d’une seule commande : par exemple writeln(’bonjour’) ;
ou l’affectation d’une variable s := 0 ;.
Une instruction composée est une suite d’instructions terminées par un ’ ;’ : l’ensemble de ces instructions
doit alors commencer par un BEGIN et finir par un END ;.
! Le BEGIN .. END . du programme principal se termine par un ’.’ et non un ’ ;’.
Pour des raisons de lisibilité, on utilise très souvent une indentation en décalée :
BEGIN
instruction1 ;
instruction2 ;
instruction3
END ;
où instruction1, instruction2 et instruction3 peuvent être des instructions simples ou com-
posées.
Le point virgule est en fait un séparateur d’instructions : c’est pourquoi il n’est pas nécessaire d’en
insérer un à la fin de instruction3.
4.2 Instructions conditionnelles et if then else

Cette structure répond à l’attente :
“Si une relation est vraie (par exemple x 6= 0), alors on veut effectuer une certaine instruction (par
exemple diviser par x) et sinon, on en effectue une autre.”
la syntaxe est la suivante :
IF relation THEN
BEGIN
instructions B ;
END
ELSE
BEGIN
instructions C ;
END ;
instructions D ;
Remarques :
i. Si les instructions B ou C sont simples, le BEGIN END correspondant est inutile.
ii. Le ELSE est facultatif ; mais il ne doit pas être précédé immédiatement d’un ’ ;’.
9
5 Boucles itératives
5.1 Boucle for
Cette structure est utile pour répéter une suite d’instructions n fois, lorsque n est connu à l’avance.
La syntaxe est la suivante :
FOR i:=n TO m DO
BEGIN
instructions_B ;
END ;
instructions_C ;
On le lit de la manière suivante : “Pour i allant de n à m, faire. . .”. Remarques :

i. instructions B est effectué une première fois avec i = n, une deuxième avec i = n + 1, . . .,
puis une dernière avec i = m : le groupe d’instruction est exécuté m − (n − 1) fois. ! La

variable compteur i doit être déclarée en 2. !
ii. n et m sont deux variables de type entier, déclarées et initialisées.
iii. Si instructions B est simple le BEGIN END ; correspondant est inutile.
iv. Si n > m, instruction B n’est pas exécuté.
Variante :
Si l’on veut aller de m à n dans l’ordre décroissant, la syntaxe devient :
FOR i := m DOWNTO n DO ...
5.2 Boucles conditionnelles

5.2.1 Boucle while
Cette structure s’utilise lorsque l’on veut répéter une suite d’instructions tant qu’une certaine relation
est vraie. La syntaxe est la suivante :
instructions_A ;
WHILE relation DO
BEGIN
instructions_B ;
END ;
instructions_C ;
On le lit : “Tant que relation est vraie, faire. . .”. Remarques :

i. instructions B peut ne pas être exécuter du tout4 .
ii. Si instructions B est simple, le BEGIN END ; correspondant est inutile ;
iii. !Il faut s’assurer avant de lancer le programme que la relation devient fausse
au bout d’un certain temps, sinon le programme ne s’arrêtera jamais !
4
Si dès le départ la relation est fausse
10
5.2.2 Boucle repeat ... until
L’utilisation se fait lorsque l’on veut répéter une suite d’instructions jusqu’à ce qu’une relation soit
vraie (c’est à dire qu’un objectif soit atteint).
La seule différence avant la boucle while est que dans la boucle repeat, instructions B est exécuté
avant de tester la relation au mois une fois. La syntaxe devient :
instructions_A ;
REPEAT
instructions_B ;
UNTIL relation ;
instructions_C ;
On le lit : “Répéter . . . jusqu’à relation”. Remarques :

i. Même si instructions B n’est pas une instruction simple, le BEGIN END ; ici est inutile car
REPEAT UNTIL sert de délimiteur.
ii. ! Il faut s’assurer avant de lancer le programme que la relation devient vraie
au bout d’un certain temps, sinon le programme ne s’arrêtera jamais !
11
6 Fonctions et Procédures
6.1 Notion de sous-programme
La notion de sous-programme représente toute la puissance du langage Pascal. En fait, c’est la
possibilité de structurer encore davantage le programme en créant de nouveaux ordres utilisables dans
le corps du programme mais non définis dans celui-ci. Celà permet d’avoir un programme beaucoup plus
lisible puisque l’on décompose ainsi le programme en actions simples ou blocs d’instructions.
Le principe :
Il peut arriver que l’on doive utiliser une même séquence d’instructions à différents endroits d’un pro-
gramme. Il est alors judicieux de créer un sous-programme5 dont le code sera défini une fois pour toutes
dans l’étape 3., et que l’on appellera dans le corps du programme aux différents endroits souhaités.
L’avantage est que le code du programme est beaucoup plus court puisque l’on évite ainsi des répétitions
de code.
n!
Exemple : Le calcul de Cnk = k!(n−k)! nécessite le calcul de 3 factorielles ; donc on pourra écrire
une fonction factorielle en amont, et ensuite l’appeler 3 fois.
On doit pouvoir utiliser un sous-programme sans savoir ce qu’il se passe dedans : Les informations mises
à notre disposition sont les paramètres d’entrées et le résultat produit.
De même, un sous-programme ne doit pas savoir ce qui se passe à l’extérieur : son seul lien avec
l’extérieur sont ses paramètres d’entrées.
Un sous-programme a la même structure qu’une programme mais le END du corps du sous-programme
est suivi d’un ’ ;’ et non d’un ’.’. Il faut déclarer ces sous-programmes dans la partie 3., juste avant
le corps du programme principal. Toutes les variables utilisées dans un sous-programme doivent être
définies soit comme un paramètres d’entrée soit comme les variables locales6 .
Mais l’appel du sous-programme se fait dans le corps du programme (étape 4.)7 .
Il y a deux sortes de sous-programmes : les fonctions et les procédures.
6.2 Les fonctions

Une fonction est un sous-programme qui fournit un résultat à partir des données qu’on lui apporte : la
notion de fonction en Pascal est assez proche de la notion de fonction en mathématiques. Une fonction
se déclare comme suit :
FUNCTION Nom_de_la_fonction (Nom_du_parametre1 : Type_du_parametre1) : Type_sortie ;
Déclaration des éventuelles constantes ou variables LOCALES (via CONST, VAR)
BEGIN
Corps de la fonction (liste des instructions)
Nom_de_la_fonction := Valeur_sortie ;
END ;
Remarques :
i. Une fonction ne peut avoir en sortie que des valeurs “simples” (un réel, un entier, . . .)
ii. ! S’il y a plusieurs paramètres d’entrées dans une fonction, ils sont séparés
par un ’ ;’ mais lors de l’appel de la fonction ils seront séparés par une ’,’.
5
Fonction ou Procédure
6
Les variables du programme sont alors des variables globales
7
Un sous-programme peut utiliser d’autres sous-programmes si ceux-ci ont été définis avant, ou peut s’utiliser
soi-même : dans ce dernier cas on parle de sous-programme récursif.
12
6.3 Les procédures
Contrairement aux fonctions, la procédure ne fournit pas un résultat mais crée une action ou une suite
d’actions (instructions) : on utilisera les procédures principalement lorsqu’on manipulera des tableaux
(matrices ou autres). En effet, une fonction ne permet pas de modifier un tableau puisque son but est
de renvoyer une valeur.
Sa syntaxe reste analogue à la syntaxe d’une fonction :
PROCEDURE Nom_de_la_procedure (Nom_du_parametre1 : Type_du_parametre1) ;

Déclaration des éventuelles constantes et variables LOCALES
BEGIN
Corps de la procédure
END ;
Cette structure a une variante :
PROCEDURE Nom_de_la_procedure (VAR Nom_du_parametre : Type_du_parametre) ;
Quelle est la différence entre ces deux syntaxes ? Voyons ceci sur un exemple :
Exemple :
PROGRAM proc ;
var A : real ;
procedure P(x:real);
BEGIN
write(x);
x := x+1;
writeln(x);
END;
BEGIN
A:=5
P(A);
write(A);
END.
L’affichage est :
56
5
Une variable locale x est créée et elle prend la valeur 5 puis la valeur 6 et qui est ensuite détruite
à la fin de la procédure. Mais la variable A est inchangée.
Si maintenant la première ligne de la procédure est :
procedure P1(VAR x : real);
l’affichage devient :
56
6
En effet, lors de l’exécution de la ligne de commande P1(A) ; la variable locale x n’est plus créée,
c’est la variable A qui est utilisée pour faire les instructions. Après le traitement A est donc modifiée
et prend la valeur 6. Cette variante au niveau syntaxe permet de changer des variables globales.
Remarques :
13
i. On dira dans la première syntaxe, que le paramètre d’entrée passe par valeur8 , alors que
dans la deuxième syntaxe, il passe par variable9 .
ii. Dans un passage par valeur, le paramètre d’entrée peut être n’importe quoi du type défini :
P(5) ; a un sens.
Alors que dans un passage par variable, le paramètre d’entrée doit être nécessairement une
variable : ainsi dans l’exemple précédent, P1(5) ou P1(x+5) n’a aucun sens.
8
On n’utilise que la valeur A dans P
9
La variable A est utilisée et changée dans P
14
7 Les tableaux
L’utilité des tableaux :
• Pour stocker des données. Par exemple, pour stocker les résultats d’expériences aléatoires, avant
de les analyse ou dans la présentation de données retraçant un historique complet de l’évolution
discrète d’un paramètre.
• Pour travailler formellement sur les polynômes.
• Pour traiter des problèmes matriciels.
7.1 Déclarer un tableau

7.1.1 Tableau à une dimension
Avant de pouvoir utiliser un tableau, il faut le déclarer comme variable :
VAR tableau : ARRAY[deb..fin] OF (type);
Dans cette syntaxe, deb et fin sont de type integer, sous la contrainte deb ≤ fin. La variable
tableau est alors un tableau composé de colonnes numérotées de deb à fin. Ce tableau comportera
donc fin - deb + 1 cases, remplies par des éléments de type type. Chaque case du tableau est alors
une variable identifiée par tableau[i] (avec i un entier compris entre deb et fin).
Exemple : Les coordonées d’un point A du plan peuvent être représentées par le tableau
suivant :
VAR coordA : ARRAY[1..2] OF real;
coordA[1] donne l’abscisse du point A et coordA[2] l’ordonnée.
Exemple : Un polynôme P de degré au plus 10 à coefficients réels peut être représenté par le
tableau suivant :
VAR P : ARRAY[0..10] OF real;
Le polynôme P (x) = 1 + 2x + 4x3 + 5x6 − 3x9 est alors représenté par le tableau :
1 2 0 4 0 0 5 0 0 −3 0
Tandis qu’un polynôme Q de degré au plus 5 à coefficients entiers (relatifs) sera déclaré par :
VAR P : ARRAY[0..5] OF integer ;
7.1.2 Tableau de dimension supérieure

Il est possible de créer des tableaux à double entrée, et même à plusieurs entrées. En pratique, on
utilise le plus souvent des tableaux de dimension deux.
Exemple : Un tableau représentant une matrice A de M2,3 (R) sera déclaré par la syntaxe :
VAR A : ARRAY[1..2,1..3] OF real ;
15
7.2 Créer un type “tableaux”
Dans certains cas, il sera nécessaire de fabriquer un nouveau TYPE d’objet Pascal, afin de simplifier
la déclaration des tableaux utilisés et surtout de pouvoir appliquer des fonctions ou des procédures à
des tableaux.
Rappel 7.1. La syntaxe d’une fonction comme d’une procédure nécessite la connaissance du type
du paramètre d’entrée.
La déclaration d’un nouveau type se fait juste après la déclaration des constantes (dans la structure
général d’un programme) :
• déclarations des types :
TYPE polynome = ARRAY[0..10] OF real ;
• Ensuite, se fait la déclaration des variables :
VAR P,Q,R : polynome;
Dès que l’on a défini un tel type polynome, on peut appliquer une fonction ou une procédure à un
polynome.
! Il faut garder en mémoire qu’une fonction ne pourra jamais renvoyer un polynôme :
sa sortie ne peut être qu’un type simple.
Par contre, si la procédure fait un passage par variable, elle pourra changer la variable polynôme d’entrée.
Exemple : Lorsque l’on souhaitera travailler commodément avec plusieurs matrices de M3 (R), et
créer des fonctions et procédures s’y rapportant on procédera en déclarant :
TYPE matrice : ARRAY[1..3,1..3] OF real;

VAR A,B,C : matrice;
7.3 Opérations sur les tableaux

7.3.1 Opération globale
la seule opération global que Turbo-Pascal sait réaliser sur les tableaux est l’affectation en bloc
des valeurs d’un tableau dans un tableau identique (mêmes dimensions et type de contenu) : si R
et A sont deux tableaux, la commande : R := A ; remplace le contenu du tableau R par celui du tableau A.
Il n’existe aucune autre commande globale sur les tableaux !
7.3.2 Autres opérations

Compte tenu du peu d’opération globales disponibles, toutes les opérations portant sur les tableaux se
font case par case, donc en utilisant des boucles. Ce défaut engendre souvent des temps de traitement
important, en particulier pour les tableaux mult-indicés, ou de grande taille (en plus de la consommation
d’espace mémoire réservé pour la création de ces tableaux).
Tableaux à 1 dimension :
Exemple :
• Déclaration :
VAR T : ARRAY[1..50] of REAL ;
16
• Déclaration du type :
TYPE tab = ARRAY[1..50] of REAL ;
VAR T : tab ;
• Initialiser la 15-ièmme case de T à 0 :
T[15] := 0 ;
• Initialiser la 18-ième case de T à une valeur entrée par l’utilisateur :
WRITELN(’Entrer la valeur de la case 18’);
READLN(T[18]);
• Afficher la valeur de la case 25 du tableau :
WRITELN(T[25]);
• Initialiser tout le tableau T à 0 :
FOR k := 1 TO 50 DO T[k] := 0 ;
• Initialiser tout le tableau T à des valeurs entrées par l’utilisateur :
FOR k := 1 TO 50 DO
BEGIN
WRITELN(’Entrer la valeur de la case ’,k);
READLN(T[k]);
END ;
• Afficher la valeur de tout le tableau :
FOR k := 1 TO 50 DO WRITELN(T[k]) ;
Tableaux à 2 dimensions :
Exemple :
• Déclaration :
VAR U : ARRAY[1..50,1..40] of REAL ;
• Initialiser la case située à la 11-ième ligne et 23-ième colonne de U à 0 :
U[11,23] := 0 ;
• Initialiser la case située à la 8-ième ligne et 27-ième colonne de U à une valeur entrée par
l’utilisateur :
WRITELN(’Entrer la valeur de la case 8,27’);
READLN(T[8,27]);
• Afficher la valeur de la case (25,17) du tableau :
WRITELN(T[25,17]);
• Initialiser tout le tableau U à 0 :
FOR i := 1 TO 50 DO
FOR j := 1 TO 40 DO
U[i,j] := 0 ;
• Initialiser tout le tableau U à des valeurs entrées par l’utilisateur :
FOR i := 1 TO 50 DO
FOR j := 1 TO 40 DO
BEGIN
WRITELN(’Entrer la valeur de la case (’,i,j,’)’);
READLN(U[i,j]);
END ;
• Afficher la valeur de tout le tableau :
FOR i := 1 TO 50 DO
FOR j := 1 TO 40 DO WRITELN(U[i,j]) ;
17
Chapitre 10 : Les pointeurs en Pascal
1. Généralités
Jusqu'à présent la représentation d'un groupe de données de même nature (même type) n'est possible
qu'au moyen des tableaux. Or leur facilité d'utilisation peut être fortement réduite lorsque :
a) la structure séquentielle d'un tableau ne reflète pas l'organisation globale des données comme
par exemple : les liaisons ferroviaires ou routières entre les différentes gares ou villes d'une région ;
tout arbre de calcul.
En effet un tableau peut difficilement refléter les successeurs ou prédécesseurs d'une donnée, les
relations existantes entre certaines données.
b) le nombre maximal d'éléments du tableau n'est pas connu à la compilation (ne peut pas être
fixé par le programmeur), à savoir
- si ce nombre est choisi trop petit le programme ne pourra représenter et traiter toutes les
données ;
- s'il est pris (beaucoup) trop grand le gaspillage de mémoire peut pénaliser non seulement le
fonctionnement du programme mais aussi celui du système informatique entier.
On a besoin d’une structure plus souple pour manipuler les données, pour cela nous allons étudier un
autre moyen d’y accéder : les pointeurs.
2. Notions de zones mémoires
• zones mémoires utilisées par l’exécution d’un programme
Un programme qui s’exécute utilise au moins deux zones mémoires, appelées segments :
• Le segment de code : contient les instructions du programme;
• Le segment de données : contient les données utilisées par le programme.
Le segment de données est découpé en trois parties :
• la zone statique : contient les variables statiques, c’est-à-dire les variables ayant une durée de vie
égale à celle du programme : c’est le cas des variables globales.
• la pile : sert à gérer les éléments du programmes dont la durée de vie est limitée à un bloc : c’est le
cas des paramètres des appels de fonctions/procédures, des variables locales. Elle sert également à
renvoyer les résultats des fonctions.
• le tas : tout ce qui reste... Un programme ne peut accéder directement aux emplacements du tas. Par
contre, on peut allouer des emplacements dans le tas et les référencer ensuite à l’aide de pointeurs.
La gestion du tas est à la charge du programmeur.
3. Pointeurs : déclaration et allocation
Un pointeur permet de représenter des données complexes, de modifier le contenu d’une variable, de
travailler directement sur le contenu de la mémoire en utilisant le principe de l’allocation dynamique.
Un pointeur est ni plus ni moins un moyen d’accéder indirectement à une variable : au lieu d’accéder à
celle-ci, on passe par le pointeur qui nous dirige vers celle-ci.
4. Pointeurs : utilisation sans allocation
• Pointeurs : la valeur < nil >
• Pointeurs : comparaison et affectation
❖ Pointeurs : résumé des notions de base
5. Les structures récursives

Une structure récursive est une structure dont l’un des champs est du type de la structure.
La définition suivante n’est cependant pas correcte :
❖ La liste simplement chainée
❖ Liste chainée : insertion
❖ Liste chainée : suppression
Conclusion

Support de Cours Algorithmique

Uploaded by

Copyright:

Available Formats

You might also like

Support de Cours Algorithmique

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Support de Cours Algorithmique

Uploaded by

Copyright:

Available Formats

Catalogue

1. Les types de données de base

En algorithmique, on distingue cinq types de base:

- chaîne de caractères (suite de 0 ou plusieurs caractères)

- entier (les nombres entiers positifs ou négatifs)

- réel (les nombres réels positifs ou négatifs)

2. Notions de variable et de constante

Une variable est caractérisée par

La valeur d’une variable peut être modifiée durant l'exécution du programme.

2-3. Déclaration des variables et des constantes

Toute variable ou constante doit être déclarée avant sa première utilisation.

2-3-1. Déclaration d'une variable

La déclaration d’une variable consiste à la réservation d’un emplacement mémoire, auquel on

La syntaxe de déclaration d’une variable est:

2-3-2. Déclaration d'une constante

La syntaxe de déclaration d’une constante est:

identificateur : type = valeur

MAX : entier = 32767

3. Structure générale d’un algorithme

Programme nom du programme

Définition de sous programmes

4. Les opérations de l’algorithmique

opérateur ou mot clé

successeur, prédécesseur, ordre, suc, pred, ord, car,

booléen VRAI , FAUX négation, conjonction , disjonction NON , ET , OU

Une expression est:

6. Les expressions conditionnelles

6-1. Les conditions simples

6-2. Les conditions complexes

( (a +3 = = b) ET (c < 0) ) OU ( (a = = c *2) ET (b c) )

7. Les instructions de base

Les instructions élémentaires les plus courantes sont :

L'instruction d’affectation est formée de deux parties :

L’instruction d’affectation agit en deux temps :

Lire(variable1 , variable2, …, variableN)

L'instruction d'écriture permet d'afficher des expressons à l'écran.

Ecrire(expression1, expression2, ..., expressionN)

Ecrire("Voici les résultats : x = ", x, " et y = ", y)

Ecrire("Donner la valeur de l'entier y:")

Ecrire("Avant échange: x vaut ",x, "et y vaut ",y)

Ecrire("Après échange: x vaut ",x, "et y vaut ",y)

CHAPITRE 3: LES STRUCTURES ALGORITHMIQUES DE CONTROLE ET

3- La structure conditionnelle généralisée

II. LES STRUCTURES DE CONTROLE ITERATIVES

Syntaxe en algorithmique Syntaxe en Pascal

Action 1 : initialiser le compteur de la boucle Cp à la borne Vi

Ecrire un algorithme d’un programme qui permet de remplir un tableau T par N

2- Les structures de contrôle itératives à condition d’arrêt

La structure REPETER…JUSQU'A est représentée comme suit :

Syntaxe en algorithmique Syntaxe en Pascal

ii. La structure TANTQUE…FAIRE

Le principe de fonctionnement de cette boucle est simple : Quand le programme atteint la

Syntaxe en algorithmique Syntaxe en Pascal

1. Traduire l’algorithme cet algorithme en pascal et enregistrez le programme source

Exemple : si la suite saisie est 5, 6, 7, -4, -1 la valeur affichée est 14

d’outils ou il pourra être utilisé par n’importe quel programme.

4°) Procédure et fonction :