TDI CHAPITRE I

Introduction

INTRODUCTION
I.Introduction
1. Définitions
a. L’information
L’information est le support formel d’un élément de connaissance humaine
susceptible d’être représentée à l’aide de conventions (codages) afin d’être
conservée, traitée ou communiquée.

b. La donnée
Une donnée est la représentation d’une information sous une forme
conventionnelle (codée) destinée à faciliter son traitement.

c. Traitement de l’information
Le traitement de l’information consiste à appliquer un ou plusieurs opérations sur
une information en entrée pour générer des résultats en sortie

schéma simplifié du traitement de

l’information

d. L’ordinateur
Un ordinateur est une machine électronique programmable destinée au
traitement de l’information.

e. L’informatique
L’informatique est la science du traitement de l’information dans les domaines
scientifiques, techniques, économiques et sociaux.
Exemples de traitements de l’information par informatique :
-démontrer un théorème (mathématique)
-faire jouer aux échecs (intelligence artificielle)
-dépouiller un sondage (économie)
-gérer un robot industriel (atelier)
-facturation de produits (entreprise)
-traduire un texte (linguistique)
-imagerie médicale (médecine)
-formation à distance (éducation)
-Internet (grand public)...etc

1/23
TDI CHAPITRE I
Introduction

f. Le système informatique
Ensemble de matériels (ordinateurs, réseaux) et de logiciels permettant
d'acquérir, de stocker, de traiter, de communiquer des données pour répondre
aux besoins en information de ses utilisateurs.

g. Le système d’information
En télécommunications et en informatique, le terme système d'information (ou
SI) possède les significations suivantes :* Un système, automatisé ou manuel, qui
comprend des hommes, des machines et des méthodes organisés pour assembler,
transmettre et répandre des données qui représentent de l'information pour les
utilisateurs. ...

h. Les réseaux informatique

Un réseau informatique est un ensemble d'équipements interconnectés qui
servent à acheminer un flux d'informations. Sa naissance est le fruit du mariage
entre Informatique et Télécommunications.

2/23
TDI CHAPITRE II
Algorithmique (Notions de base)

ALGORITHMIQUE
(NOTIONS DE BASE)
I Introduction
1. Notion de programme informatique
Un programme, informatique, se définit comme une série d’instructions dans un
langage que l’ordinateur comprend. Un bon programme doit :
- fonctionner
- fonctionner selon les spécifications
- pouvoir être modifié facilement
- être prêt à temps
- être très bien documenté
- utiliser la mémoire efficacement

2. Notion d’algorithme
- Un algorithme décrit un traitement sur un certain nombre, fini, de données
(éventuellement aucune).
- Un algorithme est la composition d'un ensemble fini d'étapes, chaque étape
étant formée d'un nombre fini d'opérations dont chacune est :
- définie de façon rigoureuse et non ambiguë;
- effective, c'est-à-dire pouvant être effectivement réalisée par une
machine: cela correspond à une action qui peut être réalisée avec un
papier et un crayon en un temps fini; par exemple la division entière est
une opération effective, mais pas la division avec un nombre infini de
décimales.
- Quelle que soit la donnée sur laquelle il travaille, un algorithme doit
toujours se terminer après un nombre fini d'opérations, et fournir un
résultat.
Un algorithme doit répondre aux 5 caractéristiques suivantes :
La finitude
La précision
Le domaine des entrées
Le domaine des sorties
L’exécutabilité

3. Organigramme et pseudo-code
Historiquement, plusieurs types de notations ont représenté des algorithmes.
Il y a eu notamment une représentation graphique, avec des carrés, des losanges,
etc. qu’on appelait des organigrammes. Aujourd’hui, cette représentation est
quasiment abandonnée, pour deux raisons. D’abord, parce que dès que
l’algorithme commence à grossir un peu, ce n’est plus pratique du tout. Ensuite

3/23
TDI CHAPITRE II
Algorithmique (Notions de base)

parce que cette représentation favorise le glissement vers un certain type de

programmation, dite non structurée (voir les chapitres suivants), que l’on tente
au contraire d’éviter.
C’est pourquoi on utilise généralement une série de conventions appelée «
pseudo-code », 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.

