INITIATION_ALGO_NAB_2006

SOMMAIRE
AVERTISEMENT..................................................................................................................................4
AVANT PROPOS .................................................................................................................................4
I. GÉNÉRALITÉS...................................................................................................................................5
I.1. algorithmique.................................................................................................................................5
I.2. algorithme .....................................................................................................................................5
I.3. Notion d’analyse descendante.......................................................................................................5
I.4. Rôle et intérêt de l’algorithme......................................................................................................6
I.5. La programmatique........................................................................................................................6
I.6. programmation...............................................................................................................................6
I.7. Architecture d’un algorithme........................................................................................................7
II. NOTION D’OBJET..........................................................................................................................10
II.1. Caractéristiques..........................................................................................................................10
II.2. constante.....................................................................................................................................10
II.3. Variable .....................................................................................................................................11
II.4. Les types.....................................................................................................................................11
III. ACTIONS .......................................................................................................................................13
III.1. Instructions................................................................................................................................13
III.2. Opérateurs.................................................................................................................................14
III.3. Exercice d’application .............................................................................................................15
IV. STRUCTURES DE CONTRÔLE...................................................................................................17
IV.1. les structure de choix................................................................................................................17
IV.2. Les structures répétitives ou boucles........................................................................................20
V. LES SOUS-PROGRAMMES...........................................................................................................22
V.1. Les procédures...........................................................................................................................22
V.2. Fonctions....................................................................................................................................24
V.3. différences entre fonctions et procédures...................................................................................25
V.4. Imbrication de sous programmes...............................................................................................25
25
VI. NOTION DE RÉCURSIVITÉ.........................................................................................................26
VI.1. Définition..................................................................................................................................26
VI.2. Types de récursivité..................................................................................................................26
VI.3. Construction..............................................................................................................................26
VII. LES STRUCTURES DE DONNEES STATIQUES.....................................................................28
VII.1. Les chaînes de caractères.........................................................................................................28
VII.2. Le type énuméré......................................................................................................................30
VII.3. Le type intervalle.....................................................................................................................31
VII.4. type ENSEMBLE....................................................................................................................33
VII.5. Type TABLEAU.....................................................................................................................35
VII.6. type ENREGISTREMENT.....................................................................................................38
VIII. LES FICHIERS.............................................................................................................................43
VIII.1. Définition...............................................................................................................................43
VIII.2. Caractéristiques d’un fichier..................................................................................................44
VIII.3. mode d'accès..........................................................................................................................44
VIII.4. Déclaration.............................................................................................................................44
VIII.5. Instructions sur les fichiers.....................................................................................................45
IX. LES STRUCTURES DE DONNEES DYNAMIQUES..................................................................47
Introduction.......................................................................................................................................47
IX.1. Notion d’adresse en mémoire...................................................................................................47
IX.2. Définition d’un pointeur ..........................................................................................................47
IX.3. utilité.........................................................................................................................................48
Algorithmique --- Cours réalisé par Nabeledi Ingénieur Informaticien Développeur Web ---- 1ère
Edition - 2 -

IX.4. Les différents types de pointeurs..............................................................................................48
IX.5. L’affectation à un pointeur.......................................................................................................48
IX.6. Les différentes opérations sur un pointeur................................................................................50
IX.7. Les procédures de construction de structures de données dynamiques ...................................50
IX.8. Exercice d’application..............................................................................................................54
IX.9. remarques..................................................................................................................................55
IX.10. Domaines d’application des pointeurs....................................................................................55
X. LES LISTES CHAINEES.................................................................................................................56
X.1. Définition...................................................................................................................................56
X.2. création d’une liste chaînée .......................................................................................................56
X.3. Les différentes opérations sur les listes chaînées.......................................................................57
X.4. Les piles.....................................................................................................................................58
X.5. Les files......................................................................................................................................59
X.6. Les listes doublement chaînées..................................................................................................59
XI. INTRODUCTION AUX ARBRES.................................................................................................61
XI.1. Introduction...............................................................................................................................61
XI.2. Définitions................................................................................................................................61
XI.3. Arbre localement complet, dégénéré, complet.........................................................................66
XI.4. Implémentation.........................................................................................................................67
XI.5. signature....................................................................................................................................68
XI.6. Les fonctions de base sur la manipulation des arbres...............................................................68
XI.7. Algorithmes de base sur les arbres binaires..............................................................................69
XI.8. Parcours d'un arbre...................................................................................................................71
XI.9. Opérations élémentaires sur un arbre........................................................................................76
Edition - 3 -

AVERTISEMENT
Cet ouvrage s’adresse aux étudiants des filières technologiques et à tous ceux qui sont
passionnés de la programmation informatique.
Pour toutes vos remarques et suggestion contactez
nabeledi@yahoo.fr
AVANT PROPOS
Ceux qui auront des notions poussées en programmation et donc en algorithmique
gouverneront le monde des TICs. C’est pour nous y aider que cette première édition a vu le
jour.
Une simple lecture ne pourra pas suffire.
Votre détermination et assiduité feront de vous un chevronné.
En attendant la future édition complète intégrant des exercices, bon apprentissage à tous.
INTRODUCTION
Avez-vous déjà ouvert un livre de recettes de cuisine ? Avez-vous déjà déchiffré un mode
d’emploi traduit directement du coréen pour faire fonctionner un magnétoscope ou un
répondeur téléphonique réticent ? Si oui, sans le savoir, vous avez déjà exécuté des
algorithmes.
Plus fort : avez-vous déjà indiqué un chemin à un touriste égaré ? Avez-vous fait chercher
un objet à quelqu’un par téléphone ? Ecrit une lettre anonyme stipulant comment procéder à
une remise de rançon ? Si oui, vous avez déjà fabriqué – et fait exécuter – des algorithmes.
Comme quoi, l’algorithmique n’est pas un savoir ésotérique réservé à quelques rares initiés
touchés par la grâce divine, mais une aptitude partagée par la totalité de l’humanité. Donc,
pas d’excuses…
Un algorithme, c’est une suite d’instructions, qui une fois exécutée correctement, conduit à
un résultat donné. Si l’algorithme est juste, le résultat est le résultat voulu, et le touriste se
retrouve là où il voulait aller. Si l’algorithme est faux, le résultat est, disons, aléatoire, et
décidément, cette saloperie de répondeur ne veut rien savoir.
Complétons toutefois cette définition. Après tout, en effet, si l’algorithme, comme on vient de
le dire, n’est qu’une suite d’instructions menant celui qui l’exécute à résoudre un problème,
pourquoi ne pas donner comme instruction unique : « résous le problème », et laisser
l’interlocuteur se débrouiller avec ça ? A ce tarif, n’importe qui serait champion
d’algorithmique sans faire aucun effort. Pas de ça, ce serait trop facile.
Le malheur (ou le bonheur, tout dépend du point de vue) est que justement, si le touriste
vous demande son chemin, c’est qu’il ne le connaît pas. Donc, si on n’est pas un goujat
intégral, il ne sert à rien de lui dire de le trouver tout seul. De même les modes d’emploi
contiennent généralement (mais pas toujours) un peu plus d’informations que « débrouillez
vous pour que ça marche ».
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions
compréhensibles par celui qui devra l’exécuter. C’est d’ailleurs l’un des points délicats pour
les rédacteurs de modes d’emploi : les références culturelles, ou lexicales, des utilisateurs,
étant variables, un même mode d’emploi peut être très clair pour certains et parfaitement
abscons (obscurs) pour d’autres.
En informatique, heureusement, il n’y a pas ce problème : les choses auxquelles on doit
donner des instructions sont les ordinateurs, et ceux-ci ont le bon goût d’être tous
strictement aussi idiots les uns que les autres.
Edition - 4 -

I. GÉNÉRALITÉS
I.1. algorithmique
On appelle algorithmique la science de l’informatique qui s’appesantit sur les méthodes qui
permettent de construire des algorithmes. C’est la discipline qui permet d’édicter les règles,
d’élaborer les méthodes à observer pour concevoir un algorithme.
De ce fait l’algorithmique se penche sur :
 la clarté
 la lisibilité
 le caractère non ambigu de l’algorithme.
I.2. algorithme
Le terme ALGORITHME vient du mathématicien arabe MUHAMMAD IBN MUSA AL
KHAREZMI (fin VIIIè siècle, début IX siècle) qui rédigea un traité exhaustif sur le système de
chiffres et de numérotation hindou.
Par la suite l’utilisation des chiffres et des modes de calcul hindou fut connue sous le nom
d’ALGORISMI.
Selon Le Petit Robert, Nouvelle édition revue de 1986, c’est l’ensemble des règles
opératoires propres à un calcul ; c’est aussi l’enchaînement des actions nécessaires à
l’accomplissement d’une tâche.
On dirait encore qu’un algorithme est la description précise et rigoureuse d’une suite
d’opérations permettant d’obtenir la solution d’un problème en un nombre fini d’étapes.
I.3. Notion d’analyse descendante
Soit T un travail décrit par un énoncé non primitif. On peut analyser et découper T en
plusieurs sous travaux, ti (avec 1 ≤ i ≤ n).
Puis, chaque t i peut être aussi analysé et découpé en sous travaux : ti k où
tik [1,2 ;… ;m ] et m est le nombre de sous travaux issus de ti
Une telle analyse qui consiste à décomposer les problèmes en sous problèmes pouvant se
résoudre est appelée : analyse descendante
En amont de toute programmation se trouve nécessairement un problème. En fait, c’est
l’idée de résoudre le problème en utilisant l’ordinateur qui amène la programmation. Pour
mieux appréhender un problème à résoudre, il y a des étapes à franchir.
L’analyse d’un problème consiste donc à :
- énoncer le problème,
- le poser,
- en décrire le cheminement pour sa résolution.
I.3.1. Enonciation du problème
Elle consiste à répertorier :
− toutes les données
− les situations initiales et aussi
− les résultats.
C’est donc comprendre clairement le problème à résoudre. Il faut donc pouvoir répondre aux
trois questions suivantes :
− De quoi est-il question dans le problème ?
Edition - 5 -

