ENSMM ANNABA 2018/2019

Chapitre 4 : Généralités sur

l’Algorithmique

1. Introduction :

L’algorithmique est un terme d’origine arabe, comme algèbre. Un algorithme prend des
données en entrée, exprime un traitement particulier et fournit des données en sortie. Dans la
vie sans le savoir, vous avez déjà exécuté des algorithmes.

 Pour préparer un gâteau on suit une recette de cuisine

 Pour installer et faire fonctionner un magnétoscope (imprimante) on suit à la lettre le mode
d’emploi
 En indiquant le chemin a un touriste ou a une personne égarée.

Un algorithme est un assemblage et enchaînement d’actions nécessaires pour résoudre un

problème. On a différentes appellations :
 langage algorithmique
 pseudo-langage de programmation
 pseudo-code

Pour fonctionner, un algorithme doit donc contenir uniquement des actions compréhensibles
par celui qui devra l’exécuter.
La maîtrise de l’algorithmique requiert deux qualités, très complémentaires :

 il faut avoir une certaine intuition.

 il faut être méthodique et rigoureux.

Programme : série d’instructions pouvant s’exécuter en séquence, ou en parallèle qui réalise

(implémente) un algorithme
Un programme est réalisé dans le but d’effectuer un ensemble de traitements particuliers sur
un ensemble de données :

Données Traitements Résultats

Un programme doit être :
1- lisible
2- fiable
3- maintenable
4- réutilisable
5- portable
6- correct (preuve)
7- efficace (complexité)
8- faire face à des contraintes économiques

Donc on a besoin d'une méthodologie.

1
 La création d'un programme informatique commence par 4 phases :
 La spécification (ou analyse) ;
 La conception préliminaire (ou conception générale) ;
 La conception détaillée ;
 Le codage.

Les trois étapes d’un algorithme

•Préparation du traitement : données nécessaires à la résolution du problème

•Traitement : résolution pas à pas, après décomposition en sous-problèmes si nécessaire
•Edition des résultats : impression à l’écran, dans un fichier, etc.

Pourquoi apprendre l’algorithmique pour apprendre à programmer ?

Parce que l’algorithmique exprime les actions résolvant un problème donné indépendamment
des particularités de tel ou tel langage. Apprendre l’algorithmique, c’est apprendre à manier
la structure logique d’un programme informatique.

Avec quelles conventions écrit-on un algorithme ?

La description (formalisation) d’un algorithme peut se faire par les manières suivantes :

1) Formalisation dans la langue usuelle (Langage naturel) :

On décrit l’algorithme par une suite de phrases. Par exemple le calcul de la surface d’un
rectangle peut être décrit ainsi :

 connaitre la longueur et la largeur ;

 multiplier la longueur par la largeur ;
 le résultat est la surface recherchée.
Cette description est loin du langage de la machine, c’est pour cela qu’on ne l’utilise pas de
façon explicite.

2) Formalisation graphique (Organigramme, Algorigramme)

On utilise des symboles graphiques et on obtient ce qu’on appelle l’Organigramme ou
l’Algorigramme décrivant l’algorithme.
Les principaux symboles rencontrés dans un algorigramme sont représentés dans le tableau ci-
dessous. L'algorigramme permet une vision globale mais reste limité aux études peu
complexes.

Symbole Désignation

Début ou fin d’un algorithme

Symbole général de traitement

Entrée / Sortie
 Test ou branchement

conditionnel Une entrée deux

sorties

Sous programme : Appel d’un sous programme

Exemple : Calcul de la surface d’un rectangle.

debut

Entrées:
L: Longueur; l: largeur
Saisir (L,l)

Traitement S L*l S: Surface

Résultat Afficher (S) Sortie: S: surface

Fin

3) Formalisation en pseudo-langage (Pseudo code)

Le pseudo-langage 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.
Exemple : Calcul de la surface d’un rectangle

Algorithme Surface ;
Variables L, l, S : reels ; / déclarations
Debut / préparation traitement
Lire (L, l) ; / entrées données
S L*l; / calcul
Ecrire (S); / sortie résultat
Fin.
Le slash « / » indique un commentaire n’est pris en considération par la machine.