4. Algorithmique et programmation
Les ordinateurs, quels qu’ils soient, ne sont fondamentalement capables de
comprendre que quatre catégories d'ordres (en programmation, on n'emploiera
pas le terme d'ordre, mais plutôt celui d'instructions). Ces quatre familles
d'instructions sont :

• l’affectation de variables
• la lecture / écriture
• les tests
• les boucles

Un algorithme informatique se ramène donc toujours au bout du compte à la

combinaison de ces quatre petites briques de base. Il peut y en avoir quelques
unes, quelques dizaines, et jusqu’à plusieurs centaines de milliers dans certains
programmes de gestion (cependant, la taille d’un algorithme ne conditionne pas en
soi sa complexité: de longs algorithmes peuvent être finalement assez simples, et
de petits très compliqués).
Pourquoi apprendre l’algorithmique pour apprendre à programmer ? En quoi a-t-on
besoin d’un langage spécial, distinct des langages de programmation
compréhensibles par les ordinateurs ?
Parce que l’algorithmique exprime les instructions résolvant un problème donné
indépendamment des particularités de tel ou tel langage. Il vaut mieux faire
d’abord le plan et rédiger ensuite que l’inverse…
Apprendre l’algorithmique, c’est apprendre à manier la structure logique d’un
programme informatique. Cette dimension est présente quelle que soit le langage
de programmation ; mais lorsqu’on programme dans un langage (en C, en Visual
Basic, etc.) on doit en plus se colleter les problèmes de syntaxe, ou de types
d’instructions, propres à ce langage. Apprendre l’algorithmique de manière
séparée, c’est donc sérier les difficultés pour mieux les vaincre.

II.Elements de base des algorithmes

1. Notion de variable

4/23
TDI CHAPITRE II
Algorithmique (Notions de base)

a. Les types de données

Dans un programme informatique, on va avoir en permanence besoin de stocker
provisoirement des valeurs. Il peut s’agir de données issues du disque dur,
fournies par l’utilisateur (frappées au clavier), ou autres. Il peut aussi s’agir de
résultats obtenus par le programme, intermédiaires ou définitifs. Ces données
peuvent être de plusieurs types : elles peuvent être des nombres, du texte, etc.
On peut dire qu’un type de données est l’ensemble de valeurs de même nature
qu’une variable peut avoir

b. Les variables
Pour employer une image, une variable est une boîte, que le programme
(l’ordinateur) va repérer par une étiquette (Nom de variable). Pour avoir accès au
contenu de la boîte, il suffit de la désigner par son étiquette.
Dans l’ordinateur, physiquement, il y a un emplacement de mémoire, repéré par
une adresse binaire. Si on programmait dans un langage directement
compréhensible par la machine, on devrait désigner nos données par des chiffres
binaires (0 et 1).
Les langages informatiques plus évolués (ce sont ceux que presque tout le monde
emploie) se chargent précisément, entre autres rôles, d’épargner au
programmeur la gestion fastidieuse des emplacements mémoire et de leurs
adresses. Il est beaucoup plus facile d’employer des noms de variables de son
choix, que de devoir manier des adresses binaires.
La première chose à faire avant de pouvoir utiliser une variable est de créer la
boîte et de lui coller une étiquette. Ceci se fait tout au début de l’algorithme,
avant même les instructions proprement dites. C’est ce qu’on appelle la
déclaration des variables Le nom de la variable (l’étiquette de la boîte) obéit à
des impératifs changeant selon les langages. Toutefois, une règle absolue est
qu’un nom de variable peut comporter des lettres et des chiffres, mais qu’il
exclut la plupart des signes de ponctuation, en particulier les espaces. Un nom de
variable correct commence également impérativement par une lettre. Quant au
nombre maximal de signes pour un nom de variable, il dépend du langage utilisé.
En pseudo-code algorithmique, on est bien sûr libre du nombre de signes pour un
nom de variable.
Lorsqu’on déclare une variable, il ne suffit pas de créer une boîte (réserver un
emplacement mémoire) ; encore doit-on préciser ce que l’on voudra mettre
dedans, car de cela dépendent la taille de la boîte (de l’emplacement mémoire) et
le type de codage utilisé.

2. Expression et opérateur
Une expression est un ensemble de valeurs, reliées par des opérateurs, et
équivalent à une seule valeur
Par exemple, voyons quelques expressions de type numérique. Ainsi :

5/23
TDI CHAPITRE II
Algorithmique (Notions de base)

