INFORMATIQUE :
Thème : Algorithme
* Un algorithme est plus souple et général
qu'un programme. En effet, il est applicable à tous les programmes
*
1) Définition :
Décomposition d'un problème en étapes élémentaires
dans le but de sa résolution.
2) Sa conception :
- Réfléchir aux informations à manipuler et
à la méthode de codage de celle-ci.
- Analyser le problème en le décomposant en sous-problème
= Analyse descendante = Programmation modulaire.
- Ecrire un algorithme compréhensible en commentant celui-ci, en
utilisant des noms significatifs et en ayant une présentation rigoureuse.
- Penser à l'utilisateur
3) De l'algorithme au programme
La machine comprend le langage machine (binaire 0/1)
Premier langage : l'Assembleur
Puis des langages évolués : impératifs (Pascal, Basic...)
et fonctionnels (CAML...)
La machine traduit ces langages par des programmes (compilateurs et/ou
interpréteurs) en langage machine.
La syntaxe doit-être correcte (->exécutable) ainsi que
la sémantique (->un sens).
Pour mettre au point un programme, on fait des jeux d'essais. En cas de
problèmes, on retourne à l'algorithme.
Exemple : Algorithme d'Euclide
Méthode de calcul :
pgcd de 24(A) et de 9(B)
15 9
6 3
3 3
- Obtenir A et B
- Mettre en oeuvre Euclide <-> Répéter jusqu'à
ce que A=B<->Remplacer le plus grand de A et de B par la différence
de ces deux nombres.
Thème : instructions simples
1) Lecture
Elle sert à stocker des informations venant de l'utilisateur
dans la mémoire de l'ordinateur
- Lire (Nom_de_Variable)
Le programme s'interrompt et attend que l'utilisateur tape une valeur.
Cette valeur est rangée en mémoire dans la variable désignée.
2) Affectation
- Nom_de_Variable <- Expression
L'expression est évaluée et sa valeur est rangée dans
la variable indiquée à gauche de la flèche.
L'expression peut-être : - une valeur
- le résultat d'un calcul
- le contenu d'une autre variable.
Exemple :
A <- 3,14
B <- 5
C <- 8
B <- A+1
B <- B+1
C <- B
3) Ecriture
Ecrire (expression)
Expression pouvant être une valeur, un résultat, un message,
le contenu d'une variable...
Exemple :
Ecrire (3) -> Valeur numérique
Ecrire (Prix) -> Contenu d'une variable
Ecrire (Prix+Taux)
Ecrire ("Prix") -> Chaîne de caractère, message
Ecrire ("Le prix est" Prix) -> Expression mixte
* Toute instruction de lecture sera précédé d'une
instruction d'écriture d'un message d'information. *
Exemple : Algorithme prixtte
{Algorithme de calcul d'un prix avec taxe, taux de taxe : 20,6%}
Variable utilisée : Prix HT, Prix TTC : réel
Début
{saisie données}
Ecrire ('Donner votre prix hors taxe')
Lire (Prix HT)
{calcul}
Prix TTC <- Prix HT * (1+20.6/100)
{Résultat}
Ecrire ('Le prix avec taxe est', Prix TTC)
Fin
Exemple :
Algo AireDisque En tête
{Algo de calcul de l'aire d'un disque}
Const Pi=3,14 Zone déclarative
Variable Rayon, Aire : réel
Début Zone
exécutive
{Saisie de données}
Ecrire ('Ce programme calcule l'aire d'un disque')
Ecrire ('Donnez le rayon du disque en cm')
Lire ('Rayon')
{calcul}
Aire <- Rayon * Rayon * Pi
{Résultat}
Ecrire ('L'aire d'un disque de rayon ',Rayon,'est ',Aire,'cm?.')
Fin
Thème : Objets de base
1) Constante et variable
constante -> nom <-> valeur
variable -> nom <-> zone mémoire, type
2) Type de données simples :
a/ Entier
i) Valeurs possibles : Sous ensemble de Z
ii) Opérateurs de calcul : + - * div mod
iii) Opérateurs de comparaison : = < > <= >= <>
b/ Réel
i) Valeurs possibles : Sous ensemble de R
ii) Opérateurs de calcul : + - * / fonction
iii) Opérateurs de comparaison : = < > <= >= <>
c/ Caractère
i) Valeurs possibles : "a", "A"...
ii) Opérateurs de calcul : vus ultérieurement
iii) Opérateurs de comparaison : = < > <= >= <>
d/ Booléen
i) Valeurs possibles : Vrai, Faux
ii) Opérateurs de calcul : et ou non
iii) Opérateurs de comparaison : =
3) Représentation des entiers
Les entiers positifs sont représentés par leur décompositions
en base 2
exemple : 0 -> 0 1 -> 1 2 -> 10 3 -> 11 4 -> 100 5 ->
101 6 -> 110
Pour les négatifs, on utilise la méthode de compléments
à deux.
4) Représentations des réels
Un sous-ensemble rationnel
Méthode dite à virgules flottantes (flotting point)
5) Représentationdes caractères
Chaque caractère est noté par une suite de 0 et de
1 : code ASCII
6) Les booléens
Type booléen (ou logique), ils sont associés à
une condition ou à une expressin logique
exemple : x > 3
Conditions simples (utilise des comparaisons) ou composées (relie
des conditions simples par les opérateurs logiques).
Tables de vérité :
Opérateur ET
________________
| A | B |A
et B|
----------------------
| Faux | Faux | Faux |
----------------------
| Faux | Vrai | Faux |
----------------------
| Vrai | Faux | Faux |
----------------------
| Vrai | Vrai | Vrai |
----------------------
Opérateur ou
________________
| A |B
|A ou B|
----------------------
| Faux | Faux | Faux |
----------------------
| Faux | Vrai | Vrai |
----------------------
| Vrai | Faux | Vrai |
----------------------
| Vrai | Vrai | Vrai |
----------------------
Opérateur non
___________
| A |Non A|
---------------
| Faux|Vrai |
---------------
| Vrai | Faux |
---------------
On peut déclarer des variables de type logique
NB: On ne peut pas utiliser une instruction de lecture avec une variable
de type logique.
Exemple :
test <- Vrai
trouvé <- Faux
test <- trouvé
condition <- (x=3) et (x>0) avec x un entier
Un bit suffit à la machine pour représenter le type booléen.
Thème : Structure de choix
1) Structure alternative
Structure : instruction complexe
SI condition
ALORS
action 1
SINON
action 2
FIN SI
Une condition est une expression logique ou une variable logique évaluée
à Vrai ou Faux
2) Structure conditionnelle ou alternative incomplète
SI condition
ALORS
action
FIN SI
Exemple : algorithme qui demande un entier (relatif) à l'utilisateur
et affiche sa valeur absolue.
Algo ValeurAbs
{affiche la valeur abs d'un entier fourni par l'utilisateur}
Variable x:entier
Début
{saisie}
Ecrire ('Donner un entier pour affichage de sa valeur absolue'}
Lire (x)
{affichage}
SI x>0
ALORS
Ecrire ("Valeur absolue = ",x)
SINON
Ecrire ("Valeur absolue = ",-x)
FINSI
FIN
Autre exemple: Algorithme qui demande 2 entiers (relatifs) à l'utilisateur
et les affiche dans l'ordre croissant.
Algo Ordre Croissant
{Affichage dans l'ordre croissant de 2 entiers fournis par l'utilisateur}
Variable x,y : entier
Début
{saisie}
Ecrire ("Affichage ordonné de 2 entiers, donner le premier")
Lire (x)
Ecrire ("Donner le second entier")
Lire (y)
SI X=Y
ALORS
Ecrire ("Egalite ",x)
SINON {x<>y}
SI x < y ALORS
Ecrire (x,"<",y)
SINON {x>y}
Ecrire (x,">",y)
FIN SI
FIN SI
Fin
3) Alternatives imbriquées
Exemple d'imbrication :
SI condition a
ALORS
{Action 1.a}
SI condition b
ALORS
{action 1.b}
SINON
{action 2.b}
FIN SI
SINON
{action 2.a}
FIN SI
On peut avoir plusieurs niveaux aussi bien dans le alors que dans le sinon.
Thème : Structures répétitives
Structure : instruction
1) Boucle POUR
1-1) Rôle
Répéter plusieurs fois la même action dans le cas où
l'on connaît le nombre de fois que l'on doit répéter
l'action. 1-2) Ecriture algorithmique
Deux formes :
a/ boucle croissante
Pour un indice croissant d'une valeur initiale (VI) à une valeur
finale (VF), faire une action.
Exemple: Pour ind cr 1 à 5 faire
Ecrire (ind)
Fin Pour
b/ boucle décroisssante
Pour un indice décroissant d'une valeur initiale (VI) à une
valeur finale (VF), faire une action.
Exemple: Pour ind décr 5 à 1 faire
Ecrire (ind)
Fin Pour
1-3) Exemples
a/
Calcul de la somme des premiers entiers naturels jusqu'à n fournis
par l'utilisateur.
Méthode : accumulation successive de chaque entier dans une variable
somme.
Au départ, on mettra somme à 0 puis on ajoutera 1 puis 2
puis 3...puis n
quand somme vaut 0
somme <- somme + 1
quand somme vaut 1
somme <- somme + 2
Algo de calcul de la somme des premiers entiers
{demande un nombre n puis calcule et affiche la somme 1+2+3+..+n}
Variables N,I,somme : entiers
Début
Ecrire ("Donner la valeur de l'entier n pour lequel vous voulez calculer
: 1+2+...+n")
Lire (N)
{Le principe de l'algo va constituer à accumuler au fur et à
mesure dans somme les nombres 1,2,3,...,n}
somme <- 0 {initialisation de l'accumulateur}
Pour I cr de 1 à N faire
somme <- somme + I {accumulation de I à chaque itération}
Fin Pour
Ecrire (" La somme des ",N,"premiers entiers = ",somme)
Fin
Jeu d'essai
b/
Afficher à l'écran tous les diviseurs d'une entier naturel
n fourni par l'utilisateur ainsi que le nombre total de ces diviseurs.
Algo diviseur
{Algo de tous les diviseurs d'un nombre entier N fourni par l'utilisateur
ainsi que le nombre total de ces diviseurs}
Variables N,A,compteur : entiers
DEBUT
{saisie}
Ecrire ("Donner un entier positif pour l'affichage de ses diviseurs")
Lire (N)
{initialisation du compteur}
compteur <- 0
POUR A cr 1 à N faire
SI A divise N
ALORS
Ecrire (A," est un diviseur de ",N)
compteur <- compteur + 1
FIN SI
FIN POUR
Ecrire (" il y a ",compteur," diviseur de ",N)
FIN
Jeu d'essai :
Thèmes : Types structurés
de données
1) Tableaux à une dimension
1-1) Définition :
(**?**)
1-2) Utilisation :
Les instructions (lire, écrire, affectation) peuvent s'utiliser
sur chacune des cases du tableau.
Exemple :
Lire (T[1])
Ecrire (T[4])
T[4]<-T[5]+5
Lire (T[j]) si j est un entier
T[2i+1] = 5
L'indice d'une case d'un tableau est une expression entière.
Par contre, on ne peut pas utiliser Lire ou écrire sur T masi on
peut utiliser l'application entre deux tableaux de même type : T1
<- T2
1-3) Déclaration
a/ Déclaration en un temps
T:tableau [1...10] de réels
ou
cst Nmin=1
Nmax=10
Variable T: tableau [Nmin...Nmax] de réels
b/ Déclarations en deux temps
Premier temps : type, exemple : type tab = tableau [1...10] de réels
Deuxième temps : var , exemple : var T : tab
ou
cst Nmin = 1
Nmax = 10
type tab = tableau [Nmin...Nmax] de réels
Variable T : tab
1-4) Algo de saisie
Algo saisie de tableau
{remplir un tableau fourni par l'utilisateur}
Cst Nmin = 0
Nmax = 99
Type table = tableau [Nmin...Nmax] d'entiers
Variables i, n : entiers {i indice et n dernier indice utile}
DEBUT
{saisie de n}
Ecrire("Saisie d'un tableau jusqu'à la case n")
Ecrire("Donner n <= ",Nmax)
Lire (n)
{remplissage du tableau}
POUR i cr 0 à n faire
Ecrire ("case n ",i)
Lire (T[i])
FIN POUR
FIN
1-5) Débordement
Tentative d'accéder à une case hors de l'intervalle Nmin-Nmax
2) Tableaux à deux dimensions (cf matrices)
Déclaration:
Variable M: tableau [0...99,1...50]de réels
ou
cst Lmin=0
Lmax=99
Cmin=1
Cmax=100
type matrice=tableau [Lmin...Lmax,Cmin...Cmax] de réels
Variable M :matrice
3) Chaîne de caractères
Type prédéfini :
Chaîne (Par défaut, 255 caractères) ou chaîne
[taille]
Exemple :
ch : chaîne [30]
ch <-"informaticien"
Pour certaines manipulations, une chaîne peut-être considérée
comme un tableau de caractères dont l'indice minimum est 1
Exemple: ch[2] vaut "n"
Thème : Procédures et
fonctions
1) Sous-programmes
a/ Analyse descendante ou programmation modulaire
On écrit des modules ou sous-programmes
b/ Définition
Un sous-programme est un bloc d'instructions séparé du bloc
principal d'instructions (programme principal).
C'est dans le programme principall que s'exécute l'action. On doit
faire référence aux instructons du sous-programme (=appel
du sous-programme).
c/ Exemple
DEBUT
Ecrire ("Donner la somme de ",X,"et ",Y)
Lire (somme)
résultat <- X+Y
SI somme = résultat
ALORS
Ecrire ("juste")
SINON
Ecrire ("Non, le résultat est : ",résultat)
FIN SI
FIN
On déclare de manière analogue les autres procédures.
{corps du programme principal}
DEBUT
Ecrire ("Programme de test de calcul")
{menu choix d'opérations}
Ecrire ("a addition")
Ecrire ("s soustraction")
Ecrire ("m multiplication")
Ecrire ("d division")
Ecrire ("Votre choix (a, s, m ou d) ?")
Lire (rep)
{saisie des deux nombres}
Ecrire ("Donner un nombre")
Lire (a)
Ecrire ("Un autre nombre")
Lire (b)
{traitrement}
SI rep = 'a'
ALORS
TestAddition (a,b)
FINSI
SI rep = 's'
ALORS
TestSoustraction (a,b)
FINSI
SI rep = 'm'
ALORS
TestMultiplication (a,b)
FINSI
SI rep = 'd'
ALORS
TestDivision (a,b)
FINSI
FIN
2) Procédure
a/ Rôle : résoudre un sous-problème quelconque
mais clairement défini
ex: Calcul et affichage de deux matrices fournies par l'utilisateur.
On utilisera trois procédures :
- saisie : stocker dans un tableau à deux dimensions une matrice
carrée donnée par l'utilisateur.
- somme : stocker dans un tableau àdeux dimensions la somme de deux
matrices carrées.
- affichage : afficher une matrice carrée.
b/ Paramètres et variables locales
On appelle paramètres, les objets qui entrent en jeu dans les communications
de valeur entre un sous-programme et le programme principal.
On parle de paramètres formels au moment de la déclaration
du sous-programme et effectifs au moment de l'appel du sous-programme.
Un sous-programme a besoin de variables locales (internes). Leurs valeurs
n'ont pas à être communiquées à l'extérieur.
Elles seront déclarées localement.
C'est au moment de l'appel que s'effectue effectivement le travail.
Au moment de la déclaration, tout est formel.
-> Valeur initiale
i) données : doit-être définie
ii) données modifiées : doit-être définie
iii) résultat : quelconque
-> Valeur finale
i) données : identique à valeur initiale
ii) données modifiées : (re)définie
iii) résultat : définie
-> Paramètres effectifs lors de l'appel de la procédure
i) données : expression ou identificateur initialisée
ii) données modifiées : identificateur initialisé
iii) résultat : identificateur
-> Contrainte sur le paramètre
i) données : ne doit jamais être modifiée
ii) données modifiées : peut-être modifiée
iii) résultat : doit-être affecté à une valeur
Cst : Nmax
Type matrice = tableau [INmax,INmax] dans réels
{déclarations des sous-programmes}
.....................
Programme principal
Variable A,B,C : matrice
dim :entier
DEBUT
Ecrire ('Le sous-programme de calcul de la somme de 2 matrices carrées
à dimension n')
Ecrire ('Quelle est la dimension souhaitée ?')
Lire (dim)
Ecrire ('Saisie de la première matrice')
{Appel de s.p (param effectifs : A,dim)}
saisie (A,dim)
Ecrire ('Saisie de la deuxième matrice')
{Appel de s.p (param effectifs : B,dim)}
saisie (B,dim)
Ecrire ('Saisie de la somme des deux matrices')
{Appel de s.p (param effectifs : A,B,dim,c)}
saisie (A,B,dim,c)
Ecrire ('Affichage de la somme de deux matrices données.')
{Appel du s.p (param effectifs : C,dim)}
Affichage (c,dim)
FIN
Variable locale : objet dont à besoin le programme mais objet non
concerné par les communications avec l'extérieur.
c/ Déclaration d'une procédure
procédure : Nom procédure (param formels avec nature et type)
variable : déclaration des variables locales à la procédure.
DEBUT
instruction de la procédure
FIN
On peut regrouper les paramètres si ils sont de même nature
et de même type. Les paramètres effectifs doivent être
fourni à la procédure dans le même ordre que les paramètres
formels et doivent être de même type.
3) Fonctions
a/ Rôle
La notion de procédure est plus générale que celle
de fonction. La fonction a seulement pour but de déterminer une
valeur.
b/ Paramètres et variables locales
Identique pour les fonctions et les procédures
c/ Déclaration d'une fonction
fonction : Nom fonction (param formels avec type):type résultat
variable : déclaration des variables locales
DEBUT
instruction de la fonction
Nom fonction retourne expression
FIN
Exemple :
Fonction min (x,y:entiers):entier
DEBUT
SI x<= y
ALORS
min retourne x
SINON
min retourne y
FIN SI
FIN
* Un appel de fonction se fait à l'intérieur d'une instruction
(qui peut manipuler une valeur) car une fonction est en fait semblable
à une valeur.
Thèmes : Structure répétitive,
boucle tant que
1) Rôle :
Effectuer la répétition d'une action tant qu'une certaine
condition est vérifiée
2) Ecriture algorithmique
TANT QUE condition FAIRE
action
FIN TANT QUE
avec condition : expression booléenne
3) Schémas de traitement
-> Traitement d'une suite de valeurs.
a/ Arrêt du traitement par une valeur particulière
Algo Somme-entiers
{Somme d'une suite d'entiers positifs saisis successivement au clavier,
arrêt de la saisie avec -1}
Variable somme,valeur,compteur : entiers
DEBUT
Ecrire ("Somme d'entiers positifs")
Ecrire ("Donnez une première valeur (ou -1 pour arrêter)")
Lire (valeur)
somme <-0
compteur <-0
{boucle de traitement}
TANT QUE valeur <> -1 FAIRE
{traitement courant}
somme <- somme + valeur
compteur <- compteur + 1
{valeur suivante}
Ecrire ("Valeur suivante (ou -1 pour arrêter)")
Lire (valeur)
FIN TANT QUE
{résultat}
Ecrire ("La somme des ",compteur," valeurs saisies est :
", somme)
FIN
OBTENIR PREMIERE VALEUR
Tq valeur <> valeur particulière faire
TRAITEMENT
VALEUR SUIVANTE
FIN tq
b/
Algo somme-entier
variable : somme, valeur, compteur : entier
rep : caractère
DEBUT
Ecrire ("Somme d'entiers positifs")
Ecrire ("Avez-vous une valeur à saisir (O/N) ? ")
Lire (rep)
somme <- 0
compteur <- 0
{boucle de traitement}
TANT QUE rep ="O" FAIRE
{saisie de valeurs}
Ecrire ("Valeurs ?")
Lire (valeur)
{Traitement de la valeur}
somme <- somme + valeur
compteur <- compteur + 1
Ecrire ("Encore (O/N) ? ")
Lire (rep)
FIN TANT QUE
{résultat}
Ecrire("....")
FIN
INTIALISATION DE CONDITION
Tq condition faire
OBTENIR VALEUR
TRAITEMENT
MISE A JOUR DE CONDITION
Fin tq
* blindage : exigence d'une valeur correspondante aux contraintes posées.
Exemple : contrainte
Valeur comprise entre 0 et 20
....
....
....
Ecrire ("Donnez une valeur comprise entre 0 et 20")
Lire (valeur)
TANT QUE (valeur < 0) ou (valeur > 0) FAIRE
Ecrire ("Entre 0 et 20 !")
Lire (valeur)
FIN TANT QUE
* Menu
....
....
....
rep <- 1 {on force l'entrée dans la boucle}
TANT QUE rep <> 0 FAIRE
{affichage des options}
Ecrire ("1: charger")
Ecrire ("2: copier")
.....
Ecrire ("0: quitter")
{saisie du choix}
Ecrire ("Votre choix (0,1,2)")
Lire (rep)
{blindage}
TANT QUE (rep <> 0) et (rep <> 1).... FAIRE
Ecrire ("0,1,2")
Lire (rep)
FIN TANT QUE
{traitement}
SI rep = 1
ALORS
traitement
SINON
SI rep = 2
ALORS traitement2
SINON...
FIN SI
FIN SI
FIN TANT QUE
FIN
Thème : Structure de choix
CHOIX MULTIPLES :
Choix selon variables
valeur 1:
action 1
valeur 2:
action 2
...
AutresChoix
ActionAutreChoix
FinChoix
Thème : Structure répétitive
: boucle REPETER
1) Rôle :
L'action est au moins exécuter une fois.
REPETER
action
JUSQU'A condition
Si la condition est vraie, on sort de la boucle.
On a l'équivalence entre :
REPETER C <- Faux
action et TANT QUE non C FAIRE
JUSQU'A C action
FIN TANT QUE
et aussi entre :
TANT QUE C FAIRE SI C
action et ALORS
FIN TANT QUE REPETER
action
JUSQU'A non C
FIN SI
-> Utilisation : La boucle répéter n'est pas adaptée
au traitement d'une suite de valeurs se terminant par une valeur particulière
qui ne subit pas le traitement.
Le schéma suivant ne se vérifie pas :
Obtenir la premiere valeur
SI valeur <> valeur particulière
ALORS
REPETER
Traitement
Obtenir la valeur suivante
FIN SI
Par ailleurs, la version où le test de comparaison de valeur à
valeur particulière est effectuée deux fois ne doit pas être
utilisée.
REPETER
Obtenir valeur
SI valeur <> valeur particulière
ALORS
Traitement
FIN SI
JUSQU'A valeur = valeur particulière
Si le premier test (si) est oublié, la valeur particulière
subit le traitement.
La boucle Répéter est justifiée pour le traitement
d'une suite de valeurs, dans le cas où la condition du traitement
ne porte pas sur la valeur à traiter et lorsque le traitement est
effectué aumoins une fois. REPETER
obtenir la valeur courante
traitement
mise à jour de C
JUSQU'A C
ce qui équivaut à
Initialisation de Cbis à Vrai
TANT QUE Cbis faire
Obtenir la valeur courante
Traitement
Mise à jour de Cbis
FIN TANT QUE
avec Cbis = non C
*blindage
Tapez une valeur entre 0 et 20
Refusez si condition non remplies
REPETER
Ecrire ("Donner une valeure entre 0 et 20")
Lire (valeur)
JUSQU'A (valeur >= 0) et (valeur <= 20)
Cette écriture est plus économique que tant que car la demande
est faite en dehors de la boucle
Lors d'une relance, le message initial = message de relance
*menu
....
{Traitement des choix successifs}
REPETER
{affichage du menu et saisie de la réponse}
Ecrire ("1: charger")
Ecrire ("2: copier")
.....
Ecrire ("0: quitter")
{saisie du choix}
Ecrire ("Votre choix (0,1,2)")
Lire (rep)
{blindage}
TANT QUE (rep < 0) et (rep > 2).... FAIRE
Ecrire ("Tapez 0,1,2")
Lire (rep)
FIN TANT QUE
{traitement, utilisation d'une structure de choix}
choix selon rep
1:traitement_charger
2:traitement_copier
...
Fin Choix
JUSQU'A rep = 0
Thème : TURBO PASCAL
1) Structure générale
Une entête : Program NomProgr
Une partie déclaration : Constantes, types, variables, procédures...
Le corps du programme : begin, suite d'instructions séparées
par; et end
2) Structure d'une procédure
idem à l'exception de :
- déclaration dites locales
- la plupart du temps, on a que des variables
- Procedure NomProc (paramètres avec nature et type)
La liste des paramètres avec type suit les règles syntaxiques
des déclarations de variables, on utilise le mot VAR pour un passage
par adresse.
-> Passage de paramètres :
En Pascal, on dispose de deux modes de passages de paramètres, par
adresse ou par valeur.
Aucun signe particulier ne marque un passage par valeur. L'indication VAR
est utilisée lors d'un passage par adresse.
Sauf indications contraires, aux données (resp données modifiées
resp résultat) de l'algorithme correspondent en Pascal au passage
par valeur (resp adresse resp adresse).
Pour l'instant, nous appliquerons cette règle.
Exemple : program passagparam;
{illustration de la différence entre passage par valeur et passage
par adresse}
procedure P (var X:integer,Y:integer)
begin
writeln('X=',X,'Y=',Y);
X:=X+1;
Y:=Y+1;
writeln('X=',X,'Y=',Y);
end; {fin procedure}
var A,B:integer;
begin {début du programme principal}
A:=0;
B:=0;
writeln('A=',A,'B=',B);
P(A,B);
writeln('A=',A,'B=',B);
end.
L'exécution de ce programme donne l'affichage suivant :
A=0 B=0
X=0 Y=0
X=1 Y=1
A=1 B=0