− Quels sont les éléments contenus dans le problème qui le prouvent et à utiliser pour
sa résolution ?
− Quelle est la finalité du problème ?
I.3.2. Poser le problème
C’est décrire les grandes lignes de la résolution du problème posé, c'est-à-dire passer des
données aux résultats tout en respectant les hypothèses de travail.
En d’autres termes dégager les grandes lignes de la résolution du problème.
I.3.3. Le cheminement
Il s’agit de décrire de façon détaillée et non ambigue, les différentes étapes pour passer des
données aux résultats tout en respectant les hypothèses de travail.
C’est le lieu de résolution du problème posé.
Ces différentes étapes doivent être exprimées dans un langage naturel (anglais, français,
arabe…) mais non intelligible à l’ordinateur. On l’appelle : ALGORITHME.
I.4. Rôle et intérêt de l’algorithme
o Dans le domaine de la programmation, l’algorithme a un rôle fondamental. En réalité,
il n’y pas de programme sans algorithme.
(Le programme étant la traduction de l’algorithme dans un langage compréhensible par
l’ordinateur : langage de programmation).
o L’algorithme est indépendant à la fois de l’ordinateur qui l’exécute (à travers les
programmes) et des langages de programmation dans lesquels il est énoncé et traduit. Cela
signifie que lorsque vous écrivez votre algorithme, vous ne deviez pas vous soucier du
langage dans lequel celui-ci sera traduit et de l’ordinateur sur lequel ce dernier sera traduit
et exécuté .En d’autres termes nous dirons que :
il n’y a pas d’algorithme spécialement écrit pour tel ou tel langage et
il n’y a pas d’algorithme spécialement écrit pour tel ou tel ordinateur.
I.5. La programmatique
C’est l’art de programmer et de permettre la réalisation de bons programmes c’est-à-dire
des programmes qui tournent, qui s’exécutent sans problème et qui respectent les critères
suivants :
1. L’absence d’erreur
2. Conformité aux spécifications données
3. Efficacité de fonctionnement du programme
4. La robustesse (aptitude à bien réagir lorsqu’on s’écarte des conditions normales
d’utilisation c’est-à-dire lors de l’acquisition des données, veuillez à ce que les données
saisies soient conformes aux spécifications du problème, (Ex : lors de la saisie de l’âge des
personnes, il faut s’assurer que la valeur saisie par l’utilisateur ne soit pas négative).
5. L’efficience : Minimiser le temps d’exécution du programme et aussi l’espace occupé en
mémoire centrale.
I.6. programmation
Un programme est un assemblage et un enchaînement d’instructions élémentaires écrit
dans un langage de programmation, et exécuté par un ordinateur afin de traiter les données
d’un problème et renvoyer un ou plusieurs résultats.
Il y a trois (trois) types de langages qui ont été connus dans l’histoire des langages.
Edition - 6 -

- Le langage machine ;
- Le langage assembleur
- Les langages évolués.
I.6.1. Le langage machine
C’est le seul langage directement intelligible à l’ordinateur. On l’appelle encore langage
binaire.
En effet toutes les tâches à réaliser sont communiquées à l’ordinateur sous forme de
combinaisons de bits : (une suite de 0 et de 1).
I.6.2. Le langage assembleur
Langage plus évolué que le langage machine, il reste toujours difficile pour l’homme (en
décimal ou hexadécimal)
I.6.3. Le langage évolué
Langage de programmation ou de développement plus au moins proche du langage
humain.
Exemple : Pascal…
Un langage de programmation est défini par des règles d'écriture des règles de construction
que doivent respecter les programmes. La difficulté, pour le programmeur, consiste à
respecter ses règles imposées.
I.7. Architecture d’un algorithme
Historiquement, plusieurs types de notations ont représenté les algorithmes.
I.7.1. Organigramme
Représentation de l’algorithme sous forme graphique avec des carrés, des losanges, des
rectangles etc.
Edition - 7 -
Début ou Fin de l’Organigramme
ENTREE ou SORTIE
Instructions : traitement d’une ou plusieurs opérations sur des
données
Branchement conditionnel

Aujourd’hui, cette représentation est quasiment abandonnée, parce que dès que l’algorithme
commence à grossir un peu, elle n’est plus pratique du tout.
I.7.2. Pseudo code ou langage de description algorithmique
Une série de conventions, qui ressemble à un langage de programmation authentique dont
on aurait évacué la plupart des problèmes de syntaxe. Ce pseudo-code est susceptible de
varier légèrement d’un livre (ou d’un enseignant) à un autre. C’est bien normal : le pseudo-
code, encore une fois, est purement conventionnel ; aucune machine n’est censée le
reconnaître. Donc, chaque cuisinier peut faire sa sauce à sa guise, avec ses petites épices
bien à lui, sans que cela prête à conséquence.
Comme je n’ai pas moins de petites manies que la majorité de mes semblables, les pseudo-
codes que vous découvrirez dans les pages qui suivent possède quelques spécificités
mineures dues à mes névroses personnelles.
Rassurez-vous cependant, celles-ci restent dans les limites tout à fait acceptables.
En tout cas, personnellement, je les accepte très bien.
La construction de la structure syntaxique d’un algorithme est gouvernée par un certain
nombre de règles qu’il faut connaître
Ainsi un algorithme est structurellement subdivisé en trois parties dont l’ordre immuable est
suivant :
− l’en-tête, ensuite
− la partie déclarative et enfin
− le corps de l’algorithme.
1. L’en-tête
On l’appelle encore nom de l’algorithme car c’est le nom que l’on donne à l’algorithme. Il est
obligatoire c’est-à-dire que tout algorithme doit nécessairement avoir un nom.
Ce nom est au choix mais doit être soumis à un certain nombre de principes (comme les
noms de variables).
2. La partie déclarative
C’est dans cette partie que l’on déclare :
− les constantes
− les variables
− les structures de données
− les fonctions
− les procédures.
Cette partie dépend de la nature du problème et des besoins de l’utilisateur. Elle est donc
facultative.
Edition - 8 -
Impression

Ainsi, si la résolution d’un problème donné nécessite l’utilisation d’une variable alors, l’on
déclarera une variable. Autrement une variable ne sera pas déclarée. Il en va de même pour
les autres (constantes, structures de données…).
3. Le corps de l’algorithme
Il est obligatoire. Il débute par le mot clé DEBUT et se termine par le mot clé FIN.
(instructions d’encadrement)
C’est dans cette partie que l’on effectue les différentes actions nécessaires pour la
résolution du problème, bien sûr en utilisant les éléments déclarés éventuellement dans la
partie déclarative.
4. Schéma de la structure syntaxique d’un algorithme
ALGORITHME nom algorithme } En-tête
-------------------------------
------------------------------- Partie déclarative
-------------------------------
__________________________________________
DEBUT Instruction d’encadrement
__________________________________________
Instruction1
Corps de l’algorithme
Instruction n
__________________________________________
FIN. Instruction d’encadrement
__________________________________________
NB : Une instruction est une action élémentaire que l’on effectue en vue de la résolution
d’un problème, dans le cadre de la construction d’un algorithme.
I.7.3. trace d'un algorithme
La trace d'un algorithme représente la valeur des différentes informations d'un programme
durant son exécution. Il est vivement conseillé d'effectuer la trace d'un algorithme afin de
vérifier qu'il fonctionne.
La première chose à faire est de choisir des données sur lesquelles ont va effectuer le test
de l'algorithme. Pour ces données, on calcule à la main le résultat attendu. Puis on effectue
la trace et on compare le résultat attendu avec le résultat de la trace qui doivent être les
mêmes (sinon, il y a une erreur quelque part…)
Edition - 9 -

II. NOTION D’OBJET
II.1. Caractéristiques
Un objet est une donnée qui intervient dans l’environnement d’un problème (l’environnement
d’un problème est l’ensemble des éléments nécessaires à la résolution du problème).
Un objet est parfaitement défini si nous connaissons ces trois caractéristiques suivantes :
II.1.1. Son identificateur ou son nom
C’est le nom donné à l’objet par le programmeur. Il est représenté par une suite de
caractères alphanumériques (des nombres et des lettres alphabétiques sans espacement)
commençant obligatoirement par une lettre de préférence.
Il est choisi par rapport au contenu de l’objet.
Exemples
Note, age, CodeEtudiant, San_pedro
Remarque
Un identificateur ne doit pas contenir d’espace et de caractères accentués
Eviter les mots réservés
Faux Vrai Sortir Autre
Boucle Tant que Caractère Booléen
Entier Réel Lire Etre
Type Vaut Sinon Non
Début Retourner Enregistrement Ou
Fin Cas Pour Quitter
Répéter Jusqu'à Tableau Programme
Fonction Alors Ecrire Procédure
Si Nil Vide Dag
Ensemble De Constant Chaîne
Div Mod Dad Xou
II.1.2. Sa valeur
C’est ce que vaut l’objet à un instant donné. On parle aussi de son contenu.
II.1.3. Son type
C’est l’intervalle des différentes valeurs que l’objet peut prendre. Ainsi suivant le type qu’on
va lui attribuer, l’objet pourra prendre telles valeurs ou non.
Le type d’une variable détermine les valeurs qu’elle peut prendre, les opérations dont elle
peut faire l’objet et son encombrement mémoire.
II.2. constante
II.2.1. Définition d’une constante
C’est un objet dont la valeur ou contenu ne change pas au cours du traitement, durant
l’exécution du programme, d’où le terme de « constante »
II.2.2. Sa déclaration
Elle est précédée par le mot-clé CONST.
Edition - 10 -

CONST
Nom-de-la-constante = valeur
NB
Une constante a 2 attributs :
Son identificateur ou nom
Sa valeur (son contenu)
Exemple
L’objet masse atomique de l’oxygène est une constante à laquelle on associe l’identificateur
MO2 de valeur 16.
II.3. Variable
II.3.1. Définition d’une variable
Une variable est un objet dont la valeur ou contenu est susceptible de varier durant
l’exécution du programme d’où le terme de variable
II.3.2. Sa déclaration
Elle est précédée par le mot-clé VAR
VAR
Nom_de_la_variable : type- de- la- variable
Exemple
VAR
Val : ENTIER
a : REEL
NB. Une déclaration de variables consiste en une liste d’identificateurs désignant les variables et le
type auquel chacune d’elles est associée
II.4. Les types
On distingue deux principaux types de variables : les types scalaires ou types simples et les
types structurés.
II.4.1. Types scalaires
Ce sont les types dits simples car à un instant donné une variable de ce type contient une et
une seule valeur
a. Le type entier
Ce sont les entiers relatifs
Au niveau du langage pascal un type entier a une plage de -32768 à +32767
2. Le type réel
Ce sont les nombres réels
Ici c’est en informatique c’est un intervalle borné
Edition - 11 -

Dans la plus part des langages on a :
Réel simple -3,40x1038 à -1,40x1045 pour les valeurs négatives 1,40x10-45 à 3,40x1038
pour les valeurs positives
Réel double -1,79x10308 à -4,94x10-324 pour les valeurs négatives 4,94x10-324 à
1,79x10308 pour les valeurs positives
3. Le type caractère
Ce sont les 256 symboles du code ASCII et chaque symbole est représenté entre cotes
Exemple
‘’A’’ , ‘’p’’ ,’’1’’
4. Le type chaîne de caractères
Ce type de variable est construit à partir de plusieurs caractères
Exemple
chaine= ‘’une chaîne qui contient plusieurs caractères ’’
5. Le Type booléen
Le dernier type est le type booléen : on y stocke uniquement les valeurs logiques VRAI et
FAUX.
On peut représenter ces notions abstraites de VRAI et de FAUX par tout ce qu'on veut : de
l'anglais (TRUE et FALSE) ou des nombres (0 et 1). Peu importe. Ce qui compte, c'est de
comprendre que le type booléen est très économique en termes de place mémoire occupée,
puisque pour stocker une telle information binaire, un seul bit suffit.
Remarque
Tous ces types scalaires cités sont des types prédéfinis dans la plupart des langages (le
programmeur ne fait qu’en servir)
II.4.2. Types structurés
Ce sont des types bâtis par le programmeur à partir des types simples. Ils correspondent à
des variables qui à un instant donné contiennent plusieurs valeurs.
− Type tableau
− Type chaîne de caractères
− Type enregistrement
− Type ensemble
− Type intervalle
− Type énuméré
− Type fichier
− Type pointeur
− liste chainée
− arbre
Edition - 12 -

III. ACTIONS
III.1. Instructions
III.1.1.Définition
Une action est une directive ou un événement qui modifie l’environnement de résolution d’un
problème.
On peut exécuter une action plusieurs fois.
Une instruction est une action élémentaire.
III.1.2.L’instruction d’affectation : 
C’est l’opération qui consiste à attribuer une valeur à un objet donné.
Syntaxe
Nom _objet  valeur
Nom _objet  expression
Nom _objet1 nom_ objet2
III.1.3.Les instructions d’entrée et de sortie
a. L’instruction d’entrée
Elle permet de ranger, de mémoriser la valeur que l’on vient de saisir, en vue d’un usage
ultérieur. Elle permet de communiquer des données à la mémoire de l’ordinateur : Les
vocables utilisés sont SAISIR, LIRE, ENTRER.
Syntaxe
SAISIR (nom _variable)
LIRE (nom_variable) ou
ENTRER (nom_variable)
2. L’instruction de sortie
Elle permet (à l’algorithme ou programme) d’afficher des informations à l’écran de
l’ordinateur afin que l’utilisateur puisse en prendre connaissance. Les vocables utilisés sont
AFFICHER, ECRIRE ; SORTIR.
Syntaxes
On a trois syntaxes possibles :
Syntaxe 1
AFFICHER (‘information à afficher’)
// pour afficher une simple information à l’écran
Syntaxe 2
AFFICHER (nom_variable) // pour afficher la valeur d’une variable.
Syntaxe 3
AFFICHER (‘Information à afficher’, nom_variable)
// pour afficher une information et la valeur d’une variable.
NB.
-Tout message à afficher est entre quotes ‘ ‘
Edition - 13 -

