You are on page 1of 21

EPST – Annaba Introduction à l’Algorithmique 2015

Première Année

Chapitre 1 : Généralités sur


l’Algorithmique

 Algorithme : mot dérivé du nom du mathématicien al_Khwarizmi qui a vécu au 9ème


siècle, qui a vécu à Bagdad. Un algorithme prend des données en entrée, exprime un
traitement particulier et fournit des données en sortie.
L’objectif de l’algorithme est d’obtenir de la «machine» qu’elle effectue un travail à notre
place, pour cela il faut lui expliquer comment elle doit s'y prendre.
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.

La création d'un programme informatique commence par 4 phases :


 1 La spécification (ou analyse) ;
 2 La conception préliminaire (ou conception générale) ;
 3 La conception détaillée ;
 4 Le codage.

1
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

A partir de l’énoncé d’un problème, on aboutit à une forme de langage compréhensible par la
machine.

Enoncé du étape un algorithme traduction Programme


problème d’analyse (pseudo-code) (langage) (ex : c)

Machine

Exemple :

Calcul Expliciter les formules un algorithme traduction


Moyenne , procédures, règles… en langage c

programme C

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

2
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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:
Préparation Saisir (L,l) L: Longueur; l: largeur

Traitement S L*l S: Surface

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

Fin

3
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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
Saisir (L, l) ; / entrées données
S L*l; / calcul
Afficher (S); / sortie résultat
Fin.
Le slash « / » indique un commentaire n’est pris en considération par la machine.

4
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Chapitre 2 : Notions de base

Structure générale d’un algorithme


Algorithme< en tête > ;
< déclarations >
Debut Les mot soulignés sont dits MOTS CLES
< corps de l’algorithme > (mots du langage)
Fin.

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


Exemple :CalculSurface.
2- Les <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.)

La partie déclaration 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.

Rq : 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

5
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

 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 (dans 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 : reelles ;
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.

6
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Chapitre 3: 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.

7
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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 ;

8
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Chapitre 4 : 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 AFFICHER
Cette fonction affiche à l'écran les arguments qu'on lui demande d'afficher. Nous utiliserons
également une autre fonction nommée SAISIR qui permet de stocker la ou les données saisies
au clavier dans des variables.

Les entrées : 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: Saisir(x) ;
Saisir (nom, prénom) ;
Saisir (val) ;

9
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Les sorties : 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: Afficher("Entrer la valeur de x");


Afficher(x) ;
Afficher (" la valeur de x est ", x ," la valeur de y est ",y );
Afficher (" 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


Afficher ("Donnez-moi le prix hors taxe :") ;
Saisir(prixHT) ;
prixTTC ←prixHT* (1+TVA/100) ; /calcul du prix TTC
Afficher(Titre) ; /présentation du résultat
Afficher(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.

10
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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.

 3-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 non
Afficher (" les 2 valeurs sont égales ") ;
Sinon Afficher (" les 2 valeurs sont différentes ") ;
Finsi ; les 2 valeurs les 2 valeurs
sont égales sont #

RQ : si un bloc d’actions est composé de plus d’une action, il sera délimité par : debut …
fin.

11
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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 ;

12
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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 ;

3-2) 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

 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

13
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Exemple :

Pour i allant de 0 `a 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

 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

 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>

14
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Chapitre 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.25 12 0 -9 4 1 14 85 100 -6 33 10
indice 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 ;

15
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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 12
Tableau à 3 lignes et 4 colonnes
10 7 -50 14
20 30 40 70 M[1,3]=5 ; M[2,2]=7…..

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

16
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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 prenom age


2
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

17
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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.

18
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

Chapitre 6: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)

19
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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.

20
EPST – Annaba Introduction à l’Algorithmique 2015
Première Année

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).

21