7
5+4
123-45+844
T-12+5-R
sont toutes des expressions valides, à condition que T et R soient bien des
nombres. Car dans le cas contraire, la quatrième expression n’a pas de sens. En
l’occurrence, les opérateurs employés sont l’addition (+) et la soustraction (-).
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.
Les opérateurs possibles dépendent du type des valeurs qui sont en jeu. On peut
avoir :

a. Opérateurs numériques :
Ce sont les quatre opérations arithmétiques :
+ : addition
- : soustraction
* : multiplication
/ : division
Mentionnons également le ^ qui signifie « puissance ». 45 au carré s’écrira donc
45 ^ 2.
Enfin, on a le droit d’utiliser les parenthèses, avec les mêmes règles qu’en
mathématiques. La multiplication et la division ont « naturellement » priorité sur
l’addition et la soustraction. Les parenthèses ne sont ainsi utiles que pour
modifier cette priorité naturelle.
Cela signifie qu’en informatique, 12 * 3 + 5 et (12 * 3) + 5 valent strictement la
même chose, à savoir 41. Pourquoi dès lors se fatiguer à mettre des parenthèses
inutiles ?
En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96. Rien de difficile là-dedans, que du
normal.

b. Opérateur alphanumérique : & ou +

Cet opérateur permet de concaténer, autrement dit d’agglomérer, deux chaînes
de caractères. Par exemple :
Variables A, B, C en Caractère
Début
A ← "Salut "
B ← "tout le monde"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "Salut tout le monde"

c. Opérateurs logiques (ou booléens) :

Il s’agit du ET, du OU, du NON et du mystérieux (mais rarissime XOR : le ou
exclusif).

6/23
TDI CHAPITRE II
Algorithmique (Notions de base)

3. L’affectation
Consiste à mettre la valeur d’une variable dans une autre variable
Pseudo-code : Variable1  Variable2
Exemple x10 ; yx

4. Lecture et écriture
La lecture permet d’attribuer une valeur à un objet en allant lire sur un
périphérique d’entrée (exemple clavier) et elle range cette valeur dans l’objet.

Pseudo-code Organigramme

lire(Nom de variable) lire(Nom de variable)

Exemple : Lire(x)

La lecture permet d’écrire sur un périphérique de sortie l’information spécifiée

(exemple affichage à l’écran)

Pseudo-code Organigramme

écrire(Nom de variable) écrire(Nom de variable)

Exemple : écrire(« salut »)
En organigramme les instructions de lecture écriture sont mises dans un losange

5. Le bloc début et fin

Chaque programme possède un début et une fin
Pseudo-code Organigramme

Début
début
.
.
Fin
fin

6. Exemples (voir exercices)

III.Structures de base des algorithmes
1. Structures alternatives
a. L’instruction SI
L’instruction si permet de faire un traitement si la condition est vrai un autre
traitement sinon

7/23
TDI CHAPITRE II
Algorithmique (Notions de base)

Pseudo-code Organigramme

Si condition alors
Fausse Vrai
Bloc d’instructions condition
Sinon
Bloc d’instructions
Traitement si Traitement si
Fin si condition fausse condition vrai
Exemple : si x>=0 alors
Ecrire (x,« est positif »)
Sinon
Ecrire(x,« est négatif »)
Fin si

b. L’instruction SELON
L’instruction selon permet d’évaluer plusieurs cas pour des valeurs d’une variable
de type simple tel que caractère ou entier. C’est une structure que l’on trouve
dans tous les langages de programmation et qui permet d’éviter des si imbriqués

2. Structures itératives (les boucles)

Les structures itératives permettent de répéter un traitement zéro ou plusieurs
fois.

a. La boucle tant que

La boucle Tant que permet de répéter un traitement Tant que la condition est
vrai
Pseudo-code Organigramme

Tant que condition faire

Fausse Vrai
Bloc d’instructions condition
Fin Tq
Exemple : Traitement de la
X10 boucle
Tant que x>=0 Faire
Xx-1
Fin Tq

b. La boucle répéter…. jusqu'à

La boucle Répéter jusqu'à permet de répéter un traitement au moins une fois
jusqu'à ce que la condition est vrai la condition est vérifiée à la fin de la boucle

Pseudo-code Organigramme

8/23
TDI CHAPITRE II
Algorithmique (Notions de base)