- Les variables dont on désire afficher les valeurs ne sont pas entre ‘ ‘, des
apostrophes.
- Il faut séparer les contenus des apostrophes des autres, par une virgule.
III.2. Opérateurs
III.2.1.Opérateurs arithmétiques
Ces opérateurs sont utilisés dans les expressions de calculs arithmétiques avec des
opérandes de types numériques
opérateurs significations
+ Addition
- Soustraction
* Multiplication
/ Division décimale
Div Division entière
Mod Reste de la division entière
III.2.2.Opérateurs relationnels
Ces opérateurs sont utilisés dans les structures de choix ou conditionnelles
= égalité
> supériorité
< infériorité
>= Supériorité large
<= Infériorité large
<> Différence
III.2.3.Opérateurs logique
les opérateurs logiques ne font intervenir que des opérandes logiques ou booléens ou des
expressions dont le résultat est booléen
ET intersection
OU union
XOU Ou exclusif
NON complément
Exercice
Compléter les tables de vérité suivantes :
III.2.4.Opérateur de concaténation
Cet opérateur permet de concaténer deux (2) chaines de caractères
Edition - 14 -
Table1
L1(a>b)
a b L1
3 4
47 11
‘sanp’ ‘sans’
Table 2
L1 L2 L1 et L2 L1 ou L2 Non L1
V V
V F
F V
F F

Il est désigné par le caractère ‘&’ ou ‘+’.
Exemple
A  ‘san’
B ‘Pedro’
C  A & B
// La variable C a pour valeur ‘ sanPedro’
III.3. Exercice d’application
On donne deux nombres entiers quelconques. Ecrivez un algorithme qui permet de saisir
les deux nombres, de calculer leur somme et de l’afficher à l’écran.
CORRECTION
Notre rédaction comportera trois grandes phases :
− la description des ressources
− la description des actions
− l’écriture de l’algorithme.
III.3.1.La phase de la description des ressources
Ici, il s’agira de faire :
Un inventaire nominatif des données (objets) qui seront manipulées par le processeur que
ce soit : en entrée, en interne ou en sortie.
Puis d’indiquer le type et la nature de ces données ; enfin d’en faire un commentaire
succinct.
Application de l’exercice
Rôle de la
variable
Identificateur
ou nom
Type nature Commentaires
Entrée X, Y entier variable Les deux valeurs numériques
à entrer au clavier
Sortie SOM entier variable Résultat de la somme des
deux nombres à afficher à
l’écran
III.3.2.La phase de la description des actions
Il s’agit ici d’agencer dans l’ordre de leur exécution, les actions élémentaires qui seront
déroulées.
Application
Entrer les valeurs numériques de X et de Yet qui se traduit par l’instruction ENTRER (X, Y) ;
Faire la somme de X et Y et l’affecter dans la variable SOM ; cela se traduit par l’instruction
SOM  (X + Y) ;
Communiquer le résultat sur le périphérique approprié ; cela se traduit par l’instruction :
AFFICHER (SOM) ;
Edition - 15 -

III.3.3.La phase de la rédaction de l’algorithme
ALGORITHME Addition1
VAR
X : ENTIER
Y : ENTIER
SOM: ENTIER
DEBUT
ENTRER (X)
ENTRER (Y)
SOM  (X + Y)
SORTIR (SOM)
FIN.
Edition - 16 -

IV. STRUCTURES DE CONTRÔLE
Introduction
En programmation procédurale comme en algorithmique, l'ordre des instructions est
primordial.
Le processeur exécute les instructions dans l'ordre dans lequel elles apparaissent dans le
programme. On dit que l'exécution est séquentielle.
Une fois que le programme a fini une instruction, il passe à la suivante. Tant qu'une
instruction n'est pas terminée, il attend avant de continuer. Par exemple, une instruction de
saisie va attendre que l'utilisateur rentre une valeur au clavier avant de continuer.
Parfois, il est nécessaire que le processeur n'exécute pas toutes les instructions, ou encore
qu'il recommence plusieurs fois les mêmes instructions. Pour cela, il faudra casser la
séquence. C'est le rôle des structures de contrôle.
Il existe deux grands types de structures de contrôle:
- les structures conditionnelles vont permettre de n'exécuter certaines instructions que sous
certaines conditions
- les structures répétitives, encore appelées boucles, vont permettre de répéter des
instructions un certain nombre de fois, sous certaines conditions.
IV.1. les structure de choix
Les structures conditionnelles permettent d’exécuter des instructions différentes en fonction
de certaines conditions.
IV.1.1.L’instruction conditionnelle réduite : « SI…ALORS »
Cette instruction permet à la machine d’opérer un choix lorsqu’une condition est vérifiée.
Elle présente la particularité de ne pas avoir de traitements à effectuer lorsque l’évaluation
de la condition produit la valeur FAUX.
Sa syntaxe
Si <condition > alors
<bloc d’instructions>
Finsi
Remarque :
Si la condition est vérifiée alors le bloc d’instructions est exécuté ; dans le cas contraire, il est ignoré.
IV.1.2.Structure conditionnelle alternée ou complète
Sa syntaxe
Si <condition > ALORS
<bloc d’instructions 1>
Sinon
FINSI
Remarque
si la condition est vérifiée seul le premier traitement est exécuté ;
si la condition n’est pas vérifiée seul est effectué le second traitement..
IV.1.3.Imbrication des si
Il est possible d’imbriquer les si autant que nécessaire
Edition - 17 -

SI <condition 1> ALORS
Si <condition11> alors
Sinon
Finsi
Sinon
FINSI
Exercice
SI a > b ALORS
SI B < 0 ALORS
SI C = 5 ALORS
I 3
D 0
FSI
SINON
SI C > 5 ALORS
K b
C  1
SINON
A - 2
FSI
K P * J;
FSI
P M – D ;
FSI
Indiquez les conditions pour lesquelles ces instructions sont exécutées :
I  3 ; et D 0 ; réponse : -------------------------------------------
K B ; et C  1 ; réponse : ----------------------------------------------
A  -2 ; réponse : ----------------------------------------------------------
K  P *J ; réponse : -------------------------------------------------------
P  M – D ; réponse : ------------------------------------------------------
IV.1.4.Structure d’aiguillage
Cette structure de choix permet, en fonction de plusieurs conditions de type booléen,
d’effectuer des actions différentes suivant les valeurs que peut prendre une même variable.
Elle permet de choisir le traitement à effectuer en fonction de la valeur ou de l'intervalle de
valeur d'une variable ou d'une expression.
Cette structure permet de remplacer avantageusement une succession de structures Si…
Alors.
Syntaxe
SUIVANT <nom_variable_choix> FAIRE
Valeur1 : Action1
Valeur 2 : Action2
.
.
Edition - 18 -

.
Valeur n : Action n
SINON Action par défaut
FSUIVANT
Ou
SELON <variable> FAIRE
valeur 1 de variable : traitement 1
valeur 2 de variable: traitement 2
valeur 3 de variable: traitement 3
.
.
.
[Sinon traitement par défaut]
FINSELON
Exercice d’application
Ecrivez un algorithme qui permet d’effectuer la somme ou le produit ou la moyenne de
quatre entiers selon l’opération choisie.
CORRECTION
La description des ressources
Rôle Identificateur Nature Type Commentaires
Entrée Choix VARIABLE ENTIER Choix effectué
Entrée Nb1 VARIABLE ENTIER 1er nombre
Entrée Nb2 VARIABLE ENTIER Deuxième nombre
Entrée Nb3 VARIABLE ENTIER Troisième nombre
Entrée Nb4 VARIABLE ENTIER Quatrième nombre
Description des Actions
Au nombre de quatre nous avons :
 La saisie des quatre nombres qui se traduit par l’instruction suivante : LIRE (Nb1, Nb2,
Nb3, Nb4) ;
 La lecture d’une valeur correspondant au choix effectué traduite par l’instruction LIRE
(choix) ;
 La comparaison de la valeur du choix aux différentes valeurs définies. Ici on dispose de
trois choix présentés de la sorte :
1- Somme
2- Produit
3- Moyenne
 Il faudrait au préalable afficher les trois choix et un message qui invite à saisir le choix
désiré.
 Après la lecture de la valeur du choix, on la compare successivement à 1 ou 2 ou 3.
Si choix vaut 1 alors on exécute l’action correspondant à la somme
Si choix vaut 2 alors on exécute l’action correspondant au produit
Si choix vaut 3 alors on exécute l’action correspondant à la moyenne
Sinon on affiche un message informant que le choix est incorrect.
Edition - 19 -

Rédaction de l’algorithme
ALGORITHME Menu1
VAR choix, Nb1, Nb2, Nb3, Nb 4 : ENTIER
DEBUT
(*Afficher un message de lecture des nombres*)
ECRIRE (‘Saisir quatre nombres’)
(*Lecture des nombres*)
LIRE (Nb1, Nb2, Nb3, Nb4)
(*Afficher le menu*)
ECRIRE (‘Tapez 1 pour la Somme’)
ECRIRE (Tapez 2 pour faire le Produit’)
ECRIRE (‘Tapez 3 pour faire la Moyenne’)
ECRIRE (‘Tapez la valeur de votre choix’)
(*lecture du choix*)
LIRE (choix)
(*Comparaison et exécution de l’action correspondant*)
SUVANT CHOIX FAIRE
1 : ECRIRE (‘la somme est:’ Nb1 + Nb2 +Nb3 + Nb4)
2 : ECRIRE (‘le produit est:’ Nb1 * Nb2 * Nb3 * Nb4)
3 : ECRIRE (‘la moyenne est :’ (Nb1 +Nb2 + Nb3 + Nb4)/4)
SINON ECRIRE (‘votre choix est incorrect’)
FINSUVANT
FIN.
IV.2. Les structures répétitives ou boucles
Les structures répétitives aussi appelées boucles, permettent de répéter un traitement (c’est
à dire une action simple ou composée) autant de fois qu'il est nécessaire: soit un nombre
déterminé de fois, soit tant qu'une condition est vraie.
Il existe trois grands types principaux de structures répétitives:
- la structure Tant que…Faire, qui permet d'effectuer une instruction tant qu'une condition
est satisfaite ;
- la structure Pour qui permet de répéter une instruction un certain nombre de fois ;
- la structure Répéter…Jusqu'à, qui comme son nom l'indique, permet de répéter une
instruction jusqu'à ce qu'une condition soit satisfaite.
IV.2.1.La boucle tant que … faire
La boucle Tant que … Faire permet de répéter un traitement tant qu'une expression
conditionnelle est vraie. Si d'emblée, la condition n'est pas vraie, le traitement ne sera pas
exécuté. On voit donc que la boucle Tant que a un point commun avec la structure
conditionnelle où si la condition n'est pas vraie, le traitement n'est pas exécuté.
Syntaxe
TANT QUE <condition d’exécution> FAIRE
instruction1
.
. Bloc d’instructions
.
Instruction n
FINTANTQUE
Edition - 20 -