Structure générale d’un algorithme

Algorithme < L’entête > ;

< déclarations >
Debut Les mot soulignés sont dits MOTS CLES
< Corps de l’algorithme >
Fin.

1- L’<entête> : est le nom de l’algorithme il permet d’identifier un algorithme. Exemple

:CalculSurface.

2- La <déclarations> : Actions (Instructions) permettant de réserver de l’espace mémoire pour

stocker des données (dépend du type de données : entiers, réels, caractères, etc.).Elle comprend :
des constantes, des variables, des enregistrements, des fonctions et des procédures. (Nous
commencerons par étudier les constantes et les variables).
Les constantes et les variables sont désignées par un identificateur. Cet identificateur peut
être composé de lettres ou de lettres et de chiffres.

Remarque : Un identificateur ne peut être un mot clé, ne peut commencer par un chiffre
et ne peut comporter de caractères spéciaux excepté l’under_score _ : touche du 8).

Les constantes : les constantes sont des données dont la valeur ne peut pas être modifiée
durant l’exécution de l’algorithme (programme).On peut avoir des constantes entières, des
constantes réelles, ou bien des constantes caractères.
Une constante possède deux attributs :
 Un identificateur
 Une valeur

Syntaxe : constantes < identificateur> = expression ;

L’expression peut être une valeur ou une expression

Exemple :

Constantes
MAX = 100 ; /constante entière
DOUBLEMAX =MAX ×2 ; /constante expression
PI= 3.14 ; /constante réelle
Lettre=’a’ ; /constante caractère
PlusLettres=’algerie’ ; /constante chaine de caractères
 Les variables : les variables sont des données dont la valeur peut être modifiée durant
l'exécution de l’algorithme (programme).
Une variable possède plusieurs attributs :
 Un identificateur
 Un type
 Une valeur
 Une durée de vie

Syntaxe : variables <liste d’identificateurs> : type ;

Les types de données

Les données manipulées sont typées, c'est-à-dire que pour chaque donnée que l'on
utilise (comme les variables par exemple) il faut préciser le type de donnée, ce qui
permet de connaître l'occupation mémoire (le nombre d'octets) de la donnée ainsi que
sa représentation.
Types de données simples :

 type entier : le contenu de la variable est une valeur entière positif ou négatif;
 type réel : la variable contient une valeur réelle c'est-à-dire à virgule ;
 type caractère : permet de stocker un seul caractère.
 type chaines de caractères : permet de stocker plusieurs caractères.
 type booléen : le contenu de la variable est une valeur logique (vrai ou faux)

Exemple :
Variables a : entier ;
Long, Larg, Surface : reel ;
Nom1, Nom_2 : chaine de caractères ;
Car : caractère ;
VL : booleen ;

3- <Corps de l’algorithme> : dans cette partie de l’algorithme, sont placées les

tâches (instructions, actions, opérations …) à exécuter. Ces opérations utilisent des
opérateurs pour effectuer les traitements.
Les Opérateurs

Les opérateurs ont pour but de permettre la manipulation et le traitement des données.
Différentes données peuvent être groupées à l'aide des opérateurs pour former des
expressions.
En algorithmique, il existe différentes catégories d’opérateurs.

- Les opérateurs arithmétiques :

Ils permettent d'écrire des expressions mathématiques mettant en jeu des opérandes
numériques.
Exemple : valeur de X après chaque instruction, sachant que A = 1, B = 2, C = 3 et D = 4

-
- Les opérateurs logiques :
Ils permettent de réaliser des expressions logiques ou booléennes, permettant ainsi de former
des expressions complexes à partir d'expressions simples.
Négation

NON ; ET logique
ET; OU logique
OU
Notons que A et B représentent des expressions et que le résultat de telles opérations est 0
pour faux et 1 pour vrai

- Les opérateurs relationnels.

Ils sont utilisés dans des expressions de comparaisons.