Répéter
Bloc d’instructions
Jusqu'à condition Traitement
Exemple :
X10
Répéter Fausse
Vrai condition
Xx-1
Jusqu'à x=0

c. La boucle pour
La boucle pour est une structure qui existe dans la majorité des langages de
programmation et qui permet de répéter un traitement un certain nombre de
fois, le nombre de répétition est connu à l’avance. La boucle pour utilise une
variable compteur qui sera incrémentée ou décrémentée automatiquement selon
la valeur du pas
Pseudo-code

Pour variable=valeur initiale à valeur finale pas valeurs

Traitement de la boucle

Fin pour
Exemple
Début
Pour i=5 à 100 pas 5
Ecrire (i, « est un multiple de 5 »)
Fin pour

d. La boucle répéter tant que

La boucle répéter tant que est semblable à celle de répéter jusqu'à sauf que le
traitement est répété tant que la condition est vraie
Pseudo-code Organigramme

Répéter
Bloc d’instructions
Tant que condition Traitement
Exemple :
X10
Répéter Fausse
condition
Xx-1 Vrai
Tant que x>0

9/23
TDI CHAPITRE II
Algorithmique (Notions de base)

10/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

CHAPITRE II

Algorithmes liés à l’utilisation de tableaux.

I.Introduction
1. Définition :
Une liste est une suite d’éléments de même type. Dans un programme, pour
ranger les éléments d’une liste on peut utiliser plusieurs variables simples mais
lorsque le nombre d’éléments Atteint une certaine limite il devient impossible
d’adopter cette solution.

La structure de tables ou (tableaux) vient résoudre le problème : la liste

est définie en mémoire sous forme d’un tableau ayant un seul nom et un seul
type : « type des éléments de la liste ».

Pour désigner un élément de liste on utilise le nom du tableau suivi par le

numéro d’ordre de l’élément du tableau que l’on veut utiliser.

Exemple :
Considérons le tableau T suivant :

45 20 13 5 95 10 7 T:

T(5) : représente le cinquième élément du tableau T c'est-à-dire 95

2. Algorithme de chargement d’un tableau :

L’opération de chargement consiste à affecter aux éléments du tableau

des valeurs particulières (produites par un traitement) ou des valeurs
introduites par clavier (lecture).

a. Chargement par lecture :

Soit T un tableau de N éléments écrire l’algorithme qui lit les N éléments du tableau

Début
I0
Tant que i<N
I I + 1
Lire(T(i))
Fin Tq
Fin

11/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

b. Chargement par traitement

Soit T un tableau de N éléments écrire l’algorithme qui rempli le tableau T par les N
multiples de 10
Début
I0
Répéter
I I+1
T(I) I*10
Jusqu'à I=10
Fin

II. Recherche dans un tableau :

C’est l’opération qui consiste à trouver un ou plusieurs éléments qui

peuvent exister à l’intérieure du tableau. Il y a plusieurs types de recherche, les
plus fréquentes consiste à retrouver un élément qui répond à une condition
donnée. Par exemple : chercher l’élément qui est égale à 20 et afficher son rang
dans le tableau. La recherche peut aboutir lorsque l’élément existe on dit que la
recherche est fructueuse, elle peut échouer si l’élément n’existe pas, plusieurs
algorithmes sont possibles. On va essayer de voir les algorithmes les plus
utilisés.

1. La recherche séquentielle :
La recherche séquentielle consiste à balayer le tableau séquentiellement
en partant du 1er élément ou du dernier jusqu'à trouver l’élément recherché ou
arriver à la fin du tableau.

Exemple : soit à chercher dans une liste de 20 éléments rangés dans un

tableau T un élément X donné. Afficher la position de l’élément s’il existe et le
message « non troué » s’il n’existe pas.

Algorithme : recherche de l’élément x dans un tableau à N éléments

Début
Lire (X)
I1
Tant que I< N et T(I)‡X
II+1
Fin Tq
Si T(I)=X alors
écrire « élément trouvé à la position »; I)
sinon
écrire « non trouvé ».
Fin si

12/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

Fin

2. Recherche dichotomique : recherche dans un