IV.2.2.La boucle Pour
La boucle Pour permet de répéter une instruction un nombre connu de fois
Syntaxe
POUR compteur  valeurInitiale à valeurFinale [pas de incrément] FAIRE
Instruction 1
.
.
Instruction n
FINPOUR
Elle permet de faire la même chose que la boucle Tant que mais de façon plus rapide, du
moins lorsque le nombre de répétition est connu.
La variable compteur est de type entier. Elle est initialisée à la valeur initiale. Le compteur
augmente (implicitement) de l'incrément à chaque répétition du traitement. Lorsque la
variable compteur vaut la valeur finale, le traitement est exécuté une dernière fois puis le
programme sort de la boucle.
Par défaut, l’incrément est de 1
La boucle Pour est en fait une simplification de la boucle TantQue.
IV.2.3.La boucle Répéter…Jusqu'à
Cette boucle sert à répéter une instruction jusqu'à ce qu'une condition (expression
booléenne) soit vraie.
Syntaxe
REPETER
Instruction 1
.
.
Instruction n
JUSQU'A <condition d’arrêt>
Le traitement est exécuté, puis la condition est vérifiée. Si elle n'est pas vraie, on retourne
au début de la boucle et le traitement est répété. Si la condition est vraie, on sort de la
boucle et le programme continue séquentiellement. A chaque fois que le traitement est
exécuté, la condition d'arrêt est de nouveau vérifiée à la fin.
La boucle Répéter n'est pas indispensable. Elle peut toujours être remplacée par une boucle
Tantque. C'est pourquoi certains langages n'ont pas d'équivalent pour la boucle
Répéter.
Exercice
Donner la différence entre les structures répétitives ou boucles ?
Edition - 21 -

V. LES SOUS-PROGRAMMES
Introduction
Lorsqu'un programme est long, il est irréaliste d'écrire son code d'un seul tenant. En fait, on
décompose le programme en plusieurs parties plus petites, on donne un nom à chacune de
ces parties, et on les assemble pour former le programme final. C'est le principe de la
programmation modulaire, qui repose sur l'écriture de sous-programmes.
Un sous-programme est, comme son nom l'indique, un petit programme réalisant un
traitement particulier qui s'exécute à l'intérieur d'un autre programme.
Mais contrairement à un programme, un sous-programme ne peut pas s'exécuter
indépendamment d'un autre programme.
Les sous-programmes sont utilisés pour deux raisons essentielles :
- quand un même traitement doit être réalisé plusieurs fois dans un programme (ou qu'il est
utilisé dans plusieurs programmes): on écrit un sous-programme pour ce traitement et on
l'appelle à chaque endroit où l'on en a besoin. On évite ainsi de réécrire plusieurs fois le
code du traitement.
- pour organiser le code, améliorer la conception et la lisibilité des gros programmes. En
effet, le découpage en sous-programmes permet de traiter séparément les difficultés.
Certains sous-programmes ont déjà été écrits et peuvent être utilisés directement dans
n'importe quel programme. Ce sont des sous-programmes standards ou prédéfinis. C'est le
cas par exemple des sous-programmes permettant de faire des calculs mathématiques
(racine carrée, exposant, …). La nature et le nombre de programmes standards dépendent
des langages.
Mais les sous-programmes prédéfinis ne suffisent pas pour découper un gros programme :
le programmeur est amené à écrire le code de ses propres sous-programmes.
Il existe deux sortes de sous-programmes : les procédures et les fonctions.
V.1. Les procédures
V.1.1. Définition
a. Procédure
Une procédure est un ensemble d'instructions regroupées sous un nom, qui réalise un
traitement particulier dans un programme lorsqu'on l'appelle.
Comme un programme, une procédure possède un nom, des variables, des instructions, un
début et une fin.
2. Un paramètre
Un paramètre ou un argument est une variable particulière qui sert à la communication entre
programme appelant et sous-programme.
Les paramètres formels.
Les paramètres placés dans la définition d'une procédure sont les paramètres formels. Ils
servent à décrire le traitement à réaliser par la procédure indépendamment des valeurs
traitées. Les paramètres formels sont des variables locales à la procédure, et à ce titre ils
sont déclarés dans l'entête de la procédure.il existe trois statuts de paramètres : donnée,
résultats, donnée-résultat
Les paramètres réels ou effectifs
Edition - 22 -

Les paramètres placés dans l'appel d'une procédure sont les paramètres réels ou effectifs.
Lorsqu'ils sont de type donnée, ils contiennent effectivement les valeurs sur lesquelles sera
effectué le traitement de la procédure. Lors de l'appel, leur valeur est recopiée dans les
paramètres formels correspondants. Un paramètre effectif en donnée peut être soit une
variable du programme appelant, soit une valeur littérale, soit le résultat d'une expression.
Schéma de communication
Tableau récapitulatifs
Paramètre Début de la procédure Fin de la procédure
Donnée Valeur connue Valeur non modifiée
Résultat Valeur ignorée Valeur modifiée
Donnée-résultat Valeur connue Valeur modifiée
V.1.2. syntaxe de déclaration d’une procédure
PROCEDURE <nom_ procédure> (arg1 : type, arg2 : type, …arg n : type)
//Partie déclarative
DEBUT
.
.
.
FINPROCEDUE
V.1.3. Appel d'une procédure
Pour déclencher l'exécution d'une procédure dans un programme, il suffit de l'appeler, c'est-
à-dire d'indiquer son nom suivi de parenthèses avec les éventuels paramètres effectifs.
V.1.4. Passage de paramètre
a. Le passage de paramètres par valeur
L’algorithme appelant fait un passage de paramètres par valeur à l’algorithme appelé ou
sous-programme lorsqu’il transmet à ce dernier les valeurs des paramètres d’entrée.
L’intégrité de ces valeurs est assurées et le sous programme ne peut les modifier.
2. Le passage de paramètres par adresse ou référence
Edition - 23 -

On dit que des variables sont passées en paramètres par adresse, lorsque celles-ci sont
modifiées au sein du sous- algorithme, elles le sont même lorsque l’on retourne au
programme appelant.
passage par valeur passage par référence
utilisation en entrée oui oui
utilisation en sortie non oui
Remarque
Pour différencier les paramètres passés par valeurs de ceux passer par adresse, on place le
mot var ou le caractère @ avant les paramètres passant par adresse en commençant la liste
par les paramètres passés par valeur.
V.1.5. Visibilité des variables
a. Variables locales
Ce sont les variables qui sont déclarées à l’intérieur d’un programme ou d’un sous-
programme et non visibles ou inaccessibles par les autres (programmes et sous-
programmes)
2. Variables globales
Par opposition au variables locales, ce sont des variables définies dans la partie déclarative
d’un programme et utilisables par les sous programmes et l’ensemble du programme
principal
V.2. Fonctions
V.2.1. Définitions
Les fonctions sont des sous-programmes qui retournent un et un seul résultat au
programme appelant. De ce fait, les fonctions sont appelées pour récupérer une valeur,
alors que les procédures ne renvoient aucune valeur au programme appelant.
FONCTION nom_ fonction (Arg1 : type, arg2 : type,…arg n : type) : type
renvoyé par la fonction
// Partie déclarative
DEBUT
Instruction1
.
. Corps de la fonction
.
Instruction n
Retourne <valeur à retourner>
FINFONCTION
Remarque
Les paramètres d'une fonction sont toujours de statut donnée. La valeur des paramètres
effectifs à l'appel est recopiée dans les paramètres formels qui servent à réaliser le
traitement de la fonction.
Edition - 24 -

V.2.2. Appel d’une fonction
L'appel des fonctions est différent de l'appel des procédures :
L'appel d'une fonction doit obligatoirement se trouver à l'intérieur d'une instruction (affichage,
affectation,…) qui utilise sa valeur.
V.3. différences entre fonctions et procédures.
Fonction Procédure
1 Les fonctions ne peuvent avoir que
des paramètres de statut
données.
Les procédures peuvent avoir des paramètres
résultats, données ou données-résultats.
2 Les fonctions ne peuvent
communiquer qu'un seul résultat
au programme appelant à travers
une valeur de retour (et non à
travers un paramètre)
Les procédures peuvent communiquer de 0 à
plusieurs résultats au programme appelant à
travers des paramètres résultats ou données-
résultats. La valeur de ces résultats est affectée
aux paramètres effectifs correspondant (qui
doivent obligatoirement être des variables du
programme appelant).
3 Une fonction s'appelle à l'intérieur
d'une instruction.
L'instruction utilise la valeur
retournée par la fonction.
L'appel d'une procédure représente une
instruction en elle-même. On ne peut pas
appeler une procédure au milieu d'une
instruction
Remarque
Une sous programme peut ne pas posséder de paramètres.
V.4. Imbrication de sous programmes
Une procédure ou une fonction peut être appelée soit par un programme, soit par un autre
sous-programme (qui lui même a été appelé). Les appels de sous-programmes peuvent
s'imbriquer autant qu'on le désire.
Edition - 25 -

VI. NOTION DE RÉCURSIVITÉ
VI.1. Définition
La récursivité est la possibilité de faire figurer dans la définition d'un objet une référence à
l'objet lui-même.
VI.2. Types de récursivité
Deux types de récursivités:
− Directe (l'algorithme s'appelle lui-même)
− Indirecte ou croisée (un algorithme appelle un autre qui appelle le premier)
VI.3. Construction
Pour construire un algorithme récursif, on doit d'abord s'intéresser à son organisation
générale. Un tel algorithme comprend au moins deux parties principales qui sont
accessibles par une structure de choix (SI condition alors …sinon …….)
 Une condition d'arrêt qui donne la solution d'un cas trivial du problème à résoudre.
 Une partie traitement dans laquelle s'opère(nt) le(s) appel(s) récursif(s) et où sont
altérés les paramètres de l'algorithme. Cette altération doit réduire le problème
général au cas particulier (le cas dit trivial) dont l'algorithme donne la solution.
Trois grandes étapes:
− Paramétrage de l'algorithme (détermination des paramètres à faire évoluer car ce
sont eux qui conditionnent la résolution du cas trivial)
− Étude de la condition d'arrêt (cas trivial)
− Étude du cas général jusqu’à sa réduction au cas simple (cas trivial).
La structure adaptée à un algorithme récursif est la primitive de choix :
SI <condition> ALORS
Traitement1 (résolution du cas trivial)
SINON
Traitement2 (résolution du cas général)
FINSI
Exercice
On se propose une d'écrire une fonction récursive nommée fact_rec qui prend en
paramètre un entier naturel n et retourne n! (factoriel n).
n! = n*(n-1)*(n-2)*…………*3*2*1
Correction
Fonction FACT_REC (n : entier):entier
VAR
Facto : entier
DÉBUT
Si n = 0 alors
Facto  1
Sinon
Facto  n*FACT_REC(n-1)
Finsi
Retourner (facto)
Edition - 26 -

FIN.
La version itérative de cette fonction est:
Fonction fact_it (n : entier):entier
Var
x, produit : entier
Début
x  n
produit  1
Tant que x >0 faire
Produit  produit * x
X  x - 1
Fintantque
Retourner (produit)
Fin.
Edition - 27 -

VII. LES STRUCTURES DE DONNEES STATIQUES
Introduction
Les structures de données statiques sont des variables évoluées qui sont susceptibles de
recevoir plusieurs valeurs à la fois. Par ailleurs, une fois leur taille fixée, il n’est plus possible
de la modifier au cours de l’exécution du programme. C’est pour cette raison qu’on les
appelle structures de données statiques en comparaison avec les structures de données
dynamiques.
Les structures de données statiques regroupent six grands groupes. Ce sont :
 Les chaînes de caractères
 Les intervalles
 Les ensembles
 Les énumérés
 Les tableaux
 Les enregistrements. On les appelle encore les types structurés
