II.4.LES EXPRESSIONS ARITHMETIQUES:
II.4.1.DEFINITION:
Une EXPRESSION ARITHMÉTIQUE est une expression composée de variables, de constantes
ou d'expressions arithmétiques séparées par des opérateurs mathématiques.
Elles correspondent au schéma suivant:
<exp. arith> =::=
<variable | constante | exp. arith entre parenthèses>
<opérateur mathématique>
<variable | constante | exp. arith entre parenthèses
>
Remarquons que la définition précédente est récursive: une expression
arithmétique de base est formée de deux termes séparés par un opérateur.
Chacun de ces termes peut être une expression arithmétique, et ainsi de suite....
EXEMPLES:
var A, B, C en numerique
........................
A+B, 3-C, 4*D sont des expressions arithmétiques «minimales»
........................
A+(3*B+C), 5*(4*A+2*B) sont des expressions arithmétiques comprenant d'autres expressions
arithmétiques mises entre parenthèses.
II.4.2.EVALUATION D'UNE EXPRESSION ARITHMETIQUE:
L'évaluation d'une expression arithmétique donne un résultat numérique.
En algorithmique, les opérateurs mathématiques suivants sont les plus utilisés:
OPERATEUR
|
OPERATION
|
( )
|
Parenthèses
|
+
|
Addition
|
-
|
Soustraction
|
*
|
Multiplication
|
/
|
Division
|
%
|
Modulo. 40 % 7 signifie «reste de la
division
de 41 par 7» (c'est à dire 6
car 40=(5*7)+6)
|
^
|
Elévation à une puissance
(5^3 =5*5*5)
|
L'évaluation d'une expression arithmétique obéït à l'ordre de priorité suivant:
Priorité
0: Expressions représentant des indices de tableaux
Priorité
1: Autres expressions placées entre parenthèses.
Priorité
2: Opérandes affectés des opérateurs *, / ou
%
Priorité
3: Opérandes affectés des opérateurs + ou -
Les opérandes de même priorité sont exécutés de gauche à droite.
EXEMPLE:
3 - ( 7 - T(A-2) * (B - 8) ) est évalué dans l'ordre
suivant:
- A-2 est utilisée comme indice du tableau T
- B – 8 Expression dans la parenthèse la plus intérieure
- T(A-2)* (B – 8) L'opérateur * est prioritaire sur l'opérateur – de
«7-T(A-2) »
- (7 - T(A-2) * (B – 8)) L'expression entre parenthèse est prioritaire sur
l'opérateur – de «3 - (7 -....»
- 3 - (7 - T(A-2) * (B – 8)) Il ne reste plus que l'opérateur – de 3 - .....
à exécuter.
II.4.3.REMARQUE:
Les langages de programmation mettent à disposition des développeurs beaucoup plus
d'opérateurs arithmétiques que les pseudo-codes. Ceci vient du fait que le but de l'analyse
algorithmique est beaucoup plus de faire ressortie la logique des traitements que leur contenu
mathématique. En fait, il faut éviter autant que possible de faire figurer dans un pseudo-code
des calculs détaillés qui diminuent la lisibilité et n'amènent rien à la
compréhension de la logique du traitement. On se contentera en général d'évoquer
ces calculs par une instruction en texte libre:
EXEMPLE:
DEBUT CalculPortee
// Déclaration des données
var VitesseInitiale en numerique
var Hausse en numerique
var Portee en numerique
// Debut procedure
ENTRER VitesseInitiale
ENTRER hausse
<Calcul de la portee de l'obus, puis transfer du résultat dans Portee>
SORTIR Portee
FIN CalculPortee
II.5.LES EXPRESSIONS LOGIQUES:
II.5.1.DEFINITION:
Les expressions logiques sont celles dont l'évaluation donne une valeur de type booléen: true
(vrai) ou false (faux). On les nomme parfois «assertions».
EXEMPLES:
- La terre est ronde est une assertion ayant la valeur vraie
- Le prénom de Napoléon Bonaparte n'était pas Napoléon est une
assertion ayant la valeur faux
- 3 fois 12 vaut 36 est une assertion ayant la valeur vraie
II.5.2.LES COMPARAISONS ARITHMETIQUES:
II.5.2.1.DEFINITION:
Une comparaison arithmétique consiste à comparer les valeurs de deux expressions arithmétiques
à l'aide d'un opérateur de comparaison:
<booleen> = <exp. mathématique> <opérateur de comparaison> <exp.
mathématique>
II.5.2.2.LES OPERATEURS DE COMPARAISON ARITHMETIQUE:
Les opérateurs de comparaison arithmétiques permettent de créer des variables logiques.
En effet, le résultat d'une comparaison entre deux expressions arithmétiques est un booléen
(valeurs true ou false, vrai ou faux). Les opérateurs de comparaison suivants sont les plus utilisés:
OPERATEUR
|
OPERATION DE COMPARAISON
|
=
|
Teste l'égalité numérique de deux expressions
|
<>
|
Teste l'inégalité numérique de deux expressions
|
<
|
x < y teste si x est plus petit que y
|
>
|
x > y teste si x est plus grand que y
|
<=
|
x <= y teste si x est plus petit ou égal
à y
|
>=
|
x >= y teste si x est plus grand ou égal
à y
|
EXEMPLES:
var A en numerique
A ← 25
B ← 15
A > 5 est une expression logique (comparaison) qui vaut vrai (true)
A > B est une expression logique (comparaison) qui vaut faux (false)
A-2 >= B+7 est une expression logique (comparaison) qui vaut vrai (true)
II.5.3.LES EXPRESSIONS LOGIQUES COMPOSEES:
II.5.3.1.DEFINITION:
Une expression logique composée est une expression composée de variables logiques, de constantes
logiques (true/false), d'expressions logiques ou de comparaisons, séparées par des opérateurs
logiques. Le schéma général est le suivant:
<exp. logique> :=:
<variable logique | constante logique | exp. Logique | comparaison>
<opérateur logique>
<variable logique | constante logique| exp. Logique | comparaison>
Une expression logique composée a pour valeur un booléen (true/false).
II.5.3.2.LES OPERATEURS LOGIQUES:
L'INTERSECTION (OPERATEUR ET)
a
|
b
|
a ET b
|
FAUX
|
FAUX
|
FAUX
|
FAUX
|
VRAI
|
FAUX
|
VRAI
|
FAUX
|
FAUX
|
VRAI
|
VRAI
|
VRAI
|
LA RÉUNION (OPERATEUR OU)
a
|
b
|
a OU b
|
FAUX
|
FAUX
|
FAUX
|
FAUX
|
VRAI
|
VRAI
|
VRAI
|
FAUX
|
VRAI
|
VRAI
|
VRAI
|
VRAI
|
LA NÉGATION (OPERATEUR NON)
a
|
NON a
|
FAUX
|
VRAI
|
VRAI
|
FAUX
|
L'EXCLUSION (OPERATEUR XOR)
a
|
b
|
a XOR b
|
FAUX
|
FAUX
|
FAUX
|
FAUX
|
VRAI
|
VRAI
|
VRAI
|
FAUX
|
VRAI
|
VRAI
|
VRAI
|
FAUX
|
LES PARENTHÈSES:
Dans une expression logique comme dans une expression mathématique, les parenthèses
délimitent une sous-expression qu'il faut évaluer individuellement.
EXEMPLES:
- (<la terre est ronde>) ET (<Elle tourne autour du soleil>) est vraie
- (<la lune est cubique>) OU (<Elle tourne autour de la terre>) est fausse
- (<la lune est cubique>) XOR (<Elle tourne autour de la terre>) est vraie Si la
variable A contient 25, NON( A > 15 ) est fausse.
- (NON <la lune est cubique>) XOR (Elle tourne autour de la terre) est fausse.
II.5.3.3.EVALUATION DES EXPRESSIONS LOGIQUES:
Dans une expression logique:
<
- Les parenthèses ne contenant pas d'autres parenthèses sont évaluées en
premier, puis remplacées par leur valeur booléenne, et ainsi de suite.
- L'opérateur NON est prioritaire sur ET, OU et XOR
- Les opérateurs ET et XOR sont prioritaires sur OU
- A égalité de priorités, l'évaluation se fait de gauche à droite.
EXEMPLE:
Si A = 12, B = -7, C = 9, l'expression VRAI ET ( ( A > B–2 ) OU NON ( C = 9 )) est
évalué de la manière suivante:
- On évalue d'abord (A > B-2), parenthèse ne contenant pas de parenthèse la
plus à gauche: 12>-9 est VRAIE. L'expression devient: VRAI ET ( VRAI OU NON ( C = 9 ))
- On évalue ensuite (C = 9), parenthèse ne contenant pas de parenthèse: 9 = 9
est VRAIE. L'expression devient: VRAI ET ( VRAI OU NON VRAI )
- On évalue alors ( VRAI OU NON VRAI ). L'opérateur NON étant prioritaire, on
évalue NON VRAI, ce qui donne FAUX. L'expression devient alors VRAI ET ( VRAI OU FAUX ), et
comme VRAI OU FAUX donne VRAI, l'expression devient: VRAI ET VRAI.
Ce qui donne finalement: VRAI ET ( ( A > B – 2 ) OU NON ( C = 9)) a pour valeur logique:
VRAI.
II.6.LES STRUCTURES ALTERNATIVES:
II.6.1.DEFINITIONS:
Un BLOC D'INSTRUCTIONS est constitué soit d'une seule instruction, soit d'une liste d'instructions
consécutives dont l'exécution peut être assimilée à celle d'une seule
instruction.
REMARQUE:
Ceci implique que l'exécution d'un bloc d'instructions débute à la première
instruction de la liste et se termine toujours par la dernière: on ne peut pas «sortir»
du bloc avant cette dernière instruction.
Une STRUCTURE ALTERNATIVE est un modèle de pseudo-code qui permet de conditionner l'exécution ou
non de BLOCS D'INSTRUCTIONS à la vérification d'EXPRESSIONS LOGIQUES.
REMARQUE:
On appelle souvent «instructions conditionnelles» les
structures alternatives. Cependant, il faut remarquer qu'une structure alternative n'est pas une instruction,
mais un ensemble de blocs d'instructions «enchassées» dans un schéma logique
matérialisé par des mots-clefs. L'appellation STRUCTURES conditionnelles serait plus adaptée.
II.6.2.L'ALTERNATIVE SIMPLE:
II.6.2.1.SCHÉMA GÉNÉRAL:
SI < expression logique > ALORS
Bloc d'instructions n° 1
SINON
Bloc d'instructions n° 2
FINSI
II.6.2.2.FONCTIONNEMENT:
- Si l'expression logique est vraie alors, on exécute la séquence d'instruction n° 1
- Sil'expression logique est fausse alors, on exécute la séquence d'instruction n° 2
On peut représenter ce mécanisme par le logigramme suivant:
II.6.2.3.SCHÉMA SIMPLIFIÉ:
Si le bloc d'instructions n° 2 est vide, on peut simplifier en:
SI < expression logique > ALORS
Bloc d'instructions n° 1
FINSI
II.6.2.4.EXEMPLE:
DEBUT TraitementDigicode
const Code = 3456
var Digicode en numerique
< Attendre l'entrée d'un code sur le digicode >
ENTRER Digicode // DEPUIS le clavier
SI ( Digicode = Code ) ALORS
<Déverrouiller la porte>
<Actionner le buzzer>
<Attendre le signal porte refermée>
<Verrouiller la porte>
SINON
<Emettre sur le haut-parleur la phrase ''code erroné''>
FINSI
FIN TraitementDigicode
II.6.3.ALTERNATIVES MULTIPLES:
II.6.3.1.SCHÉMA GÉNÉRAL:
SI < expression logique 1 > ALORS
Bloc d'instructions n° 1
SINON SI < expression logique 2 > ALORS
Bloc d'instructions n° 2
SINON SI < expression logique 3> ALORS
Bloc d'instructions n° 3
....................
SINON SI < expression logique n-1> ALORS
Bloc d'instructions n° n-1
SINON
Bloc d'instructions n° n
FINSI
Le fonctionnement correspond au logigramme suivant:
II.6.3.2.EXEMPLE:
ENTRER EtatfeuTricolore
SI ( EtatFeuTricolore = ''vert'' ) ALORS
<Accélérer>
SINON SI ( EtatFeuTricolore = ''jaune'' ) OU ( EtatFeuTricolore = ''Rouge'' ) ALORS
<Tenter de s'arréter avant le feu>
SINON // Etat clignotant
<Ralentir>
FINSI
II.6.4.IMBRICATION D'ALTERNATIVES SIMPLES:
II.6.4.1.PRINCIPE:
Un bloc d'instructions devant obligatoirement se comporter comme une seule instruction, il doit obligatoirement
englober entièrement les structures alternatives qu'il renferme. De ce fait, une structure alternative
imbriquée dans une autre doit obligatoirement être englobée par un des blocs de cette
dernière.
II.6.4.2.SCHÉMA GÉNÉRAL:
SI < expression logique 1 >
ALORS
Séquence d'instruction n° 1
SINON
SI < expression logique 2 > ALORS
Séquence d'instruction n° 2
SINON
Séquence d'instruction n° 3
FINSI
FINSI
Ce qui donne le logigramme suivant:
II.6.4.3.EXEMPLE:
DEBUT Traitement digicode
const Code = 3456
var Digicode en numerique
< Attendre l'entrée d'un code sur le digicode >
ENTRER Digicode
SI ( Digicode = Code ) ALORS
SI <La porte est fermée> ALORS // alternative imbriquée
<Déverrouiller la porte>
<Actionner le buzzer>
FINSI
<Attendre le signal porte refermée>
<Verrouiller la porte>
SINON
<Emettre sur le haut-parleur la phrase «code erronné»
FINSI
FIN TraitementDigicode
II.6.5.LES COMMUTATEURS (SWITCHES):
Les commutateurs (switches) sont des structures alternatives très employées dans les langages
de programmation. Equivalents logiques des alternatives multiples, ils les remplacent avantageusement dans
les cas complexe, car leur notation est plus adaptée.
II.6.5.1.SCHÉMA GENERAL:
SUIVANT LE CAS <expression>
FAIRE
CAS <valeur n°1>:
Bloc d'instruction n° 1
CAS <valeur n°2>:
Bloc d'instruction n°
CAS ....................
........................
CAS <valeur n° m-1>:
Bloc d'instruction n° m-1
AUTRES CAS:
Bloc d'instruction n° m
FINCAS
REMARQUES:
- Expression peut être une expression logique ou arithmétique ou une variable simple.
- les valeurs qui suivent le mot clef CAS doivent être des constantes de même type
que <expression>
II.6.5.2.FONCTIONNEMENT:
L'expression libellée dans la première ligne est évaluée, puis le bloc
d'instruction correspondant au CAS ou la valeur est égale à celle de l'expression
(et uniquement celui-ci) est exécuté. Si aucun cas ne convient, le bloc d'instructions
AUTRES CAS est exécuté.
II.6.5.3.LOGIGRAMME:
II.6.5.4.EXEMPLE:
DEBUT TrouverPrenoms
var Nom en chaine de caracteres
<Attendre l'entrée d'un nom de famille>
ENTRER Nom
SUIVANT LE CAS Nom FAIRE
CAS BALZAC:
SORTIR «Honoré»
CAS Hugo:
SORTIR «Victor»
................................
................................
CAS Flaubert:
SORTIR «Gustave»
AUTRES CAS:
SORTIR «Prénom inconnu»
FINCAS
FIN TrouverPrenoms
II.7.LES STRUCTURES ITERATIVES (BOUCLES):
II.7.1.LA BOUCLE TANT QUE:
II.7.1.1.SCHÉMA GÉNÉRAL:
TANT QUE <expression logique ou variable booléenne> FAIRE
<Bloc d'instructions>
FIN TANTQUE
II.7.1.2.FONCTIONNEMENT:
Tant que <expression logique ou variable booléenne> a la valeur VRAI, on exécute la
séquence d'instructions, puis on recommence jusqu'à ce que <expression logique ou variable
booléenne> devienne fausse.
Si, au départ, <expression logique ou variable booléenne> est déjà fausse,
on saute complêtement la boucle.
La boucle TANTQUE est utilisée quand le nombre d'itérations dépend d'une condition dont
la valeur varie en fonction des traitements contenus dans la boucle: à priori, on ne sait pas combien
d'itérations vont être effectuées.
ATTENTION:
cette boucle implique que le bloc d'instructions interne puisse modifier la valeur
de <expression logique ou variable booléenne>. Sinon, il n'y a aucune raison que l'on puisse
terminer la boucle après y être entré une fois...
II.7.1.3.LOGIGRAMME:
La boucle TANT QUE est équivalente au logigramme suivant:
II.7.1.4.EXEMPLES:
EXEMPLE 1
var A, B en numérique
A ← 5
B ← 300
i ← 1
TANTQUE ( A^i < B )
i = i+1
FIN TANTQUE
EXEMPLE 2
TANTQUE ( 3 < 5 )
séquence d'instructions
FIN TANTQUE
EXEMPLE 3
var A, B en numérique
ENTRER A
ENTRER B
i ← 1
TANT QUE (A^i< B) ET (i<10)
i = i+1
FIN TANTQUE
II.7.2.LA BOUCLE POUR:
II.7.2.1.SCHÉMA GÉNÉRAL:
POUR <compteur> ← <valeur debut> à <valeur fin> PAS DE <pas de progression>
<Bloc d'instructions>
<compteur> SUIVANT
<compteur>, <valeur debut>, <valeur fin> et <pas de progression>
sont des nombres entiers négatifs, nuls ou positifs
II.7.2.2.FONCTIONNEMENT:
- Au départ, le compteur est chargée à sa valeur de début.
- Tant que le compteur n'est pas égal à la valeur de fin, on effectue la séquence
d'instructions et on ajoute algébriquement le pas au compteur (on peut donc faire progresser ou
régresser le compteur)
La boucle POUR est utilisée quand on sait combien d'itérations doivent être
effectuées.
II.7.2.3.LOGIGRAMME ÉQUIVALENT:
II.7.2.4.EXEMPLE:
Calculer les 10 premières puissances paires d'un nombre et les afficher par ordre
décroissant:
var A, P en numerique
ENTRER A
POUR C ← 20 A 2 PAS DE -2
P ← A^C
SORTIR «la puissance », C, «ieme de A est=», P
C SUIVANT
II.8.PROCEDURES ET FONCTIONS
II.8.1.LES PROCEDURES:
II.8.1.1.DEFINITION:
Une procédure est un algorithme qui satisfait aux conditions suivantes:
- Son exécution peut être déclenchée depuis un autre algorithme,
à l'aide d'une seule instruction, dite «instruction d'appel de procédure».
- A la fin de son exécution, la procédure rend la main à l'algorithme appelant,
qui peut reprendre son exécution à partir de l'instruction qui suit l'instruction
d'appel.
- L'algorithme appelant peut communiquer à la procédure des valeurs que celle-ci
pourra utiliser dans ses traitements (passage d'arguments par valeurs) ou des noms de variables dans
lesquelles la procédure pourra ranger les résultats de ses traitements, de façon
à ce que l'appelant puisse récupérer ces résultats (passage d'arguments par
référence).
II.8.1.2.FONCTIONNEMENT:
Le schéma suivant représente un algorithme appelant qui effectue deux appels à
une procédure:
COMMENTAIRES:
Les
instructions de l'algorithme appelant sont exécutées
jusqu'à la première instruction d'appel
La
première instruction d'appel interromp la séquence
d'exécution de l'algorithme appelant et transfère
l'exécution vers le début de la procédure.
La
procédure est exécutée jusqu'à Fin
procédure qui retransfère l'exécution vers
l'appelant, juste après l'instruction d'appel.
L'exécution
de l'algorithme appelant reprend donc avec l'instruction j et se
poursuit jusqu'à la nouvelle instruction d'appel de
procédure.
La
deuxième instruction d'appel interromp de nouveau la séquence
d'exécution de l'algo. appelant et transfère comme
précédemment l'exécution vers le début
de la procédure.
La
procédure est exécutée jusqu'à Fin
procédure qui retransfère l'exécution vers
l'appelant, juste après l'instruction d'appel.
L'exécution
de l'algorithme appelant reprend donc avec l'instruction k, et ainsi
de suite....
REMARQUE:
Les procédures sont le plus souvent appelées «SOUS-PROGRAMMES»
II.8.1.3.SCHÉMA DE DÉCLARATION D'UNE PROCÉDURE:
PROCEDURE <Nom de procedure>
(
var <nom argument_1> en <type de donnée> par <valeur/référence>,
var <nom argument_1> en <type de donnée> par <valeur/référence>,
.............................................................,
var <nom argument_1> en <type de donnée> par <valeur/référence>
)
<Déclaration des variables locales>
<instructions de la procedure>
FINPROCEDURE
REMARQUES:
La déclaration d'une procédure comprend non seulement le nom de cette procédure, mais
aussi la déclaration des arguments que cette procédure attend de l'appelant. Chaque argument
est une variable dont le rôle peut être:
- Soit de récupérer une valeur (numérique, alphanumérique, caractère,
booléene, etc.) transmise par l'appelant (C'est le passage d'argument par valeur)
- Soit de récupérer une référence vers une variable de l'appelant (passage
d'argument par référence)
- Dans le premier cas, la procédure ne dispose que d'une valeur qu'elle peut utiliser pour ses
traitements internes. Les arguments passés par valeur sont donc uniquement des arguments
d'entrée de la procédure.
- Dans le deuxième cas, la procédure peut:
- Soit récupérer la valeur contenue dans la variable, comme elle le ferait pour un
passage par valeur.
- Soit utiliser cette variable pour retourner un résultat à l'appelant.
Les arguments passés par référence sont donc à la fois des arguments
d'entrée et de sortie de la procédure.
II.8.1.4.SCHEMA D'APPEL D'UNE PROCÉDURE:
<Nom de procédure> ( <argument 1>, <argument 2>,...,<argument n> )
- Les arguments seront libellés dans l'instruction d'appel dans le même ordre que dans
l'instruction de déclaration de la procédure. Ils doivent être de même type que
dans la déclaration.
- Un argument passé en valeur peut être une étiquette de variable ou une valeur
(numérique, alphanumérique, caractère, booléenne)
- Un argument passé en référence doit être obligatoirement une étiquette
de variable (en effet, dans ce cas, ce n'est pas la valeur de la variable qui est passée, mais une
«référence» sur cette variable(ce qui correspont à l'adresse de son
conteneur).
II.8.1.5.EXEMPLE:
Procédure de comparaison de deux nombres:
compare 2 nombres X et Y et renvoie une chaîne de caractères indiquant le résultat:
PROCEDURE Compare
(
var X en numerique par valeur,
var Y en numerique par valeur,
var R en chaîne de caractères par référence
)
SI X > Y ALORS
R ←''Y est plus grand que X''
SINON
R ←''Y est plus petit ou égal à X''
FINSI
FIN PROCEDURE
Algorithme appelant:
DEBUT
......................................
var PremierNombre, SecondNombre en numerique
var TroisiemeNombre, QuatrièmeNombre en numerique
var Reponse en chaîne de caractères
......................................
......................................
ENTRER PremierNombre, SecondNombre
Compare ( PremierNombre, SecondNombre, Reponse ) // Premier appel à Compare
SORTIR Reponse
......................................
......................................
ENTRER TroisiemeNombre, QuatriemeNombre
Compare ( TroisiemeNombre, QuatriemeNombre, Reponse ) // Deuxième appel à Compare
SORTIR Reponse
......................................
FIN
II.8.1.6.PORTEE DES DECLARATIONS DE DONNEES:
Les données déclarées à l'intérieur d'une procédure (données
dites «locales») ne sont utilisables qu'à l'intérieur de cette procédure.
Les données déclarées en dehors d'une procédure ne sont pas utilisables par
celle-ci. De ce fait, deux données différentes peuvent avoir la même étiquette
pourvu qu'elles ne soient pas déclarées dans la même procédure.
REMARQUE:
La plupart des langages informatiques permettent de déclarer certaines données
«GLOBALES», c'est à dire utilisables quel que soit l'endroit ou on se trouve. Cependant,
cette pratique n'est pas très recommandée, car elle peut favoriser les effets de bord.
De ce fait, cette possibilité n'est en général pas donnée dans les langages algorithmiques.
II.8.2.LES FONCTIONS
II.8.2.1.DEFINITION:
Les fonctions sont des procédures conçues pour renvoyer une valeur et une seule.
II.8.2.2.SCHEMA DE DECLARATION D'UNE FONCTION:
FONCTION <Nom de fonction>
(
var <nom arg_1> en <type donnée 1> par valeur|reference,
................................
var <nom arg_n> en <type donnée n> par valeur|reference
) en <Type de la valeur de retour>
<Déclaration des variables locales>
<Bloc d'instructions (corps de la fonction)>
RETOUR <Valeur de retour>
FIN FONCTION
On peut donc associer à chaque fonction un type, qui est le type de la donnée retournée
(par l'instruction RETOUR).
II.8.2.3.APPEL D'UNE FONCTION:
Une fonction ayant une valeur de retour et une seule, elle peut être manipulée comme une variable
du type de cette valeur de retour:
- Dans une affectation:
Var R en <Même type que la fonction)>
R ← <Nom de fonction> ( Valeur_arg 1,..., Valeur_arg n °)
- Dans une expression (fonction Cos):
SI ( 3*Cos( X ) < 1 ) alors ....
II.8.2.4.EXEMPLE:
//-----------------------------------------------------------------------------
// FONCTION CompareDeuxNombres
//-----------------------------------------------------------------------------
// PRINCIPE:
// Fonction de comparaison de deux nombres: compare 2 nombres X et Y
// et renvoie une chaîne de caractères indiquant le résultat
// La fonction réalise le même traitement que la procédure du sous-chapitre
// précédent, mais le résultat est passé dans la valeur de retour de la
// fonction au lieu d'être passé par référence).
//-----------------------------------------------------------------------------
// DONNEES D'ENTREE:
// X: Valeur du premier nombre
// Y: Valeur du second nombre
//-----------------------------------------------------------------------------
// DONNEE DE SORTIE:
// Chaîne de caractère indiquant le résultat
//-----------------------------------------------------------------------------
FONCTION CompareDeuxNombres ( var X en numerique par valeur, var Y en numerique par valeur )
SI X > Y ALORS
RETOUR ''Y est plus grand que X''
SINON
RETOUR ''Y est plus petit ou égal à X''
FINSI
FIN FONCTION
//-----------------------------------------------------------------------------
// Algorithme appelant:
//-----------------------------------------------------------------------------
DEBUT
......................................
var PremierNombre, SecondNombre en numerique
var TroisiemeNombre, QuatrièmeNombre en numerique
var Reponse en chaîne de caractères
......................................
ENTRER PremierNombre, SecondNombre
Reponse = CompareDeuxNombres ( PremierNombre, SecondNombre )
SORTIR Reponse
......................................
......................................
ENTRER TroisiemeNombre, QuatriemeNombre
Reponse = Compare ( TroisiemeNombre, QuatriemeNombre )
SORTIR Reponse
......................................
FIN