< ≤ > ≥ = ≠ (<>)

& : concaténation des chaines de caractères
Priorité et ordre d'évaluation des opérateurs

En algorithmique, chaque opérateur a sa priorité et son ordre d'évaluation. Dans une

expression comportant plusieurs opérateurs ceux de plus grande priorité sont évalués en
premier ensuite ceux de priorité plus petite et ainsi de suite jusqu'à arriver à ceux dont la
priorité est la plus petite. Dans le cas où plusieurs opérateurs sont de même priorité leur ordre
d'évaluation détermine alors celui qui sera évalué en premier. Ci-
dessous un tableau de priorité et d'ordre d'évaluation des différents opérateurs:

Opérateur Ordre d'évaluation

() Gauche --> Droite
NON Droite --> Gauche
^ Gauche --> Droite
* / DIV MOD Gauche --> Droite
+- Gauche --> Droite
< <= > >= Gauche --> Droite
= ≠ Gauche --> Droite
ET Gauche --> Droite
OU Gauche --> Droite
Droite --> Gauche

Exemple : Que vaut X après l'action suivante : X 3 + (1 + (2 + 1) * 3) / 2 ;

Que vaut Y après l'action suivante : Y 17 / 5 + 17 div 5 + 17 mod 5 ;

Les instructions du langage algorithmique

C’est dans le Corps de l’algorithme que la plupart des opérations sont placées. Ces opérations
peuvent être divisées en quatre catégories.

1) L’opération d’affectation
2) Les entrées / Sorties (lecture / écriture, Input / output)
3) Les tests (conditions)
4) Les boucles (répétitions, itérations).

1) L’opération d’affectation
Syntaxe : identificateur <Expression> ;
: Symbole d’affectation
<Expression> peut être :
. une valeur ex : X 5;
. une variable ex : X Y;
 . une expression ex : Z 2*X+(y -
z) ; L’affectation se fait toujours en deux temps :
1) Evaluation de l’expression située à droite du symbole
2) Affectation du résultat à l’identificateur de variable.

2) Les entrées, sorties

L'algorithme a besoin de données en entrée, et fournit un résultat en sortie. Lorsqu'on utilise
un ordinateur, le clavier permet de saisir les données et l'écran d'afficher un résultat.
Lorsqu'on voudra afficher un texte sur l'écran, on utilisera une fonction nommée Ecrire
(AFFICHER) Cette fonction affiche à l'écran les arguments qu'on lui demande d'afficher. Nous
utiliserons également une autre fonction nommée lire (SAISIR) qui permet de stocker la ou
les données saisies au clavier dans des variables.

Les entrées : lire ou Saisir une donnée

Syntaxe :
Saisir(<liste de noms de variables>) ;
Fonction : action permettant de placer en mémoire les informations fournies par l'utilisateur.
Exemples: lire(x) ;
lire (nom, prénom) ;
lire (val) ;
Les sorties : Ecrire ou Afficher une donnée, un résultat
Syntaxe :
Afficher(<Expression>) ;
Fonction: action permettant de visualiser les informations placées en
mémoire. (<Expression> peut être : Un texte
: la valeur d’une variable
: mélange de textes et de valeurs
: expression mathématique

Exemples: Ecrire ("Entrer la valeur de x");

Ecrire (x) ;
Ecrire (" la valeur de x est ", x ," la valeur de y est ",y );
Ecrire (" la valeur de Delta est ", Delta b*b – 4* a* c) ;

La virgule sépare les chaînes de caractères à Afficher. Tout le texte contenu entre des
guillemets est Affiché tel quel à l'écran, alors que lorsqu'une variable apparaît dans l’action
Afficher c'est sa valeur qui est affichée.

Exemple :

Algorithme Exemple d’E_S ;

/ Saisit un prix HT et affiche le prix TTC correspondant
Constantes TVA= 20.6 ;
Titre = "Résultat" ;
Variables prixHT, prixTTC: réels ; / déclarations

Début /préparation du traitement

Ecrire ("Donnez-moi le prix hors taxe :") ;
 lire(prixHT) ;
prixTTC ←prixHT* (1+TVA/100) ; /calcul du prix TTC
Ecrire(Titre) ; /présentation du résultat
Ecrire (prixHT, " D.A. H.T. devient ", prixTTC, "D.A.T.T.C.") ;
Fin.

Exercices :
1) Ecrire l’algorithme qui calcule la surface et le périmètre d’un cercle Traduire cet
algorithme en organigramme.