VII.1. Les chaînes de caractères
VII.1.1. Définition du type CHAINE
Une chaîne de caractères est une suite de caractères juxtaposés. En d’autres termes une
suite de caractères différents collés les uns aux autres.
Une chaîne de caractères est définie par :
Son nom et Sa longueur maximale (c’est le nombre maximal de caractères que cette
chaîne peut contenir).
VII.1.2. syntaxe
La syntaxe de déclaration d’une chaîne de caractères se fait par :
VAR
Nom_chaîne : CHAINE [longueur maximale] // avec long max є [1 ; 255]
Exemple
VAR
Nom : CHAINE [30] ;
Nous déclarons une chaîne de caractères nommée Nom et pouvant contenir au maximum
trente (30) caractères.
Remarque :
L’on peut parcourir ou atteindre les différents éléments d’une chaîne de caractères grâce à
un indice (entier > 0) qui débute par 1 comme suit : Nom_chaîne [indice].
En fait l’indice ici est la position de cet élément (le caractère) dans la chaîne de caractères.
VII.1.3. Les différentes fonctions applicables sur une chaîne de caractères
On peut réaliser sur une chaîne de caractères, plusieurs différentes opérations usuelles de
fonctions.
On peut citer les fonctions suivantes :
 LONGUEUR ( )
 COPIER ( )
 CONCATENER ( )
Edition - 28 -

 INSERER ( )
 EFFACER ( )
a. La fonction LONGUEUR (M)
Elle permet de déterminer le nombre de caractères contenus dans une chaîne de caractères
M.
syntaxe
LONGUEUR (M) où M est le nom de la variable chaîne_de_caractères.
Exemple
VAR
Nom : CHAINE [30]
Début
Nom  San Perdo.
LONGUEUR (Nom) affichera 9
//Ici on compte tous les caractères y compris les espaces.
b. La fonction COPIER (n, i, j) ;
Elle permet de copier j caractères de la chaîne de caractères M, à partir de son caractère n°i
inclus, dans une autre chaîne de caractères.
syntaxe
COPIER (M, i, j)
Exemple
VAR phrase : CHAINE [20]
P : CHAINE [10]
DÉBUT
Phrase ‘’Heureux sont ceux qui sont pieux’’
P COPIER (Phrase, 3, 8)
(*Cette instruction stipule de copier 8 caractères de la chaîne de caractères Phrase mais à
partir de son caractère n° 3 inclus*)
De sorte que la chaîne de caractères : P contiendra les caractères suivants : ‘’ureux so’’.
3. La fonction CONCATENER (L, M) ;
Elle permet de concaténer (souder) les chaînes de caractères L et M. Ici, c’est la deuxième
chaîne M qui est collée à la première L.
Exemple
VAR
Nom : CHAINE [20]
Prenom : CHAINE [25]
Nom_P : CHAINE [50]
Debut
Nom  ‘’KANGAH’’
Prenom  ‘’EKOUMANO’’
Nom_P  CONCATENER (Nom, Prenom)
Nom_P contiendra ‘’KANGAHEKOUMANO’’
Ici les deux termes sont collés (KANGAHEKOUMANO)
Si nous voulons les séparer alors nous prévoyons un espace qui sera matérialisé par
Donc nous reprenons la syntaxe de la façon suivante :
Nom_P  CONCATERER (Nom,’’ ‘’Prénom) ;
Edition - 29 -

Alors nous aurons :
Nom_P qui contiendra : ‘’KANGAH Ekoumano’’.
4. La fonction INSERER (L, M, K) ;
Elle permet d’insérer la chaîne de caractères L dans la chaîne M mais à partir du caractère
n° K (i. e juste après le caractère n° k -1) de la chaîne M.
Exemple
VAR
Nom : CHAINE [20]
Prenom : CHAINE [25]
DEBUT
Nom  KANGAH
Prenom  Ekoumano
INSERER (Nom, Prénom, 4)
(*Cette instruction ordonne de prendre la contenu de la chaîne Nom et de l’insérer dans le
contenu de la chaîne Prénom, mais à partir du caractère n° 4 (juste après le caractère n° 3)
de la chaîne Prénom*).
On aura comme résultat :‘’EkKANGAHoumano’’.
5. La fonction EFFACER (M, i, j) ;
Elle permet d’effacer j caractères de la chaîne M mais à partir de son caractère n° i inclus.
Exemple :
VAR
Nom : CHAINE [20]
DEBUT
Nom ‘’KINDO’’
EFFACER (Nom, 2, 3)
(*Cette instruction ordonne de se positionner sur le 2ème
caractère de la chaîne Nom et à
partir de ce 2ème
caractère inclus, d’effacer 3 caractères, vers la droite*).
De sorte que la chaîne Nom contiendra finalement ‘’KO’’.
VII.1.4. Les opérateurs applicables sur une chaîne de caractères
Nous avons les opérateurs suivants :
+ : joue même rôle que CONCATENER :
Nom_P  Nom + Prenom ;
= : permet de comparer deux chaînes.
SI Nom = Prenom ALORS….
< > : Permet de différencier 2 chaînes.
Si Nom < > Prenom ALORS…
<, >, < =, > = : permettent de savoir si une chaîne précède ou succède une autre,
alphabétiquement.
SI Nom < prenom ALORS…
VII.2. Le type énuméré
VII.2.1. Définition
C’est un ensemble ordonné d’éléments énumérés tous.
L’ordre d’énumération des éléments est très important : ce n’est véritablement pas une
structure de donnée.
VII.2.2. Sa syntaxe de déclaration
Edition - 30 -

Un type énuméré est défini dans la partie TYPE de l’algorithme. Sa syntaxe est :
TYPE
Nom_type_énuméré = (valeur1, valeur2, ..., valeurn).
Remarque
Tout type déclaré dans la partie TYPE, ne peut être utilisé comme tel, il faudra nécessairement
déclarer dans la partie VAR, une variable de type, le type déclaré dans la partie TYPE ; et c’est cette
variable qui sera utilisé par la suite dans le programme.
Exemple :
TYPE
Jours = (Dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi)
Etat_civil = (célibataire, marie, veuf, separe) ;
Corps = (C, O, H, CO2, H2O) ;
VAR
P : Jours
(*Déclaration de la variable P de type Jours. Et donc P, ne pourra
recevoir que les valeurs citées entre parenthèses dans Jours (Dimanche,
lundi, ---) mais une seule à la fois*)
F : Etat_civil
(*déclaration de la variable F de type Etat_civil. F ne pourra recevoir
que les valeurs citées dans Etat_civil, et une seule à la fois*).
MT : Corps
(*déclaration de la variable Mt de type Corps.
Mt ne recevra donc que les valeurs entre parenthèses dans Corps une seule
à la fois*)
Ainsi, ce sont les variables P, F, Mt qui seront utilisées par la suite dans le programme (mais
non pas Jours, Etat _civil, et corps).
VII.2.3. Les fonctions applicables du type énuméré
Les fonctions suivantes sont utilisables :
ORD, PRED, SUCC
SUCC (mardi) vaut mercredi
PRED (SAMEDI) vaut vendredi
Mais PRED (lundi) et SUCC (dimanche) ne sont pas définis. (Ils n’existent pas).
La première valeur du type énuméré possède le rang 0 (zéro).
Ainsi ORD (lundi) vaut 0
ORD (jeudi) vaut 3.
Remarque
Il est impossible d’utiliser les instructions AFFICHER et SAISIR avec les variables de type énuméré.
Il est aussi impossible de les utiliser comme indice à un tableau.
VII.3. Le type intervalle
Il permet de définir un ensemble de valeurs par la simple connaissance de la valeur initiale
et de la valeur finale à la différence du type énuméré où obligation est faite de définir tous
ses éléments.
Edition - 31 -

VII.3.2. Sa déclaration et syntaxe
Un type intervalle est défini dans la partie TYPE de l’algorithme.
La syntaxe de déclaration est la suivante :
TYPE
Nom_intervalle = valeur_initiale.. valeur_finale
Avec valeur_initiale et valeur_finale, des constantes (entier, caractère) telles que
valeur_initiale < valeur_finale.
Exemple
TYPE
Age = 1.. 150
VAR
age_pere : age
En effet, age_pere ne pourra recevoir seulement que les valeurs comprises entre 1 et 150 y compris.
Mais une seule valeur à la fois.
Remarque
Un intervalle est forcément ordonné et continu.
Il est possible d’utiliser des constantes d’un type énuméré pour constituer un type intervalle.
Exemple
TYPE
Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche)
Jours_travail = lundi..vendredi
Week_end = samedi..dimanche
Mais les deux dernières déclarations ont été possibles parce que l’on a auparavant déclaré
un type énuméré ayant ces constantes (lundi…)
VII.3.3. Les propriétés de type intervalle
Les variables d’un type intervalle jouissent exactement des mêmes propriétés que le type
hôte. Elles peuvent intervenir dans les mêmes expressions.
TYPE ENTIER : , +, *, /, =, -, < ; <=, >, >=, < >.
TYPE CARACTERE: , =, -, <, <=, >, >=, < >, ORD, SUCC, PREC.
TYPE ENUMERE : ,ORD, SUCC, PRED, incrémentation, décrémentation.
Exemple :
TYPE
Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche)
Jours_travail = lundi..vendredi
VAR
Courant, aujourd’hui : jours_travail
ct : Jours
Aujourd-hui  mardi
Courant  SUCC (Aujourd-hui) (*courant contiendra mercredi*)
Aujourd-hui Aujourd-hui + 2 (*Aujourd-hui contiendra jeudi*)
Remarque :
Il est possible d’utiliser des valeurs de type énuméré comme compteur dans la boucle
POUR….FAIRE.
En s’appuyant sur l’exemple ci-dessus, nous pouvons avoir :
Edition - 32 -

POUR Ct  lundi à dimanche FAIRE
(*Ici il faut que ct soit une variable de type énuméré*)
Instructions
FPOUR
VII.4. type ENSEMBLE
Le terme ensemble évoque ici, une collection non ordonnée d’éléments de même type, où le
rang des éléments n’a pas d’importance.
VII.4.2. Déclaration du type ensemble
Elle se fait majoritairement dans la partie TYPE bien qu’on puisse le faire aussi dans la
partie VAR)
La syntaxe de déclaration est la suivante :
TYPE
Nom_ensemble = ENSEMBLE de type_de_base
Avec type_de_base, un type ordinal (ENTIER, REEL, CARACTERE, ENUMERE) ou
INTERVALLE d’un type ordinal dont les valeurs ordinales sont comprises entre zéro(0) et
255 et contenant au plus 256 éléments.
Exemple
TYPE
Lettres = ENSEMBLE de CARACTERE
Premier = ENSEMBLE de 1..20
VAR
F : Lettre
P : Premier
Ainsi F pourra contenir zéro (0), un (1) ou plusieurs caractères à la fois ;
P pourra contenir zéro (0), un (1) ou plusieurs valeurs entières à la fois comprises entre 1 et
250 y compris.
VII.4.3. Construction d’une variable de type ensemble
Construire un ensemble, c’est constituer ses éléments.
Un ensemble se construit grâce à la parie de crochet [ ]
La syntaxe de construction d’un ensemble est la suivante :
[Objets]
Où objets peut être une liste d’éléments séparés par des virgules ou bien un ou plusieurs
intervalles séparés par des virgules ou bien la combinaison de deux (liste d’éléments et
intervalle). Mais tous les éléments constituant un même ensemble doivent nécessairement
être du même type.
Exemples
Voici 3 exemples d’ensembles
[‘a’, ‘j’, ‘m’] est l’ensemble constitué des 3 caractères a, j, m.
[9, 7, 6, 25] est l’ensemble constitué des nombres 9 ; 7 ; 6 ; 25
[1..5, 8, 15..20] ensemble de nombres 1, 2, 3, 4, 5, 8, 15, 16, 17, 18, 19 et 20.
Remarques
L’ordre dans lequel sont mentionnées les expressions n’a aucune importance.
Edition - 33 -