tableau trié
La recherche dichotomique est appliquée sur les listes triées. Elle consiste
à limiter les champs de recherche successivement jusqu’à retrouver l’élément
recherché ou avoir un champs de recherche qui ne contient aucun élément.
Chaque fois on défini un intervalle de recherche par une borne inférieure et
supérieure et on se positionne au milieu pour faire le test. Ce traitement se
répète jusqu'à trouver l’élément ou arriver à un intervalle vide.

Algorithme de la recherche dichotomique.

Début
Lire(x)
M1
Binf1
BsupN
Tant que Binf<=Bsup et x ‡ T(m)
ME((Binf+Bsup)/2) // E : représente la partie entière
Si x>T(m) alors
Binfm+1
Fin si
Si x<T(m) alors
Bsupm-1
Fin si
Fin Tq
Si x=T(m) alors
Ecrire(« Elément trouvé »)
Sinon
Ecrire(« Elément non trouvé »)
Fin si
Fin
Remarque : La recherche d’un élément dans un tableau de 1000 éléments
nécessitera pour la recherche séquentielle dans le cas le plus défavorable la
répétition de la recherche pendant 1000 fois pour la recherche dichotomique le
traitement sera répété dans le cas le plus défavorable moins de 10 fais.

III. Les tris

1. Définition
Un tri consiste à arranger des données selon un ou des critères bien déterminés.

13/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

Par exemple trier des données selon un ordre alphabétique croissant ou

décroissant.
Le tri est une des opérations des plus importantes des traitements sur
ordinateur. Différentes méthodes peuvent être envisagées suivant la nature du
problème à traiter.
En informatique, on distingue deux grandes catégories de tri:
• le tri interne,
• le tri externe.
Par tri interne, on comprend les méthodes de tri qui gardent l'ensemble des
éléments à trier en mémoire centrale au moment de l'exécution de l'algorithme
de tri. Si cela ne pouvait se faire, soit parce que le nombre d'éléments à trier
est trop grand, soit parce que les éléments sont d'une taille trop importante, il
faudrait faire appel à des méthodes de tri externe.
Les méthodes de tri externe ne gardent en mémoire centrale qu'une partie des
éléments à trier, les autres étant par conséquent temporairement mémorisés sur
des fichiers externes.
Comme certaines méthodes de tri externe utilisent aussi en partie des méthodes
de tri interne, nous étudierons dans ce chapitre quelques algorithmes classiques
de tri interne.

2. Les méthodes de tris

a. Tri par sélection
-Méthode :
On cherche l’élément de plus petite valeur pour l’échanger avec l’élément en
première position; puis on cherche l’élément ayant la deuxième plus petite valeur
pour l’échanger avec l’élément en deuxième position ; et ainsi de suite.
2 6 1 3 1 7
0
1 6 2 3 1 7
0
1 1 2 3 6 7
0
1 1 3 2 6 7
0
1 1 3 6 2 7
0
1 1 3 6 7 20
Il faut :
• 1 boucle pour parcourir le tableau et sélectionner tous les éléments ;
• 1 boucle pour rechercher le minimum parmi les éléments non triés.

14/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

-Algorithme : Soit à trier un tableau T de N éléments dans l’ordre croissant

Début
Pour i=1 à N-1
Mini
Pour j=i+1 à N
Si T(j)<T(min) alors
Minj
Fin si
Fin pour
XT(i)
T(i)T(min)
T(min)x
Fin pour
Fin

b. Tri par insertion

-Méthode :
on considère les éléments les uns après les autres en insérant chacun à sa place
parmi les éléments déjà triés.
2 6 1 3 1 7
0
6 2 1 3 1 7
0
1 6 2 3 1 7
0
1 3 6 2 1 7
0
1 1 3 6 2 7
0
1 1 3 6 7 20
Il faut :
• 1 boucle pour parcourir le tableau et sélectionner l’élément à insérer ;
• 1 boucle pour décaler les éléments plus grands que l’élément à insérer ;
• insérer l’élément.
-Algorithme
Début
Pour i=2 à N
PT(i)
Ji
Tant que j>1 et T(j-1)>p
T(j)T(j-1)
Jj-1

15/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

Fin Tq
T(j)p
Fin pour
Fin

