Exood4 Studio - Video Game Development, Toulouse (France)

Dans l'écriture d'un algorithme nous pouvons être confrontés aux cas suivants :

les différentes parties de l'algorithme sont indépendantes
des suites identiques d'actions apparaissent en plusieurs points de l'algorithme
des suites identiques d'actions peuvent être utilisées dans d'autres algorithmes

D'où la nécessité de regrouper ces actions en "sous-programmes". Écrire un sous-programme revient à donner un nom à un regroupement d'actions. Voici quelques bonnes raisons d'utiliser les sous-programmes, ils permettent :

de nommer des actions complexes sans les décrire (abstraction)
de diviser le travail (meilleure clarté de l'algorithme, maintenance facile ...)
d'étendre le langage algorithmique de base

Définition et utilisation d'un sous-programme

Définition

Définir un sous-programme, c'est donner un nom à une action complexe (ou groupement d'actions)

Il y a deux parties dans la définition d'un sous-programme :

la spécification (QUOI ou nom du sous-programme)
la réalisation (COMMENT ou regroupement d'actions)

Syntaxiquement, la partie spécification constitue l'en-tête du sous-programme et la partie réalisation constitue le corps du sous-programme.

Exemple : Création d'une équipe de personnages (dans un jeu de rôle)

// Création des personnages
Lire le nombre de personnages à créer;
TANT QUE il reste un personnage à créer FAIRE
Lire le nom du personnage;
Lire la race;
Lire la profession;
Lire l'alignement;
Attribuer les points aux caractéristiques du personnage;
FIN TANT QUE;

Dans cet exemple "Attribuer les points ..." est une action complexe qui peut être décomposée :

// En tête du sous-programme
SOUS-PROGRAMME Attribuer_points_caracteristiques
// Corps du sous-programme
DEBUT
Affecter aléatoirement les valeurs initiales des caractéristiques;
Déterminer le capital de points à répartir;
TANT QUE il reste des points à répartir ET que le joueur désire continuer FAIRE
Choisir la caractéristique à modifier;
Lire le nombre de points à attribuer;
SI ce nombre <= capital de points restant ALORS
Modifier la caractéristique choisie;
Mettre à jour le capital de points restant;
FIN SI;
FIN TANT QUE;
FIN

Utilisation

Utiliser un sous-programme, c'est faire référence (par son nom) au sous-programme. Ce qui revient à exécuter le corps de celui-ci.

Exemple :

Si nous avons déjà écrit la définition du sous-programme Attribuer_points_caracteristiques, on écrira :

// Création des personnages
...
// référence au sous-programme
Attribuer_points_caracteristiques;
...

Remarque : sur cet exemple, nous n'avons qu'une seule référence au sous-programme, mais en réalité nous pouvons l'appeler autant de fois que nécessaire.

Voici ce qu'il se passe lorsqu'un sous-programme est appelé :

appel du sous-programme
exécution du corps du sous-programme
retour du sous-programme après l'action d'appel

L'appel et le retour du sous-programme implique un transfert de contrôle de l'appelant (algorithme) vers l'appelé (sous-programme).

Paramètres de sous-programmes

Notions de paramètre

L'idée est de pouvoir appliquer un même sous-programme à des contextes différents.

Dans l'exemple précédent, le sous-programme Attribuer_points_caracteristiques, l'absence de paramètres implique qu'il s'agira toujours du même calcul (celui d'un personnage en particulier). Pour l'algorithme, nous avons besoin de changer de personnage à chaque pas de la répétition. Il nous faut donc transmettre au sous-programme une information appelée : PARAMETRE

Exemple : on peut imaginer comme paramètre le nom du personnage

// En tête du sous-programme
SOUS-PROGRAMME Attribuer_points_caracteristiques(NOM_PERSONNAGE)
// Corps du sous-programme
DEBUT
Affecter aléatoirement les valeurs initiales des caractéristiques (NOM_PERSONNAGE);
Déterminer le capital de points à répartir;
TANT QUE il reste des points à répartir ET que le joueur désire continuer FAIRE
Choisir la caractéristique à modifier (NOM_PERSONNAGE);
Lire le nombre de points à attribuer;
SI ce nombre <= capital de points restant ALORS
Modifier la caractéristique choisie (NOM_PERSONNAGE);
Mettre à jour le capital de points restant;
FIN SI;
FIN TANT QUE;
FIN

Dans l'algorithme on écrira :

// Création des personnages
...
Attribuer_points_caracteristiques (PERSONNAGE1);
...
Attribuer_points_caracteristiques (PERSONNAGE2);
...

Remarques :

Chez l'appelant (algorithme), le paramètre est appelé paramètre effectif (ou réel), chez l'appelé (sous-programme), le paramètre est appelé paramètre formel.
On peut donner aux paramètres effectif et formel le même nom.
La définition d'un sous-programme n'est pas liée au nombre d'utilisations (même s'il n'y a qu'un seul appel, faire un sous-programme). Sa définition est liée à la notion d'entité (ou module) et non à sa fréquence d'appel.

Modes de transmission des paramètres

Les paramètres formels sont mis en correspondance avec les paramètres effectifs, un à un et de gauche à droite (avec vérification du type des paramètres pour les langages de programmation)

Il existe 3 modes de transmission :

mode ENTREE (lecture seulement)
mode SORTIE (écriture seulement)
mode MISE A JOUR (lecture et/ou écriture)

Remarques :

Il s'agit de modes de transmission logiques (notion générale d'algorithmique)
Les langages de programmation implémentent certains types de transmission. Par exemple le langage C et le Pascal ont un mode entrée (transmission par valeur) et un mode sortie/mise à jour (transmission par référence), d'autres langages possèdent les 3 modes.