De sorte que [5, 7] et [7, 5] définissent le même ensemble. ([5, 7] = [7, 5]).
Il est possible de déclarer des constantes de type ensemble
Exemple :
CONST
Voyelle = [‘a’, ‘e’, ‘i’, ‘u’, ‘o’, ‘y’]
P = 10
Valeurs = [P, 2*P, 3*P]
C = ‘e’
Lettres = [C, PRED (C), SUCC (C)]
VII.4.4. Les opérations portant sur les ensembles
Nous ferons cas de six principales opérations :
L’affectation
La réunion
L’intersection
La différence
Les opérations de comparaison
L’instruction d’appartenance : DANS.
a. L’affectation ( )
TYPE
Voy = ENSEMBLE de CARACTERE
VAR
T : Voy
DEBUT
T [‘a’, ‘f’]
Remarque
On peut faire l’affectation entre deux ensembles constitués d’éléments de même type exclusivement.
2. La réunion : (+)
Elle permet de fusionner les éléments de plusieurs ensembles mais sans redondance.
Exemples
A et B sont des ensembles
A B A + B
[1, 3] [2, 6] [1, 2, 3, 6]
[1, 3] [4, 3] [1, 3, 4]
[1, 5] [1, 5, 6] [1, 5, 6]
3. L’intersection (*)
L’intersection de deux ensembles ou plus, c’est l’ensemble formé d’éléments appartenant à
la fois aux deux ensembles ou plus.
Exemples :
Soient A et B des ensembles
A B A * B
[1, 3, 8] [1, 5, 8, 11] [1, 8]
[1, 5] [1, 3, 5, 8] [1, 5]
[3, 7] [2, 9, 11] [ ]
Edition - 34 -

4. La différence : (-)
Soient A et B deux ensembles A – B est l’ensemble formé d’éléments appartenant à A et
n’appartenant pas à B (on retire de A, tout ce qui appartient à B ;
Il s’en suit que A – B ≠ B – A
Exemples
A B A - B
[‘a’, ‘c’, ‘f’, ‘k’] [‘c’, ‘f’] [‘a’, ‘k’]
[‘a, ‘b’, ‘c’] [‘d’, ‘e’] [‘a’, ‘b’, ‘c’]
[‘f’, ‘g’] [‘a’, ‘f’, ‘g’, ‘k’] [ ]
5. Les opérations de comparaison
Ici deux opérations sont à prendre en compte :
L’Egalité (=) A = B si A et B sont formés des mêmes éléments
L’Inclusion ( ≤ ) A ≤ B si A est inclus dans B.
6. L’instruction d’appartenance : (DANS)
Syntaxe
Nom_variable DANS nom_variable_ensemble
Exemple
TYPE
Lettres = ENSEMBLE de CARACTERE
VAR
Voy : Lettres
C : CARACTERE
DEBUT
Voy  [‘a’, ‘A’, ‘e’, ‘E’, ‘y’, ‘Y’, ‘i’, ‘I’, ‘u’, ‘U’, ‘o’, ‘O’]
AFFICHER (‘Entrez une lettre SVP’’)
SAISIR ( C)
SI C DANS Voy ALORS
AFFICHER (‘Vous avez saisi une voyelle’)
FSI
VII.5. Type TABLEAU
Un tableau est une structure de données contenant des éléments de même type
Ces éléments peuvent être des :
 entiers
 réels
 booléens
 chaînes de caractères
 caractères
 tableaux
 enregistrements
Le tableau est constitué de cases représentant chacune une variable.
Edition - 35 -

Chaque valeur du tableau (valeur de chaque case) sera accessible à travers un nom du
tableau commun à toutes les valeurs et repérée par un sélecteur appelé indice du tableau
ou la position de la donnée dans le tableau).
Un tableau est caractérisé par :
son nom
sa taille (nombre maximal d’éléments qu’il va contenir)
et le type de ses éléments.
On distingue deux grands groupes de tableaux sur la base de leurs dimensions.
Ainsi on a les tableaux :
− Unidimensionnels ou vecteurs et
− Multidimensionnels.
Mais pour ce cours nous nous intéresserons aux tableaux à une dimension et à deux
dimensions.
VII.5.2. Les tableaux à une dimension ou unidimensionnels
Appelé encore vecteur un tableau unidimensionnel est constitué d’une (1) seule ligne et n
colonnes (1 seule ligne et plusieurs colonnes).
a. Exemple
Mes moyennes de 10 étudiants d’une classe IG sont stockées dans un tableau linéaire
suivant.
5 12 14 7,5 10 9,5 13 3 6 10
1 2 3 4 5 6 7 8 9 10
2. Syntaxe et description
Un tableau à une (1) dimension peut être déclaré soit dans la partie TYPE ; mais
majoritairement dans la partie VAR.
Si d’aventure, un tableau à une (1) dimension est déclaré dans la partie TYPE, il faudra
nécessairement par la suite, déclarer une variable ayant pour type, le type déclaré dans la
partie TYPE.
La syntaxe de déclaration d’un tel tableau se fera par :
VAR
Nom_tableau : TABLEAU [taile] de type_éléments
// taille, un entier>0
Ou bien :
TYPE
Nom_tableau = TABLEAU [taille] de type_éméments.
Pour atteindre chaque élément d’un tableau à une dimension l’on procède comme suit :
Nom_tableau [indice]
//avec indice є [1, taille]
Exemple
T [5] ; cette instruction permet d’atteindre le 5è élément du tableau T et d’y faire ce que l’on
désire (soit envoyer une valeur. (Écriture) ou prendre possession de la valeur déjà là
(lecture).
Edition - 36 -

VII.5.3. Les tableaux à plusieurs dimensions
On peut avoir un tableau à 2, 3,…, n dimensions.
Mais dans la pratique, c’est le tableau à deux dimensions qui est le plus utilisé.
a. Définition
Un tableau à deux dimensions (de dimension 2) est constitué de :k lignes (plusieurs lignes)
et de p colonnes(plusieurs colonnes).
2. Syntaxe de déclaration
Il peut être déclaré soit dans la partie VAR soit dans la partie TYPE ; mais majoritairement
dans la partie VAR.
Si d’aventure, un tableau de dimension 2 est déclaré dans la partie TYPE, il faudra
nécessairement par la suite, déclarer une variable ayant pour type, le type déclaré dans la
partie TYPE.
La déclaration d’un tableau P à deux dimensions se fait par :
VAR
T : TABLEAU [Nombredelignes] [Nombredecolonnes] de type_éléments
//Avec Nombre de lignes et Nombre de colonnes, des entiers > 0
Ou bien
TYPE
P = TABLEAU [Nombre de lignes] [Nombre de colonnes] de type_éléments
Exemples
P : TABLEAU [7] [5] de CARACTERE ; définit un tableau de 7 lignes et 5 colonnes, soit 35 e
t chaque case recevra un seul caractère.
C1 C2 C3 C4 C5
L1
L2
L3
L4
L5
L6
L7
Pour atteindre un élément d’un tableau de dimension 2, on procède de la façon suivante :
Nom_tableau [n° ligne] [n°colonne]
Ainsi P [2] [5] ; permet d’atteindre l’élément du tableau P se trouvant à l’intersection de la 2è
ligne et la 5è colonne.
VII.5.4. Imbrication des tableaux
Un tableau peut en imbriquer un autre c’est-à-dire qu’un tableau peut se retrouver à
l’intérieur d’un autre tableau.
Remarque
Dans ce cas les tableaux à imbriquer doivent nécessairement être déclarer dans, la partie
TYPE.
Exemple
TYPE
P : TABLEAU [5] de CHAINE
T : TABLEAU [10] de P
VAR
Edition - 37 -

M : T
VII.5.5. Définition de constante de type Tableau
Il est souvent nécessaire, dans la résolution de certains problèmes, de définir des
constantes de type tableau ; Ici, on déclare le tableau et on l’initialise en même temps (c’est-
à-dire qu’on lui attribue déjà ses valeurs). Mais une fois les valeurs du tableau attribuées,
l’on ne pourra plus les modifier car l’on à défini le tableau dans la partie CONST (donc ses
éléments sont des constantes).
Remarque :
Une telle déclaration permet de pallier les insuffisances des structures de données qui ne
permettent pas de définir des ensembles de chaînes de caractères.
Cas de la structure de données Ensemble.
Syntaxe de déclaration
CONST
Nom_CSte : TABLEAU [taille_tableau] de type_élément = (élément1,
élément2,....,élémentn)
Exemple 1
CONST
Tab : TABLEAU[5]de ENTIER = (1, 45, 78, -156, 0)
de sorte que le tableau de dimension Tab sera représenté ainsi :
1 45 78 -156 0
Exemple 2
CONST
T : TABLEAU[3][5] de CARACTERE = ((‘b’, ‘5’, ‘p’, ‘-‘, ‘b’), (‘1’, ‘c’,
‘T’, ‘y’, ‘m’), (‘>’, ‘&’, ‘@’, ‘w’, ‘Q’))
ou
CONST
T : TABLEAU[3][5] de CARACTERE = (‘b’, ‘5’, ‘p’, ‘-‘, ‘B’, ‘1’, ‘r’, ‘T’,
‘y’, ‘m’, ‘>’, ‘&’, ‘@’, ‘w’, ‘Q’)
VII.6. type ENREGISTREMENT
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.
VII.6.2. Syntaxe de déclaration
La déclaration d’un type ENREGISTREMENT se fait dans la partie TYPE.
TYPE
Nom_type_enregistrement = ENREGISTREMENT
Non_champ1 : type_champ1
Nom_champ2 : type_champ2
.
.
.
Edition - 38 -

Nom_champn : type_champn
FINENREGISTREMENT
Remarque
Mais après la déclaration d’un type Enregistrement dans la partie TYPE, il faudra
nécessairement par la suite, déclarer une variable de type Enregistrement dans la partie
VAR car c’est elle qui sera utilisée par la suite dans la suite dans le programme.
VII.6.3. L’intérêt du type Enregistrement
Il sert à identifier dans les détails, un objet donné
Exemple1
Type
eleve= ENREGISTREMENT
Mat : chaine[10]
Nom : chaine[20]
Pren : chaine[30]
Age, poids : entier
Sexe : caractère
FIN
Var
Etudiant : eleve
Exemple2
Nous voulons identifier l’objet PRODUIT.
Nous avons besoin de :
nom du produit ou son libellé (CHAINE DE CARACTERE),
sa référence (CHAINE)
et son prix de vente (REEL).
Ainsi pour définir le type Enregistrement Produit, nous procéderons de la façon suivante :
TYPE
Produit = ENREGISTREMENT
Nom : CAHINE
Référence : CHAINE
Prix_vente : REEL
FIN
VAR
Article : Produit
VII.6.4. exploitation
1. Les différents champs d’une variable de type Enregistrement sont exploités l’un après
l’autre mais séparément.
2. On accède à chaque de la variable, en précisant le nom de la variable suivie d’un point (.)
et du nom du champ concerné.
NB.
Les termes suivants sont synonymes : Champ, propriété, rubrique
Exemple.
Nous voulons accéder au champ référence de la variable Article. Alors nous écrivons
Article. Référence.
Edition - 39 -

Instruction ‘’AVEC…FAIRE’’
L’instruction ‘’AVEC…FAIRE’’ permet de simplifier l’exploitation des variables de type
Enregistrement.
Elle permet d’éviter la répétition du préfixe dans l’exploitation des champs.
AVEC nom_variable_type_enregistrement FAIRE
//instruction
FIN AVEC
exemple
ALGORITHME saisietu
TYPE
Elève = ENREGISTREMENT
Mt : CHAINE [10]
Nom : CHAINE [20]
Prénoms : CHAINE [50]
Contact : REEL
Sexe : CARACTERE
Poids, taille, Age : REEL
Classe : CHAINE [10]
Moyenne : REEL
FIN
VAR
Etudiant : Elève
DEBUT
AFFICHER (‘Veuillez affecter une valeur à chaque champ’)
SAISIR (Etudiant. Mat)
SAISIR (Etudiant. Nom)
SAISIR (Etudiant. Prénoms)
SAISIR (Etudiant. Contact)
SAISIR (Etudiant. Sexe)
SAISIR (Etudiant. Taille, Poids, Age)
SAISIR (Etudiant. Classe)
SAISIR (Etudiant. Moyenne)
FIN
Avec l’instruction avec on obtient
ALGORITHME saisietu
TYPE
Eleve = ENREGISTREMENT
Mat : CHAINE [10]
Nom : CHAINE [20]
Prenoms : CHAINE [50]
Contact : REEL
Sexe : CARACTERE
Poids, taille, Age : REEL
Classe : CHAINE [10]
Moyenne : REEL
FIN
VAR
Etudiant : Eleve
DEBUT
Edition - 40 -

AFFICHER (‘Veuillez affecter une valeur à chaque champ’)
AVEC Etudiant FAIRE
SAISIR (Mat)
SAISIR (Nom)
SAISIR (Prénoms)
SAISIR (Contact)
SAISIR (Sexe)
SAISIR (Taille, Poids, Age)
SAISIR (Classe)
SAISIR ( Moyenne)
FINAVEC
FIN
VII.6.5. Imbrication d’enregistrements
Définition
Une variable de type Enregistrement peut laisser figurer en son sein un autre
enregistrement. On dit alors qu’elle imbrique un autre enregistrement
Exemple
TYPE
Contact = ENREGISTREMENT
Telephone : CHAINE[10]
Boite_postale : CHAINE[15]
Lieu_habitation : CHAINE[25]
FIN
Personne = ENREGISTREMENT
Nom :chaine[20]
Prenom : chaine[50]
Taille :reel
Ct : Contact (*imbrication*)
VAR
P : Personne
Ainsi dans l’exploitation des champs nous avons par exemple :
P. Nom ‘’YAPI’’
P. Prénom  ‘’ASSI Fernand’’
P. Taille  1,80
P. Ct. Téléphone  ‘’08 20 13 79’’
P. Ct. Boîte-postale  ‘’14 BP 235 Abidjan 14’’
P. Ct. Habitation  ‘’Abidjan, Cocody Danga’’
VII.6.6. Tableau d’enregistrement
Il est possible d’avoir un tableau de type enregistrement
Exemple
Type
Mat : chaine[10]
Nom : chaine[20]
Edition - 41 -

Pren : chaine[30]
Age, poids : entier
Sexe : caractère
FIN
tab=TABLEAU[13] de eleve
Var
Etudiant : eleve
t :tab
i:entier
DEBUT
POUR i1 à 13 faire
AVEC t[i] FAIRE
SAISIR (Mat Nom, Pren, Age, poids,Sexe)
FINAVEC
FINPOUR
FIN
Remarque
Un enregistrement peut contenir un champ de type tableau
Edition - 42 -

VIII. LES FICHIERS
Introduction
Toutes les informations que nous avons jusqu'à présent traitées étaient saisies à partir du
clavier et stockées en mémoire (la RAM).
Or la mémoire centrale est volatile : les informations qui y sont stockées sont détruites à la
fin de l'exécution du programme et ne peuvent donc pas être réutilisées ultérieurement. A la
fin de l'exécution du programme, il ne reste aucune trace de cette exécution et des résultats
générés.
Par ailleurs, la mémoire centrale a l'inconvénient d'être bien plus chère que la mémoire non
volatile des disques durs, disquettes ou bandes magnétiques. La taille de la mémoire
centrale est par conséquent très inférieure à la taille de la mémoire non volatile. Pour
mémoriser de gros volumes d'information, la mémoire centrale ne suffit pas.
Ainsi, dans la plupart des applications d'entreprises pour lesquelles un gros volume
d'informations doit être mémorisé plus longtemps que la durée de vie du programme, les
informations sont récupérées et mémorisées sur un support non volatile (disques,
disquettes, bandes magnétiques…). Les informations y sont enregistrées de manière
permanente dans des fichiers.
Les informations ne sont plus seulement communiquées via le clavier et l'écran, mais aussi
via des fichiers de support non volatiles. Il est alors possible qu'un programme ne
communique avec son environnement qu'au travers des fichiers et n'utilise ni la saisie, ni
l'affichage.
VIII.1. Définition
VIII.1.1. fichier
Un fichier est un regroupement d'informations sur un support non volatile tel que le disque.
Il existe de nombreux types de fichiers, qui différent en outre selon les langages. Nous
distinguerons les fichiers de type « texte » et les fichiers structurés.
a. Les fichiers structurés
Les fichiers structurés permettent d’enregistrer des données de même nature. Ils sont
composés d’enregistrements (ou articles) contenant les mêmes champs (ou rubrique).
Généralement, chaque enregistrement correspond à une ligne, et les rubriques sont
séparées par un séparateur qui peut être par exemple un point-virgule (format csv).
2. Les fichiers non structurés
Les fichiers non structurés permettent quant à eux d’entasser des informations de natures
diverses. Ils ne sont pas obligatoirement structurés en enregistrements, mais ils ne peuvent
être lus que de manière séquentielle. Ex : un fichier word.
VIII.1.2. supports pour les fichiers:
Il existe deux grandes familles de supports pour les fichiers:
- les supports adressables, sont capables de fournir l'adresse d'un emplacement de
stockage. C'est le cas des disques et les disquettes. Ils permettent un accès direct (non
séquentiel) à leur contenu.
- les supports non adressables qui ne peuvent être accédés que de manière séquentielle.
C'est le cas des bandes magnétiques, qui sont encore utilisées pour stocker les données
très volumineuses (les archives)
Edition - 43 -