c. Tri bulle
-Méthode :
En commençant du 1er élément on compare chaque élément à son suivant si c’est
supérieur on permute et on passe à l’élément suivant après avoir compté le
nombre de permutation on continu jusqu'à la fin du tableau, on répète ce
traitement jusqu'à ce que le nombre de permutation est nul.
-Algorithme
Début
Répéter
Permuter=faux
I1
Répéter
Si T(i)>T(i+1) alors
Permutervrai
X<-T(i)
T(i)T(i+1)
T(i+1)x
Fin si
Ii+1
Jusqu'à i=N
Jusqu'à permuter=faux
Fin

d. Tri par permutation

-Méthode :
En commence au 1er élément du tableau on compare chaque élément avec son
successeur si ce dernier est inférieur on permute et on revient au début de la
liste sinon on continu jusqu'à ce qu’on arrive à l’avant dernier èlèment.
-Algorithme
Début
I1
Tant que i<N
Si T(i)>T(i+1) alors
XT(i)
T(i)T(i+1)
T(i+1)x
I1

16/23
TDI CHAPITRE III
Algorithmique (Les tableaux)

Sinon
Ii+1
Fin si
Fin Tq
Fin

17/23
TDI CHAPITRE IV
Algorithmique (Les procédures et les fonctions)

CHAPITRE III

Les procédures et les fonctions.

I. 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 structurée ou
modulaire, qui repose sur l'écriture de sous-programmes.
Un sous-programme est, comme son nom l'indique, un programme réalisant un
traitement particulier qui s'exécute à l'intérieur 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, sinus,
log …). 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
Nous allons étudier d'abord les procédures simples, puis les fonctions.

II. LES PROCEDURES

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.
Mais contrairement à un programme, un sous-programme ne peut pas s'exécuter
indépendamment d'un autre programme.
Exemple de DEFINITION d'une procédure:

18/23
TDI CHAPITRE IV
Algorithmique (Les procédures et les fonctions)

Procédure ligneEtoile( )
Var
i : entier
Début
Pour i = 1 jusqu'à 10 Faire
Ecrire ('*')
FinPour
Ecrire('\n') //retour à la ligne
FinProc
Cette procédure permet d'afficher une ligne de 10 étoiles puis passe à la ligne.

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.