1) Mode ENTREE

Le sous-programme consulte uniquement la valeur du paramètre. La valeur du paramètre est fournie par l'appelant.

Exemple :

SOUS-PROGRAMME Attribuer_points_caracteristiques (ENTREE NOM_PERSONNAGE)

2) Mode SORTIE

Le sous-programme calcule une valeur qui est ensuite retournée à l'appelant. Le résultat est fourni par le sous-programme.

Exemple :

On suppose que le sous-programme Attribuer_points_caracteristiques retourne le nombre de points n'ayant pas été attribués, nous écrirons :

SOUS-PROGRAMME
Attribuer_points_caracteristiques (ENTREE NOM_PERSONNAGE, SORTIE CAPITAL_RESTANT)

2) Mode MISE A JOUR

Le paramètre est communiqué par l'appelant, le sous-programme modifie la valeur du paramètre et retourne la nouvelle valeur du paramètre à l'appelant . Il s'agit d'une combinaison des modes ENTREE et SORTIE.

Exemple :

Dans notre sous-programme, les caractéristiques ont besoin d'être retournées mais aussi d'être évaluées lors de la répartition des points.

SOUS-PROGRAMME
Attribuer_points_caracteristiques (ENTREE NOM_PERSONNAGE, SORTIE CAPITAL_RESTANT,
MISE A JOUR CARACTERISTIQUES )

Portée des variables

En algorithmique une application sera codée par plusieurs sous-programmes englobés dans un programme plus général appelé programme principal. Chaque sous-programme est un bloc d'actions, on parle alors de langage à structure de blocs. Au début de l'algorithme, le contrôle est transmis à la première action du corps du programme.

De manière générale, l'écriture d'un programme se note ainsi :

PROGRAMME P
GLOSSAIRE

SOUS-PROGRAMME SP1
GLOSSAIRE
DEBUT
...
FIN

SOUS-PROGRAMME SP2
GLOSSAIRE
DEBUT
...
FIN
...
DEBUT // programme principal
...
FIN

Règles de portée des variables

Les variables déclarées dans le glossaire du programme sont visibles (et donc accessibles) dans tout le programme, y compris les sous-programmes. Sauf si une variable portant le même nom est déclarée dans le glossaire d'un sous-programme (priorité au bloc le plus interne).
Les variables déclarées dans le glossaire d'un sous-programme ne sont visibles que dans le corps de ce sous-programme.
Les paramètres formels d'un sous-programme ne sont visibles que dans le sous-programme.

Remarques :

Les variables du programme sont souvent appelées variables globales. Les variables d'un sous-programme sont appelées variables locales. Un sous-programme peut travailler :