VIII.2. Caractéristiques d’un fichier
Un fichier sera caractérisé par son nom, son emplacement ( sur le support) , son
organisation, sa taille ou son volume et par son type
Nom
Le nom par lequel le fichier est enregiqtrer sur l’unité de disque
Emplacement
Le chemin d’accès du fichier sur l’unité
Organisation
L’orde avec lequel les information sont rangés ou placées en memoire
Volume
Le nombre d’octets total que le fichier occupe sur le support
Le type
Il est fonction de ladurée de vie du fichier sur l’unité et de son tauxde mise à jour
− Fichier permaments
− Fichiers mouvement
− Fichiers historiaue ou archives
− Fichiers tempiraires
VIII.3. mode d'accès
On appelle mode d'accès à un fichier la façon de retrouver une donnée dans ce fichier. Il
existe deux modes d'accès principaux:
VIII.3.1. Les fichiers à accès séquentiel
L’accès séquentiel: possible sur tous les types de support et avec tous les types de fichiers
Pour accéder à un article particulier, on doit avoir parcouru tous les articles précédents sur
le support.
VIII.3.2. Les fichiers à accès direct
l'accès direct: possible seulement sur support adressable avec des fichiers structurés
On peut se positionner directement sur l'enregistrement voulu à partir de son emplacement
sur le support (ou à partir d’une clé) sans avoir à parcourir les précédents. Un fichier à accès
direct peut être vu en quelque sorte comme un énorme tableau stocké sur support non
volatile.
VIII.4. Déclaration
Dans un programme, un fichier est désigné par une variable, qu'on déclare dans la section
des variable.
Pour déclarer un fichier séquentiel structuré, il faut indiquer le type des articles ou
enregistrements (déclaré au préalable) qui composent ce fichier.
syntaxe
Var:
<nom_fichier> : fichier de <enregistrement>
VIII.4.1. Assignation
Avant l’utilisation d’un fichier dans un programme, il faut d’abord l’assigner (c'est-à-dire
[créer et ] établir un lien entre le non physique te le nom logique
Edition - 44 -

ASSIGNER (<nom logique fichier>, <chemin d’accès au fichier physique>)
Exemple
Type
Mat : chaine[10]
Nom : chaine[20]
Pren : chaine[30]
Age, poids : entier
Sexe : caractère
FIN
Var
Fich :Fichier de eleve
Etudiant : eleve
DEBUT
ASSIGNER (Fich,’C:cupsan_pedroalgo.txt’)
VIII.5. Instructions sur les fichiers
VIII.5.1. ouverture et fermeture
La première instruction après l’assignation d’un fichier dans un programme est son
ouverture.
Comme un fichier ne se trouve pas en mémoire centrale (mais en périphérique), il n'est pas
accessible directement par le programme (seule la mémoire centrale est accessible
directement). Il est nécessaire de l'ouvrir avant de pouvoir l'utiliser. L'ouverture permet la
réservation d'une mémoire tampon en mémoire centrale pour les échanges entre le disque
et la mémoire centrale.
Pendant l’ouverture il faut préciser le traitement ou les traitements qui seront faits sur le
fichier.
Lecture (L) ; Ecriture(E), et Lecture / Ecriture (L/E)
exemple
OUVRIR(Fich,E)
La dernière instruction est la fermeture du fichier
syntaxe
FERMER(<onm fichier>)
VIII.5.2. Instruction sous jacentes
Ces instructions ne concernent pas globalement le fichier mais un enregistrement de ce
dernier.
A. LIRE
L'instruction LIRE permet de transférer des articles d'un fichier existant dans une (ou
plusieurs) variable du programme. La variable lue doit obligatoirement être de même
structure (c'est-à-dire du même type) que les articles du fichier. Le fichier lu doit
obligatoirement exister.
syntaxe
LIRE (nom_fichier, nom_variable_de type enregsitrement )
Ou bien
Edition - 45 -

LIRE (nom_variable_de type enregsitrement )
Exemple
LIRE (Fich, etudiant)
Cette instruction récupère une occurrence d’un élève du fichier et l’affecte dans la variable
etudiant.
Remarque
La lecture nécessite un test de fin de fichier
Un indicateur booléen du système de fichier nous permet de savoir si nous sommes à la fin
du fichier. Nous le nommons FinDeFichier (FDF) ou en anglais (EOF)
2. ECRIRE
L'instruction Ecrire permet de recopier le contenu d'une variable (contenue en mémoire
centrale) à la fin du fichier (au premier article vide). Ecrire permet donc soit de créer un
nouveau fichier, soit d'agrandir un fichier en lui ajoutant un article à la fin . elle permet de
sauvegarder les enregistrement sur un support physique
syntaxe
ECRIRE (nom_fichier, nom_variable_de type enregsitrement )
Exemple
ECRIRE (Fich, etudiant)
Remarque
Toute nouvelle information écrite dans un fichier séquentiel se met systématiquement à la
fin du fichier.
3. REECRIRE
L'instruction Reecrire permet de modifier le contenu d’un enregistrement d’un fichier
Toute modification est en général précédée d’une recherche.
Syntaxe
REECRIRE (nom_fichier, nom_variable_de type enregsitrement )
Exemple
REECRIRE (Fich, etudiant)
4. SUPPRIMER
L'instruction Supprimer permet de suppriment le un enregistrement d’un fichier
Syntaxe
SUPPRIMER (nom_fichier, nom_variable_de type enregsitrement )
Exemple
SUPPRIMER (Fich, etudiant)
Remarque
Les deux dernières instructions ne peuvent être exécutées qu’âpres lecture d’un
enregistrement. C’est le dernier enregistrement le plus récemment lu qui est concerné.
Edition - 46 -

IX. LES STRUCTURES DE DONNEES DYNAMIQUES
Introduction
Ce sont des structures de données encore plus évoluées que celles vues précédemment : le
structures de données ‘’statiques’’. En effet, avec celles-ci, d’abord la réservation d’espace
mémoire, une fois faite, demeure jusqu’à terme de l’exécution du programme. Ensuite,
parfois pour gérer une certaine quantité d’informations, nous sommes obligés de faire une
importante réservation d’espace mémoire, de peur de débordement quoiqu’en réalité, seule
une partie est réellement utilisée : quel gâchis d’espace mémoire. Enfin, ces structures sont
utilisées isolément.
En fait, pour résoudre certains problèmes de façon optimale, nous avons besoin de :
juste utiliser l’espace mémoire qu’il faut,
libérer l’espace mémoire dont on a plus besoin après utilisation et,
enfin chaîner des structures (les lier entre elles) pour construire des structures plus
complexes et plus souples : c’est la notion de structure de données dites dynamiques dont
le leitmotiv est le pointeur.
Le terme ‘’dynamiques’’ signifie que la taille de ces structures de données n’est pas fixité,
figée : elle est susceptible de variation : s’agrandir ou rétrécir au besoin. Ainsi la gestion de
l’espace mémoire peut se faire de manière optimale.
IX.1. Notion d’adresse en mémoire
A la déclaration d’une variable, le compilateur réserve la place nécessaire (correspondant
au type de données déclaré) en mémoire.
En effet, pour accéder à un endroit donné de la mémoire, la machine utilise un système
d’adressage. A chaque emplacement mémoire correspond une adresse. Ainsi, lorsque le
système réserve un emplacement mémoire pour une variable il réserve une adresse
mémoire pour cette variable. Chaque variable a donc une adresse en mémoire.
IX.2. Définition d’un pointeur
Un pointeur est une variable qui au lieu de contenir l’information proprement dite va contenir
l’adresse mémoire de cette information (l’emplacement de cet objet).
Ainsi connaissant son pointeur (i. e la variable qui contient son emplacement), on peut
facilement atteindre l’objet en question.
L’objet peut être un type simple (entier, caractère, chaîne de caractères…) ou structuré
(enregistrement, tableaux…).
Syntaxe
TYPE
Nom_pointeur = ↑type_pointé // Avec type_pointé ; un type simple, Structuré, une cellule
exemple
TYPE
P = ↑ ENTIER
VAR
d : P
Edition - 47 -

Cette déclaration signifie que la variable d est de type P (c’est-à-dire un pointeur sur un
entier), et va contenir l’adresse d’un entier.
Remarque
L'adresse contenue dans un pointeur est celle d'une variable qu'on appelle variable pointée.
On dit que le pointeur pointe sur la variable dont il contient l'adresse.
Un pointeur est associé à un type de variable sur lequel il peut pointer. Par exemple, un
pointeur sur entier ne peut pointer que sur des variables entières.
NB:
Quand la variable pointeur ne pointe sur rien, elle doit contenir une valeur spéciale qui ne
doit pas pouvoir être confondue avec une adresse. On utilise le mot réservé "NIL" pour
indiquer cela.
IX.3. utilité
On utilise un pointeur pour mémoriser l'emplacement d'une autre variable.
Il est très rare d'affecter directement une adresse à un pointeur. On affecte en général
l'adresse d'une variable existante.
IX.4. Les différents types de pointeurs
Nous avons différents types de pointeurs, en fonction du type de l’objet. Ainsi nous avons
des pointeurs qui pointent sur :
des entiers,
des caractères,
des réels
des enregistrements,
des chaînes de caractères
des tableaux
des enregistrements…
IX.5. L’affectation à un pointeur
L’opération d’attribution directe d’une valeur (ou affectation) à un pointeur (sauf pour des
utilisations bien précises) est pratiquement interdite. Car la valeur attribuable à un pointeur
est une adresse mémoire. Or, sans ce rapport, c’est la système d’exploitation qui se charge
de l’allocation de la mémoire centrale et donc de l’attribution des adresses mémoire. Pour le
faire, il faudra avoir une parfaite connaissance de l’occupation de la mémoire centrale.
Lors de la déclaration d’un pointeur, on lui réserve une zone mémoire qui va servir à
contenir l’adresse de l’objet. Mais l’espace mémoire pour l’objet, n’est cependant pas encore
réservé. Ainsi, pour attribuer une valeur à un objet pointé, il faudrait :
− D’abord réserver l’espace mémoire de cet objet. Cette réservation d’espace mémoire
se fait par le mot clé :NOUVEAU dont la syntaxe est
NOUVEAU (nom_variable_pointeur)
− Ensuite, attribuer une valeur à l’objet pointé et qui se fait par :
Nom_variable_pointeur ↑  valeur
NB :
Nom_variable_pointeur ↑ : désigne l’objet pointé par Nom_variable_pointeur.
Edition - 48 -

Exemples
TYPE
P = ↑ ENTIER
VAR
d :P
DEBUT
NOUVEAU (d)
(* Réservation de l’espace mémoire pour contenir l’entier pointé par d*)
d↑  5
(*Affectation de la valeur 5 à l’entier pointé par d*)
--------
Explication schématique
d : P d
Réservation de l’espace mémoire pour le pointeur d.
Le contenu de d est encore non défini pour l’instant.
NOUVEAU (d)
1) Désormais, d contient l’adresse de l’espace créé pour contenir, l’entier.
d ↑  5
Edition - 49 -
d
Espace réservé (créé) et pointé par d (d ↑).
@ 1
d
Espace réservé (créé) et pointé par d (d ↑).
@ 1
5

IX.6. Les différentes opérations sur un pointeur.
Nous avons généralement les deux opérateurs suivants :
(-) et (+).
Ceux-ci s’appuient sur l’espace mémoire occupé par les différents types en question.
Rappel :
1 caractère occupe 1 octet
1 entier occupe 2 octets
1 réel occupe 4 octets
Soit P, un pointeur sur un objet de k octets, (P + 1) fait pointer le pointeur P sur la case
mémoire en sautant de k octets depuis la case pointée initialement par P.
Exemple :
TYPE
P = ↑ ENTIER
VAR
d : P
d d+1 d+2
Etat initial
Ici on saute de 2 octets car c’est un entier
Exercice
Soit :
TYPE
P ↑ ENTIER
G = ↑ CARACTERE
T = ↑ REEL
VAR
d : P
e : G
f : T
A partir d’un état, représentez les cas suivants :
e ; e – 1, e + 2, e + 5 ;
f ; f + 1, f – 2, f + 3
IX.7. Les procédures de construction de structures de données dynamiques
IX.7.1.cellule
Une cellule est une variable content deux champs :
− Un champ contenant de l’information qui peut être un type simple ou structuré.
Ce champ peut être constitué de un (1) ou plusieurs informations de type identique ou
différent.
− Un champ contenant l’adresse
Edition - 50 -

Cette adresse peut être : nulle c’est-à-dire ne contenant pas l’adresse d’une autre cellule.
Ce champ peut être constitué d’une (1) ou plusieurs adresses également.
Une cellule est atteinte par son adresse donc grâce à son pointeur.
IX.7.2.Déclaration de syntaxe d’une cellule
Elle se fait également dans la partie TYPE, comme suit :
Exemple
IX.7.3.accès aux différents champs d’une cellule
L’accès aux différents champs d’une cellule se fait selon la syntaxe suivante :
Edition - 51 -
TYPE
Nom_cellule = ENREGISTREMENT
Champ1 : type_champ1
--------------------- champ information
---------------------
Champ n : type_champ n
Pointeur1 : type_pointeur1
-------------------- champ adresse
--------------------
Pointeur n : type_pointeur n
Pointeur
La flèche signifie ‘’Pointe sur…’’ c’est-à-dire contient l’adresse de…
L’adresse de la
Cellule est à champ Information champ Adresse
l’intérieur
Cellule
Info 1 …… Info n Adresse1 …… Adresse n
TYPE
R = ↑ Cel ;
Cel = ENREGISTREMENT
a : CARACTERE champs Information
b : CHAINE [15]
e : R champ Adresse
FIN
VAR
m : R

Exemple
m ↑ . b ; cette instruction permet d’accéder au champ b de la variable m.
Avec m = pointeur contenant l’adresse d’une cellule.
m↑ = cellule pointée et,
m↑ . b = le champ b de la cellule pointeur par m.
IX.7.4.L’opération d’affectation avec les pointeurs
Elle se fait selon deux syntaxes :
Syntaxe 1
Nom_variable_pointeur ↑ . Nom_champ  valeur ;
ou
Syntaxe 2
Nom_variable_pointeur 1  Nom_variable_pointeur 2 ;
Exemples
m ↑ . b ‘’IG2’’
Pour dire d’affecter la valeur ‘’IG2’’ au champ b de la cellule pointée par le pointeur m.
m ↑ . e  NULL
Pour dire que le champ 2 (qui est aussi un pointeur) de la cellule pointée par m, ne pointe
sur rien.
IX.7.5.Les différentes opérations portant sur une cellule
Il existe deux opérations essentielles portant sur les pointeurs :
− la création d’une cellule
− la destruction d’une cellule.
Création d’une cellule
Cette opération permet de réserver un espace mémoire pour une cellule et d’ »attribuer
l’adresse de cet espace dans une variable de type pointeur.
La syntaxe est :
NOUVEAU (nom_variable_pointeur)
Cette instruction stipule la création d’une cellule qui sera pointée par
nom_variable_pointeur ;
Exemple
TYPE
R = ↑ Cel
Cel = ENREGISTREMENT
a : CARACTERE
b : CHAINE [15]
e : R
FIN
VAR
m : R
------------------------------------------------
Nouveau (m)
Edition - 52 -
Nom_pointeur ↑. nom_champ
@
@

IX.7.6.Destruction d’une cellule
Elle consiste à libérer l’espace mémoire occupé par cette cellule (donc à effacer cette
cellule de la mémoire centrale).
Le mot clé utilisé est DETRUIRE et la syntaxe est :
DETRUIRE (nom_variable_pointeur)
Exemple
TYPE
R =↑ Cel
Cel = EBREGISTREMENT
a : CARACTERE
b: CHAINE [15]
e : R
FIN
VAR
m : R
------------------------------------------
DETRUIRE (m)
Edition - 53 -

IX.8. Exercice d’application
Ecrivez un algorithme qui crée une variable dynamique de type ELEVE et qui permette de
saisir les champs de cette variable.
CORRECTION
Description des ressources
Rôle Identificateur Type Nature Commentaires
Entrée Pt Pt ELEVE Variable Pointeur
d’élève
Description des actions
Création de la variable dynamique via le pointeur Pt
Saisir les champs.
Rédaction de l’algorithme
Algorithme Saisi_dynami
TYPE
ELEVE = ENREGITREMENT
Mat : CHAINE [10]
Nom : CHAINE [20]
Pren : CHAINE [45]
Age, Poids, Taille : REEL
Sex : CARACTERE
Note : TABLEAU[15][3] DE REEL
Datnais = ENREGISTREMENT
JJ, MM, AN : ENTIER
FIN
FIN
PtELEVE = ↑ELEVE
VAR
Pt : PtELEVE
I, J : ENTIER
DEBUT
NOUVEAU (Pt)
ENTRER (Pt↑. Mat, Pt.Nom, Pt↑.Pren, Pt↑.Age)
ENTRER (Pt↑. Poids, Pt↑. Taille, Pt↑. Sex)
ENTRER (Pt↑. Datnais, JJ, Pt↑. Datnais.MM)
ENTRER (Pt↑. Datnais.AN)
POUR I  1 A 15 FAIRE
POUR J  1 A 3 FAIRE
ENTRER (Pt↑.Note [I][J] )
FPOUR
FPOUR
FIN.
Edition - 54 -

INITIATION_ALGO_NAB_2006

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (9)

En vedette

En vedette (20)

Similaire à INITIATION_ALGO_NAB_2006

Similaire à INITIATION_ALGO_NAB_2006 (20)

INITIATION_ALGO_NAB_2006