Programme RectangleEtoile
Var
nlignes: entier
cpt : entier
Début
Ecrire("Ce programme dessine un rectangle d'étoiles. Combien voulez-vous de
lignes?")
Lire(nlignes)
Pour cpt=1 jusqu'à nlignes Faire

ligneEtoile ( ) Appel de la
procédure ligneEtoile
FinPour
Fin
Lorsque le processeur rencontre l'appel d'une procédure, il arrête
momentanément l'exécution du programme appelant pour aller exécuter les
instructions de la procédure. Quand il a terminé l'exécution de la procédure, le
processeur reprend l'exécution du programme appelant là où il s'était arrêté.
Une procédure 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.

1. Notions de variables locales et de paramètres

Les variables déclarées dans une procédure ne sont pas utilisables dans le
programme appelant.
Chaque sous-programme a son propre espace de variables, inaccessible par les
autres. On dit que les variables sont LOCALES.

19/23
TDI CHAPITRE IV
Algorithmique (Les procédures et les fonctions)

Procédure ligneEtoile( )
Var
i : entier
Début
Pour i=1 jusqu'à 10 Faire
Ecrire('*')
FinPour
Ecrire('\n')
FinProc

Dans notre exemple, on ne pourrait pas saisir ou afficher la variable i dans le

programme principal, car i est une variable de la procédure, utilisable seulement
dans celle -ci. Le programme principal n'a pas le droit de l'utiliser.
Une question qui se pose alors est de savoir comment procédures et programmes
vont pouvoir communiquer des données. Par exemple, on pourrait vouloir que le
programme principal communique à la procédure combien d'étoiles afficher par
ligne. Cela est possible grâce aux paramètres.
Un paramètre est une variable particulière qui sert à la communication entre
programme appelant et sous -programme.
Exemple :
Dans notre exemple, nous allons mettre le nombre d'étoiles par lignes en
paramètre.
Pour cela, nous indiquons entre parenthèses la déclaration du paramètre (qui est
une variable de la rocédure !). La valeur de ce paramètre est communiquée à
l'appel, par le programme appelant.

Procédure ligneEtoile(nombre : entier ) //sous-programme

Var
cpt : entier paramètre formel
Début
Pour cpt=1 jusqu'à nombre Faire
Ecrire('*')
FinPour
Ecrire('\n')
FinProc

Programme RectangleEtoile //programme appelant

Var
nlignes, netoiles: entier //nombre de lignes et nombre d'étoiles par ligne

20/23
TDI CHAPITRE IV
Algorithmique (Les procédures et les fonctions)

i : entier
Début
Ecrire("Ce programme dessine un rectangle d'étoiles.")
Ecrire("Combien voulez-vous d'étoiles par ligne?")
Lire(netoiles)
Ecrire("Combien voulez-vous de lignes?")
Lire(nlignes)
Pour i=1 jusqu'à nlignes Faire
ligneEtoile (netoiles)
FinPour
Fin paramètre effectif

2. Passage des paramètres de type donnée (par valeur)

Lors de l'appel de la procédure, la valeur de la variable netoiles passée en
argument est copiée dans le paramètre formel nombre (qui est une variable). La
procédure effectue alors le traitement avec la variable nombre qui a bien la
valeur voulue: celle de netoiles.
La procédure n'utilise par directement la variable netoile : elle utilise sa valeur,
qu'elle a recopiée dans sa propre variable -paramètre.
Remarque importante sur l'ordre et le nombre des paramètres
Lorsqu'il y a plusieurs paramètres dans la définition d'une procédure, il faut
absolument qu'il y en ait le même nombre à l'appel et que l'ordre soit respecté
(car la copie se fait dans l'ordre).

3. Les paramètres réels et formels

Il est primordial de bien distinguer les paramètres qui se trouvent dans l'en-tête
d'une procédure, lors de sa définition et les paramètres (ou arguments) qui se
trouvent placés entre parenthèses lors de l'appel.
1 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.
2 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.

21/23
TDI CHAPITRE IV
Algorithmique (Les procédures et les fonctions)

III. LES FONCTIONS

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.
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, test…) qui utilise sa valeur.
Le résultat d'une fonction doit obligatoirement être retourné au programme
appelant par l'instruction Retourne.
Syntaxe générale
Fonction nom_Fonction(déclaration des paramètres) : type de la valeur retournée
Var
//variables locales correspond à la valeur d'une variable, d'une
Début expression ou d'une valeur littérale.
//traitement
Retourne valeur à retourner
FinFonction
instruction obligatoire

déclaration du
paramètre formel
Exemple :

Fonction factorielle(n: entier) : entier type de la valeur

retournée
/*Cette fonction retourne la factorielle
du nombre n passé en paramètre*/
Var
i : entier
fact : entier
Début
fact 1
Si n ? 0 Alors
Pour i=1 jusqu'à n faire
fact fact * n
FinPour instruction de retour
FinSi
Retourne fact
FinFonction

Fonction saisie_nb_positif( ) : entier

22/23
TDI CHAPITRE IV
Algorithmique (Les procédures et les fonctions)

/*Cette fonction permet de faire saisir à l'utilisateur un nombre positif qui est
alors retourné*/
Var
nb_saisi :entier
Début
Ecrire( "Veuillez entrer un nombre positif")
Lire( nb_saisi)
Tantque nb_saisi < 0 Faire
Ecrire( "Erreur. Saisissez un nombre supérieur à 0 s'il vous plait !")
Lire( nb_saisi)
FinTantque
Retourne nb_saisi
FinFonction

Exemple de programme appelant utilisant ces deux fonctions:

Programme affiche_factorielle
Var
appel de la fonction saisie_nb_positif
nombre: entier et affectation de sa valeur retournée à la
rep : chaîne variable nombre
Début
Répéter paramètre effectif
nombre saisie_nb_positif( )
Ecrire( "La factorielle de ", nombre, " est ", factorielle(nombre))
Ecrire( "Voulez-vous recommencez? (oui/non)")
Lire( rep) appel de la fonction
factorielle et affichage de sa
Jusqu'à rep = "non" valeur retournée
Ecrire( "A bientôt")
Fin

Remarque :
Les paramètres d'une fonction sont toujours de type 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.

Remarque sur le passage des paramètres: Le passage de paramètre par valeur

ne permet pas la modification de la variable passée en paramètre. un
autre type de passage de paramètre, est le passage de paramètre par
adresse ou (référence), dans ce type de passage de paramètre la
procédure peut modifiée la valeur de la variable passée en paramètre.
Chaque langage de programmation propose sa propre technique pour
réaliser ce type de passage de paramètre.

23/23