sur des données du programme appelant (variables globales)
sur des données transmises par l'appelant (paramètres en mode entrée)
sur des données propres au sous-programme (variables locales)

Activation d'un sous-programme

Résumé des effets d'une activation d'un sous-programme

Fonctionnement de l'appel d'un sous-programme :

Mise en correspondance des paramètres effectifs avec les paramètres formels, un à un, de gauche à droite
Pour chaque paramètre formel en mode entrée : allocation d'un emplacement et initialisation de l'emplacement par la valeur du paramètre effectif (recopie)
Chaque paramètre formel en mode sortie ou en mode mise à jour représente le paramètre effectif correspondant (référence)
Pour chaque variable locale du sous-programme : allocation d'un emplacement non initialisé (sa valeur est indéterminée, il est nécessaire d'affecter une valeur dans le corps du sous-programme)
Exécution du corps du sous-programme : pour les paramètres en mode entrée et les variables locales, les modifications sont temporaires. Pour les paramètres en mode sortie et mise à jour ainsi que pour les variables globales, les modifications sont permanentes
A la fin de l'exécution du sous-programme (retour) tous les emplacements créés sont libérés.

Remarques :

Pour les paramètres de taille importante (grands tableaux ou enregistrements ayant de nombreux champs), préférer le mode mise à jour plutôt que le mode entrée (même si le sous-programme ne fait que consulter le paramètre) car il y a recopie de toutes les valeurs du paramètre sinon.
A un paramètre en mode mise à jour ou sortie, on peut associer un paramètre effectif de type variable, mais on ne peut lui associer une expression (impossible de fournir la référence d'une expression). A un paramètre en mode entrée on peut associer un paramètre effectif variable ou expression.

Exemple :

Soit le programme
PROGRAMME P
GLOSSAIRE
A : une variable entière;
B : une autre variable entière;
// A et B sont 2 variables globales

SOUS-PROGRAMME H (ENTREE X, MISE A JOUR Y)
DEBUT
X

X + 1;
Y

Y + 1;
ECRIRE (X,Y);
FIN

DEBUT
// Étape 1
A

0; B

0;

// Étape 2
H (A, B);

// Étape 3
ECRIRE (A,B);
FIN

A et B sont 2 variables globales mais aussi paramètres effectifs du sous-programme H
X et Y sont des paramètres formels du sous-programme H

A et B sont visibles dans le corps du programme P et dans le sous-programme H (voir portée des variables)
X et Y ne sont visibles que dans le sous-programme H (voir portée des variables)

Trace d'exécution du programme P

Etape 1

Programme P

A = 0

B = 0

Etape 2

Programme P	Sous-programme H
A = 0	X = 0
B = 0	Y référence sur B = 0

Exécution du sous-programme H

Programme P	Sous-programme H
A = 0	X = 1
B = 1	Y référence sur B = 1

Résultat de l'opération ECRIRE(X,Y)

1 , 1

Etape 3

Programme P

A = 0

B = 1

Résultat de l'opération ECRIRE(A,B)

0 , 1

Attention à l'utilisation des paramètres en mode entrée ! Évitez de modifier ces paramètres...

Règles de "bonne conduite" d'utilisation des paramètres

Un paramètre en mode entrée ne doit apparaître qu'en partie droite d'une affectation (valeur du paramètre). Interdiction de modifier un paramètre en mode entrée.
Un paramètre en mode sortie ne doit apparaître qu'en partie gauche d'une affectation. Interdiction de consulter la valeur d'un paramètre en mode SORTIE.
Pour les paramètres en mode mise à jour, autorisation des opérations de consultation et de modification (parties gauche et droite d'une affectation)
Ne pas transformer les en-têtes des sous-programmes en utilisant uniquement le mode MISE A JOUR !

Solution et correction du sous-programme H :

SOUS-PROGRAMME H (ENTREE X, MISE A JOUR Y)
GLOSSAIRE
Z : variable locale au sous-programme H
DEBUT
Z

X;
Z

Z + 1;
Y

Y + 1;
ECRIRE (X,Y);
FIN

L'action ECRIRE(X,Y) donnera les valeurs 0 et 1, ce qui est conforme aux valeurs des variables A et B de l'action ECRIRE(A,B).

Page suivante

Retour en haut de page