2) Ecrire l’algorithme qui convertit un nombre donné en seconde en Heures, Minutes ,

Secondes.

3. Les structures de contrôle

Les actions de contrôle servent à contrôler le déroulement de l’enchaînement des actions à
l’intérieur d’un algorithme, ces actions peuvent être des actions conditionnelles ou itératives.

1) Actions conditionnelles : Les tests

Les actions conditionnelles permettent de réaliser des tests, et suivant le résultat de ces tests,
d’exécuter des parties de code différentes.

 L’action conditionnelle simple

Syntaxe :
Si <expression logique>alors
< bloc d’actions>
Finsi ;

Si l’expression logique (la condition) prend la valeur vraie, le bloc d’actions est exécuté; si
elle prend la valeur fausse, l’algorithme continue après finsi.
Exemple :
Si (a=b) alors
Afficher (" les 2 valeurs sont égales ") ;
Finsi ;

 L’action conditionnelle alternée

Syntaxe :
si<expression logique>alors <bloc d’actions1>
sinon <bloc d’actions2>
Finsi ;
Si l’expression logique (la condition) prend la valeur vraie, le premier bloc d’actions est
exécuté; si elle prend la valeur fausse, le second bloc est exécuté.

exemple
Si (a=b) alors oui a=b
") ;
Afficher (" les 2 valeurs sont égales ") ; les 2 valeurs sont égales les 2 valeurs
sont #
Sinon Afficher (" les 2 valeurs sont différentes non
Finsi ;
RQ : si un bloc d’actions est composé de plus d’une action, il sera délimité par : debut …
fin.

Problème: afficher "Reçu avec mention" si une note est supérieure ou égale à 12, "Passable"
si elle est supérieure à 10 et inférieure à 12, et "Insuffisant" dans tous les autres cas.
si note ≥12alors
afficher( "Reçu avec mention" ) ;
sinon si note ≥10alors
afficher( "Passable" ) ;
sinon afficher("Insuffisant" ) ;
finsi ;
finsi ;

Exercice : dire si un nombre est pair ou impair.

La sélection sur choix multiples

L'instruction de condition multiple utilise une variable ou une expression appelée sélecteur
dont la valeur est comparée à une liste d'étiquettes. En cas d'égalité, le bloc d’actions associé à
l'étiquette est exécuté.

Syntaxe :
selon <identificateur> / l’identificateur est soit une variable ou une
expression etiquette1 : bloc d’actions
etiquette2 : bloc d’actions
…
Etiquette n : bloc d’actions
[autres: bloc d’actions]
FinSelon ;

S’il y a plus de deux choix possibles, l’instruction selon permet une facilité d’écriture.

Exemple
selon abréviation
"M" : afficher (" Monsieur ") ;
"Mme" : afficher (" Madame ") ;
"Mlle" : afficher (" Mademoiselle ") ;
autres: afficher (" ERREUR ") ;
FinSelon ;
 Comparer:
si (abréviation = "M") alors
afficher( "Monsieur" ) ;
sinon si abréviation = "Mme") alors
afficher("Madame") ;
sinon si (abréviation = "Mlle" ) alors
afficher( "Mademoiselle" ) ;
sinon afficher( "ERREUR " ) ;
finsi ;
finsi ;
finsi ;

4. Les Boucles (actions répétitives)

Une boucle permet de répéter un bloc d’actions plusieurs fois. Le passage dans une boucle est
appelé itération. Il y a principalement trois types de boucles :

 Les boucles pour répéter un bloc d’actions un certain nombre de fois, il s’agit de la boucle
Pour.

 Les boucles pour répéter un bloc d’actions jusqu’`a une condition d’arrêt, il s’agit des boucles
Tant que.

 Les boucles pour répéter un bloc d’ i actions jusqu’`a une condition d’arrêt avec exécution
d’au moins une itération, il s’agit des boucles Répéter ….jusqu’a

1. La boucle «pour»

Les boucles « pour » permettent de répéter un bloc d’actions un nombre donné de fois. Elles
se caractérisent par le fait que l’on connait `à l’ avance le nombre d’itérations que l’on va
devoir effectuer.

Syntaxe :
Pour (variable) allant de (Val Ini à (Val Fin) [pas de] (valeur) faire
<bloc actions>
FinPour ;

RQ : Lorsque (valeur) est égale à 1 le pas est facultatif

Exemple :

Pour i allant de 0 à 10 faire

Afficher (i) ;
FinPour ;
Variable : i
 0 : Valeur Initiale
10 : Valeur Finale
Le pas =1

Cette boucle affichera successivement les

nombres 0,1,...,10, on effectue donc 11 itérations

Exercice
Faire la somme paire et impaire des 10 premiers
nombres naturels

2. La boucle « tant que »

Les boucles tant que permettent d’effectuer des itérations tant qu’une certaine condition est
vérifiée. On ne connait pas le nombre d’itérations à effectuer, mais à chaque itération, on
vérifie si la condition est vraie ou fausse. Dés que cette condition est fausse, on sort de la
boucle.

Tant que (condition) faire

<bloc actions>
Fintantque ;

Exemple :
n 1;
Tant que ( n mod 21 ≠ 0 ) faire
n n+15 ;
FintantQue

On sort de la boucle si n est un multiple de 21

3. La boucle « Répéter »
La boucle répéter ……jusqu’a s'utilise lorsque l'on doit exécuter au moins une fois le bloc
d’actions de la boucle.
Syntaxe :
Répéter
<bloc actions>
Jusqu'à <condition satisfaite>

5. Structure de Données Complexes (Tableaux et Enregistrements)

Les Tableaux
Définition: Les tableaux constituent un moyen pratique qui permet de regrouper plusieurs
variables de même type sous un nom collectif. On peut avoir un tableau de différents types
(entier, réel, caractère,….)

Déclaration d’un tableau

Syntaxe :
Variables <identificateur> : tableau [constante] : type ;

Exemple :
 Variables note : tableau [12] : réels ; / une variable tableau « note » de 12 réels.

note

cases
Accès aux éléments d'un tableau
A la déclaration d’un tableau s’ajoute la déclaration d’une variable qui jouera le rôle d’index,
d’adresse ou d’indice de l’élément du tableau. Les éléments du tableau sont accessibles par
l’intermédiaire de cet indice qui est le numéro de la case.
note
5.2 1 0 - 4 1 1 8 10 - 3 1
5 2 9 4 5 0 6 3 0
indices 1 2 3 4 5 6 7 8 9 10 11 12

Case n°1 :indice=1 note[1] =5.25 x= note[2] + note[7] = 26

Case n°2 :indice=2 note[2] =12
------------- ---------
Case n°n :indice=n note[12]=10

Opérations sur les tableaux

 Recherche d’un élément
 Tri d’un tableau (ordre croissant ou décroissant)
 Ajouter un élément (au début, au milieu ou à la fin du tableau)
 Supprimer un élément

Tableau à deux dimensions

Les caractéristiques sont les mêmes que celles d’un tableau unidimensionnel sauf que les
valeurs ne sont pas repérées par une seule, mais par deux coordonnées.

déclaration
Variables <identificateur> : tableau[dimension1, dimension2] : type ;
Deux indices sont nécessaires pour accéder aux éléments d’un tableau à deux dimensions

Exemple : Variables M : tableau[3,4] :entier ;

i,j :entier ( i est l’indice de la ligne et j l’indice de la colonne)

1 9 5 1
Tableau à 3 lignes et 4 colonnes M[1,3]=5 ; M[2,2]=7…..
2
1 7 - 1
0 50 4

Les Enregistrements
Un enregistrement est un ensemble de plusieurs objets de types différents regroupés sous un
nom collectif.

Déclaration d'un enregistrement

Syntaxe :
Type Enregistrement = nom_type
nom_champ1: type_champ1 ;
…
nom_champN: type_champN ;
FinEnreg ;

Exemple:

Type Enregistrement=personne
nom : chaîne ;
prénom : chaîne ;
age : entier ;
FinEnreg ;

Accès aux champs d'un enregistrement

Alors que les éléments d'un tableau sont accessibles par l’intermédiaire de leur indice, les
champs d'un enregistrement sont accessibles à travers leur nom, grâce à l'opérateur '.'

Syntaxe :
nom_enregistrement.nom_champ ;

Exemple :
Programme de saisie des données concernant les personnes pers1 et pers2, puis affichage de la
différence d'âge entre ces deux personnes

Algorithme Exemple ;
Type Enregistrement= personne
nom : chaîne ;
prénom : chaîne ;
âge : entier ;
FinEnreg ;
Variables pers1, pers2 : personne ;
Début
Afficher("Entrez le nom puis l'age de la personne 1") ;
Saisir (pers1.nom, pers1.age ) ; / il est impossible d'écrire Saisir pers1
Afficher("Entrez le nom puis l'âge de la personne 2") ;
Saisir (pers2.nom, pers2.age) ;
Afficher("La différence d'âge entre ", pers1.nom, " et ", pers2.nom, " est de ") ;
Si (pers1.age > pers2.age) Alors
Afficher(pers1.age – pers2.age, " ans ") ;
Sinon Afficher(pers2.age – pers1.age, " ans ") ;
FinSi ;
Fin.
 Déclaration d’un tableau d’enregistrements

Type Enregistrement = nom_type

nom_champ1: type_champ1 ;
…
nom_champN: type_champN ;
FinEnreg ;
Variables <identificateurs> : tableau[dimension] : type ;

Exemple :
Type Enregistrement= personne
nom : chaîne ;
prénom : chaîne ;
âge : entier ;
FinEnreg ;
Variables pers : tableau[5] : personne ;
i : entier ; / indice du tableau
Un tableau de 5 personnes. Chaque personne possède un nom ; un prénom et un age.

1 nom preno age

2 m
3
4
5

Accès aux éléments d’un tableau d’enregistrements

Pers[1].nom
Pers[1].prenom accès aux données de la premiere personne
Pers[1].age

Exercice
Que produit l’algorithme suivant ?

Algorithme Anonyme ;

Variables Nb : Tableau [6] : Entier ;

i : Entier ;
Début
Pour i allant de 1 à 6 faire
Nb[i] ← i * i ;
FinPour ;

Pour i allant de 1 à 6 faire

Afficher( Nb[i]) ;
FinPour ;

Fin.

Peut-on simplifier cet algorithme avec le même résultat ?

solution

Cet algorithme remplit un tableau avec six valeurs : 1, 4, 9, 16, 25, 36.
Il les écrit ensuite à l’écran. Simplification :

Algorithme Anonyme ;
Variables Nb : Tableau [6] : Entier ;
i : Entier ;
Début
Pour i allant de 1 à 6 faire
Nb[i]← i * i;
Afficher(Nb[i]) ;
FinPour ;
Fin.

6. Les Fonctions et Procédures

Lorsque l'on programme, il est fréquent d'avoir à utiliser plusieurs fois une portion de code
dans un programme, ou, même, d'utiliser la même portion de code dans plusieurs
programmes. Cela dit, nous ne voulons pas avoir à réécrire ce code à chaque fois ; il y aurait
une perte de temps, et d'espace mémoire !

C'est pour cela que les notions de "fonction", ou de "procédure", ont été créées. Qu'est-
ce qu'une fonction ?

Pour faire bref, on peut dire que c'est une portion de code, qui peut travailler sur des données
que l'on lui fourni, qui peut renvoyer un résultat, et qui est souvent destinée à être utilisée
plusieurs fois, par son créateur ou par quelqu'un d'autre, sans avoir à être réécrite à chaque
fois.

Lorsqu'aucun résultat n'est retourné on parle de procédure. Utiliser des fonctions permet
d'obtenir un code plus clair, et moins redondant.

Procédure: Une procédure ou une fonction est déclarée et définie dans la partie déclarative
de l’algorithme selon la syntaxe suivante:

Procédure <nom_procédure (paramètres :

type)>; Variable <partie de déclaration> ;
Début
<bloc
d'actions> Fin ;

Fonction :
fonction <nom_fonction (paramètres : type)>
:type ; Variable <partie de déclaration> ;
Début
<bloc
d'actions> Fin ;
Une fois déclarée et définie une procédure ou une fonction, on peut l'appeler en tout point de
l’algorithme.

Notion de prototype d'une fonction

Un prototype de fonction permet au compilateur de savoir ce que la fonction attend en

paramètre, et le type de ce qu'elle retournera, même si le code correspondant à la fonction est
écrit ailleurs, ou plus loin dans le fichier source.

Portée, Variable Globale, Variable Locale

La portée d'une variable est l'ensemble des sous-programmes où cette variable est connue (les
instructions de ces sous-programmes (algorithmes) peuvent utiliser cette variable)
Une variable définie au niveau du programme principal est appelée variable globale Sa
portée est totale : tout sous-programme du programme principal peut utiliser cette variable

Une variable définie au sein d'un sous programme est appelée variable locale La portée d'une
variable locale est uniquement le sous-programme qui la déclare ,Lorsque le nom d'une
variable locale est identique à une variable globale, la variable globale est localement
masquée

Appel de la fonction
Il vous faut écrire le nom de la fonction, suivi de, entre parenthèses, les différents paramètres,
s'il y en a. Naturellement, on fait suivre d'un point-virgule si on est en fin d'instruction.
Exemple : calcul(x,23) ; sin(1.57) ; res=carre(n) ;…..

Passage de paramètres
Il y a deux méthodes pour passer des variables en paramètre dans une fonction : le passage
par valeur et le passage par variable.

Passage par valeur

La valeur de l'expression passée en paramètre est copiée dans une variable locale. C'est cette
variable qui est utilisée pour faire les calculs dans la fonction appelée.

Si l'expression passée en paramètre est une variable, son contenu est copié dans la variable
locale. Aucune modification de la variable locale dans la fonction appelée ne modifie la
variable passée en paramètre, parce que ces modifications ne s'appliquent qu'à une copie de
cette dernière.

Exemple

Algorithme passval ;
Variable i : entier;

Fonction test(j : entier) :entier ; / j est la copie de la valeur passée en

paramètre debut
J 3; / Modifie j, mais pas la variable fournie par l’appelant.
retour;
fin ;

/ *** PROGRAMME PRINCIPAL : programme appelant ***

debut

i 2;
test(i); / Le contenu de i est copié dans j.
/ i n'est pas modifié. Il vaut toujours 2.
test(2); / La valeur 2 est copiée dans j.
Fin.
Passage par variable

La deuxième technique consiste à passer non plus la valeur des variables comme paramètre,
mais à passer les variables elles-mêmes. Il n'y a donc plus de copie, plus de variable locale.
Toute modification du paramètre dans la fonction appelée entraîne la modification de la
variable passée en paramètre.

Exemple :

Algorithme

passvar ;
Variable i : entier;

Procedure test(j : entier);

debut
/La variable j est strictement égal
/à la variable passée en paramètre.
j 2; / Ici, cette variable est modifiée.
Fin;

debut
I 3; /Initialise i à 3}
test(i); /Appelle la fonction. La variable i est passée en
/paramètres, pas sa valeur. Elle est modifiée par
/la fonction test.

/Ici, i vaut 2
Fin.

Puisque la fonction attend une variable en paramètre, on ne peut plus appeler test avec une
valeur (test(3) est maintenant interdit, car 3 n'est pas une variable : on ne peut pas le
modifier).