Vous êtes sur la page 1sur 42

Support d’aide

LEGHLID Hamid
Table des matières
Introduction ........................................................................................... 3
L’ordinateur et le programmeur ......................................................... 4
Les déclarations ................................................................................... 5
Les Traitements ................................................................................. 10
Structures de contrôle ................................................................... 13
Structures de contrôle conditionnelles .................................... 13

Structures répétitives (les boucles) ......................................... 18

Les vecteurs ................................................................................... 21


Les matrices ................................................................................... 26
Les pointeurs .................................................................................. 33
Conclusion .......................................................................................... 42
Introduction

Cet ouvrage s’adresse aux apprenants qui ont des difficultés


dans le module d’algorithmique.

Pour ce faire, nous n’allons pas répéter les mêmes cours mais
nous essayerons de vulgariser le module comme si nous tentons
de diluer un liquide concentré.

Par suite, cet ouvrage se voit comme un support d’aide qui doit
être accompagné des cours que vous avez déjà suivis en
algorithmique à savoir la déclaration des variables mémoires, les
actions élémentaires, les vecteurs, les matrices et les pointeurs.

3
Homaloga@gmail.com
L’ordinateur et le programmeur

L’ordinateur
Il Sait effectuer des additions, des soustractions, etc… Et
faire des comparaisons (<, >, =). Il connait seulement quelques
mots comme :

VARIABLE, DEBUT, FIN, LIRE, ECRIRE, AFFECTER, SI,


ALORS, SINON, POUR, REPETER, …

Appelés MOTS CLES

Le programmeur
Est le maitre de l’ordinateur.

Il est capable d’ordonner l’ordinateur de lui faire n’importe quel


travail en utilisant seulement ces mots clés.

Exemple

Le programmeur sait bien que l’ordinateur ne connaît pas la


signification des mots RECTANGLE, LONGUEUR,
LARGEUR et SURFACE mais en utilisant juste les mots LIRE,
ECRIRE et AFFECTER, il peut l’ordonner de lui calculer la
surface de n’importe quel rectangle.

Nous dirons alors que le programmeur a programmé


l’ordinateur

4
Homaloga@gmail.com
Les déclarations

Rappel (module : architecture des ordinateurs)

La fonction principale de la mémoire centrale est la mémorisation


des programmes et des données en cours d’exécution

Vulgarisation

Pendant que vous écrivez vos algorithmes, Cette mémoire


centrale doit être vue comme étant un ensemble de boites postales
identifiées.

5
Homaloga@gmail.com
En algorithmique, on peut utiliser ces boites individuellement
ou bien sous forme de vecteur ou de matrice.

Les boites postales gardent des objets de type courrier, cependant


en algorithmique, ces boites gardent des objets de tout type
(entier, réel, booléen, caractère, …).

Dans une boite postale, on peut trouver plus d’un objet (lettres et
quittance par exemple), par contre en algorithmique, on ne peut
garder qu’un seul objet à la fois ; le nouvel objet écrasera
automatiquement l’ancien.

En algorithmique, les boites peuvent être organisées en vecteur


ou matrice ne gardant que le même type de données (vecteur de
réels, matrice d’entiers, …).
6
Homaloga@gmail.com
En algorithmique, ces boites sont en fait des variables
mémoires que vous déclarez.

Exemple

Var
a, b, c: integer;
Nom, adresse: string;
V: array [0...6] of integer

Qu’est ce qu’il faut déclarer ?

Pour chaque problème, un objectif

Chaque objectif nécessite l’introduction des données pour générer


un ou plusieurs résultats.
7
Homaloga@gmail.com
Pour générer ces résultats, lors du traitement, il peut y avoir des
résultats intermédiaires.

Il faut donc déclarer des variables mémoires pour :

- Introduire les données


- Garder les résultats intermédiaires
- Garder les résultats définitifs

Exemple

Ecrire un algorithme de calcul de périmètre de n’importe quel


rectangle.

-Pour l’introduction des données, on a besoin de deux variables


mémoires identifiées par exemple par LNG (pour la longueur) et
LRG (pour la largeur)

- Résultat intermédiaire : aucun

-Résultat définitif : on a un seul résultat qui est le périmètre qu’on


gardera dans une variable mémoire identifiée par exemple par
PER

Bien sûre, LNG, LRG et PER sont des nombres réels.

8
Homaloga@gmail.com
VAR

LNG, LRG, PER: Real;

9
Homaloga@gmail.com
Les Traitements

Pendant que vous écrivez votre algorithme, referez-vous au


rappel ci-dessus. Il faut que vous vous comportiez comme une
unité de traitement (CPU) et non comme un être humain.

De ce fait, tout se passe comme si vous ne connaissez aucune


langue à l’exception des mots clés suscités qui vous permettent de
manipuler les fameuses boites postales (c’est à dire les variables
mémoires)

10
Homaloga@gmail.com
L’image ci-dessus montre que l’on est, soit en train d’introduire
une donnée, soit en train de ranger un résultat.

Cette image montre que l’on est en train de ranger le résultat dans
la variable mémoire PER.

11
Homaloga@gmail.com
Cette image montre que l’on est en train d’introduire une donnée
qui représente la longueur dans la variable mémoire LNG

Pour introduire une donnée, on utilise soit l’affectation, soit le


mot clé LIRE.

Remarquez que sur l’image, on lit : Algorithme de calcul de


périmètre des rectangles avec ‘s’: cela signifie que l’algorithme
doit calculer le périmètre de n’importe quel rectangle ; autrement
dit , dans ce cas il faut utiliser le mot clé LIRE et non
l’affectation.

Par contre, pour ranger les résultats, il suffit d’utiliser


l’affectation

Cette image montre que l’on veut consulter sa boite postale.

En algorithmique, pour consulter sa variable mémoire, il suffit


d’utiliser le mot clé ECRIRE

12
Homaloga@gmail.com
Structures de contrôle

Structures de contrôle conditionnelles

Tout ce que vous écrivez entre SI et FINSI, par rapport à


l’algorithme lui-même est considérée comme une seule action

Exemple 1

Instruction 1
Instruction 2
Instruction 3
SI ….ALORS…….
…….
………
……….
FINSI
Instruction 5
Instruction 6
………

Par rapport à cet algorithme SI/FINSI est la 4ème instruction


quelque soit la taille du bloc.

Exemple 2

Ecrire un algorithme de résolution d’une équation du second


degré. ax2 +bx +c =0

13
Homaloga@gmail.com
VAR
a, b, c, X1, X2, Delta: Real;
DEBUT
LIRE (a, b, c) ;
Delta <- b*b -4*a*c ;
SI delta < 0 ALORS Ecrire (‘Pas de solutions’)
SINON
SI delta = 0 ALORS
Debut
X1<- -b /2*a ;
ECRIRE (‘solution Double’, X1)
Fin
SINON
Debut
X1<- (-b –sqrt(delta)/2*a);
X2<- (-b +sqrt(delta)/2*a);
Ecrire (‘ Deux solutions ‘, X1, X2)
Fin

FINSI

FINSI

FIN.

Cet algorithme est composé des 3 actions suivantes :

14
Homaloga@gmail.com
Evaluation de la condition

La condition est en fait une proposition ou une composition de


plusieurs propositions dont on peut discuter la vérité ou la
fausseté.

15
Homaloga@gmail.com
Exemple

« delta < 0 » est une proposition qui peut être vraie ou fausse
selon les valeurs de a, b et c.

Pour évaluer une proposition, il faut connaitre, au moins les


tables de vérité de la conjonction (ET) et de la disjonction (OU).

Exemple 1

…………
…………
SI (a<2) ET (b>=5) ALORS ………
SINON
……………..
…………….

SI (a<2) ET (b>=5) est VRAIE, les instructions qui suivent


ALORS seront exécutées SINON, c’est-à-dire SI

(a<2) ET (b>=5) est fausse alors ce sont les instructions qui


suivent SINON qui seront exécutées.

16
Homaloga@gmail.com
Déroulons pour a = 10 et b = 13

a b a<2 b>=5 (a<2) ET (b>=5)

10 13 FAUX VRAI FAUX

Exemple 2

Reprenons l’algorithme de résolution des équations du second


degré.

………

SI delta < 0 ALORS ……..


SINON ( c’est-à-dire delta < 0 est fausse donc delta >=0 )
SI delta = 0 ALORS ………
SINON (c’est à dire delta =0 est fausse donc delta > 0)
……………..
……………...

Déroulons pour a= 1, b=5 et c= 4

Delta = 5*5 - 4*1*4 =

= 25 – 16 = 9

Delta >0, par suite les instructions à exécuter sont celles qui
suivent le deuxième « SINON »

17
Homaloga@gmail.com
Structures répétitives (les boucles)

Les structures répétitives permettent d’exécuter la même action


ou bloc d’actions plusieurs fois et ce automatiquement jusqu’à ce
que la limite soit atteinte ou la condition soit VRAIE ou FAUSSE
selon le cas.

Les boucles utilisent souvent des variables mémoires qui jouent


le rôle de compteurs. Elles sont généralement identifiées par « i »,
« j » , « k », … pour des raisons de simplicité et de clarté.

Quand on connait combien de fois que l’exécution de l’action


ou du bloc d’actions sera répétée, on utilise souvent la boucle
POUR /FINPOUR

Exemple

Ecrire un algorithme qui affiche 10 astérisques (*)

Pour ce faire, on réserve une variable mémoire identifiée par « i »


qui va compter combien d’astérisques affichés.

VAR
i : entier ;
DEBUT
POUR i ALLANT DE 1 A 10 Faire
ECRIRE (‘*’)
FINPOUR
FIN.

La boucle POUR/FINPOUR utilise une variable mémoire


comme compteur qui s’incrémente automatiquement d’un PAS
que vous précisez lorsque ce dernier est différent de 1.

18
Homaloga@gmail.com
Lorsque le nombre de répétitions n’est pas connu au préalable, il
faut utiliser la boucle TANTQUE/FINTANT ou bien la boucle
REPETER/JUSQU’A.

Important

Quand vous utilisez les boucles TANTQUE/FINTANT et


REPETER/JUSQU’A, deux instructions importantes doivent être
insérées :
-Une instruction pour démarrer la boucle
-Une instruction pour assurer l’arrêt de la boucle

Exemple 1

Réécrivons l’algorithme ci-dessus en utilisant la boucle


TANTQUE/FINTANT

Var
i :Entier ;
DEBUT
i <- 1 ;
TANT QUE i < = 10 FAIRE
ECRIRE(‘*’) ;
i <- i+1
FINTANT
FIN.

Sans l’instruction « i <- 1 » on ne garantit pas le démarrage


de la boucle car on ne sait pas ce qui a été stocké dans la variable
mémoire « i ».

Sans l’instruction « i <- i+1 » la condition « i < = 10 » ne sera


jamais fausse pour arrêter la boucle, car rien ne fera augmenter

19
Homaloga@gmail.com
(incrémenter) le contenu de la variable mémoire « i » pour
atteindre 10.

Exemple 2

Réécrivons l’algorithme ci-dessus en utilisant la boucle


REPETER/JUSQU’A

Var
i :Entier ;
DEBUT
i <- 1 ;
REPETER
ECRIRE(‘*’) ;
i <- i+1
JUSQU’A i > 10
FIN.

Contrairement à la boucle TANTQUE /FINTANT, la boucle


REPETER/JUSQU’A démarre toujours mais l’arrêt est-il
garanti ?

Sans l’instruction « i <- i+1 » rien ne garantit l’arrêt de la


boucle.

Sans l’instruction «i <- 1 » ; l’instruction «i <- i+1 » n’a


aucun sens étant donné que le contenu de la variable mémoire
« i » n’est pas connu au préalable par suite l’arrêt de la boucle
n’est pas garanti.

20
Homaloga@gmail.com
Les vecteurs

Cette image nous montre vraiment que l’on ne peut pas écrire
LIRE(V) ou bien ECRIRE (V) ou bien V<- … car V est
composé de plusieurs boites ( ici 7 boites numérotées de 0 à 6).

0 ,..,6 sont appelés indices

Chaque boite du vecteur est appelée élément

Ces boites contiguës du vecteur V doivent obligatoirement


contenir le même type de données.

La manipulation des vecteurs utilise toujours d’autres variables


mémoires qui vont contenir l’indice de l’élément à traiter ou
assurer une certaine transition.

Exemple

Ecrire un algorithme qui lit un vecteur V de 7 entiers.

21
Homaloga@gmail.com
Le premier élément s’écrit V[0]
Le second élément s’écrit V[1]
……
Le septième élément s’écrit V[6]

Pour lire ce vecteur, c’est-à-dire introduire les données dans ce


vecteur, on a besoin d’une autre variable mémoire qu’on
identifiera « i » pour connaitre l’indice de l’élément concerné par
l’opération de lecture.

V[ i ] correspond à l’élément dans l’indice est stocké dans la


variable mémoire « i »

Si dans la variable mémoire « i » on a stocké 5, l’élément en


cours est V[5].

Remarquez alors, au lieu d’écrire :

LIRE V[0] ; LIRE V[1] ; LIRE V[2] ; LIRE V[3] ; LIRE V[4] ;
LIRE V[5] ; LIRE V[6] ;
On peut écrire une seule action LIRE V[ i ] dont l’exécution est
répétée grâce à la boucle POUR/FINPOUR puisqu’on connait la
limite.

22
Homaloga@gmail.com
Var
V :TABLEAU [0..6] De Entier ;
I :entier ;
DEBUT
Pour i ALLANT DE 0 A 6 FAIRE
LIRE (V[ i ] )
FINPOUR
FIN.

Voyons maintenant un cas où il faut utiliser une autre variable


mémoire pour assurer une certaine transition dans le traitement.

Exemple

Ecrire un algorithme qui permet trouver le plus grand élément du


vecteur V de 7 entiers.

Supposons que le vecteur V contient les entiers suivants :

Bien sûr, rien que par voir ce vecteur vous direz que l’élément le
plus grand du vecteur est V[3] c’est-à-dire 33.

Mais nous avons souligné ci-dessus que pendant que vous écrivez
vos algorithmes comportez-vous comme un CPU , donc vous
n’avez aucun organe de sens ( ni vision, ni odorat, ni ……)

23
Homaloga@gmail.com
Pour ce faire, on stocke alors le premier élément dans une
variable mémoire qu’on identifie par exemple « m » puis à partir
du second élément, on répétera l’exécution de l’instruction de
comparaison de l’élément encours avec le contenu de « m »

SI l’élément est plus grand que celui contenu dans « m » on le


remplacera par affectation (donc par écrasement car le nouveau
contenu écrase toujours l’ancien contenu).

L’algorithme sera alors :

VAR
V : TABLEAU [0..6] De Entier ;
i, m : entier,
Début
m<- V[0] ;
POUR i ALLANT de 1 A 6 FAIRE
SI V[ i ] > = m ALORS m<- V[ i ]
FINSI
FINPOUR
ECRIRE (m)
Fin.

Déroulons cet algorithme

m<- V[0] : signifie la variable mémoire « m » va mémoriser


le premier élément du vecteur ; c’est-à-dire le nombre entier 12

La boucle POUR se déclenche :

Dans « i » on garde 1 ,donc on compare V[1] au contenu de


«m» :
V[ 1] >= m ? c’est-à-dire Est-ce que 26 >= 12 ?

24
Homaloga@gmail.com
VRAI, donc on remplace le contenu du « m » par 26 et FINSI
passe la main à FINPOUR

FINPOUR réexecute l’action conditionnelle mais cette fois ci en


mettant dans « i » la valeur 2
V[ 2] >= m ? c’est-à-dire Est-ce que 2 >= 26 ? FAUX, donc
rien ne se passe et FINSI passe la main à FINPOUR

FINPOUR réexécute l’action conditionnelle mais cette fois ci


en mettant dans « i » la valeur 3
V[ 3] >= m ? c’est-à-dire Est-ce que 33 >= 26 ? VRAI, donc
on remplace le contenu de « m » par 33 et FINSI passe la main à
FINPOUR

FINPOUR réexecute l’action conditionnelle mais cette fois ci en


mettant dans « i » la valeur 4
V[ 4] >= m ? c’est-à-dire Est-ce que 5 >= 33? FAUX, donc
rien ne se passe et FINSI passe la main à FINPOUR

FINPOUR réexécute l’action conditionnelle mais cette fois ci


en mettant dans « i » la valeur 5
V[ 5] >= m ? c’est-à-dire Est-ce que 1 >= 33 ? FAUX, donc
rien ne se passe et FINSI passe la main à FINPOUR

FINPOUR réexécute l’action conditionnelle mais cette fois ci


en mettant dans « i » la valeur 6
V[ 6] >= m ? c’est-à-dire Est-ce que 18 >= 33? FAUX, donc
rien ne se passe et FINSI passe la main à FINPOUR

FINPOUR arrête la boucle car la limite est atteinte et passe la


main à l’instruction suivante qui est : ECRIRE (m) c’est-à-dire
afficher le contenu de « m » et passe la main à « FIN. » qui
arrête l’execution.

Le contenu de « m » est 33 . donc le plus grand élément du


vecteur est 33.

25
Homaloga@gmail.com
Les matrices

Remarquez que cette matrice se présente comme s’il s’agit de


deux vecteurs contigus ; c’est pour cela qu’il faut comprendre les
vecteurs avant de passer aux matrices.

Autrement dit, ce qui a été dit sur les vecteurs reste valable pour
les matrices ; seulement dans ce cas, on a besoin de deux indices ;
l’un pour les ligne et l’autre pour les colonnes.

Chaque élément est repéré par son numéro de ligne et son


numéro de colonne.

26
Homaloga@gmail.com
Exemple

L’élément de la première ligne et troisième colonne de la matrice


M est M[0,2]

Pour les matrices aussi, il faut utiliser des variables mémoires


identifiées par exemple par « i » et « j » pour contenir les
indices des éléments encours de traitement et celles qui gardent
les données de transition.

M[i, j] est l’élément qui se trouve à la ligne qui correspond au


nombre contenu dans la variable mémoire « i » et la colonne qui
correspond au nombre contenu dans la variable mémoire « j » ;
ainsi par exemple :

Si dans la variable mémoire « i » on a gardé le nombre 1 et dans


la variable mémoire « j » on a gardé le nombre 4 alors M[i, j]
est M[1, 4] c’est-à-dire c’est l’élément de la deuxième ligne et la
cinquième colonne de la matrice M.

Exemple

Ecrire un algorithme qui lit une matrice 2X5 (2 lignes et 5


colonnes) d’entiers.

LIRE (M[0 ,0]) ; LIRE (M[0 ,1]), LIRE (M[0 ,2]) ; LIRE
(M[0 ,3]) ; LIRE (M[0 ,4]) ; LIRE (M[0 ,5]) ; LIRE (M[1 ,0]) ;
LIRE (M[1 ,1]) ; LIRE (M[1,2]) ; LIRE (M[1,3]) ; LIRE
(M[1,4])
27
Homaloga@gmail.com
On peut écrire une seule action LIRE M[ i, j ] dont l’exécution est
répétée grâce à la boucle POUR/FINPOUR puisqu’on connait les
limites des lignes ( 0 à 1) et les colonnes (0 à 4)

Le remplissage d’une matrice utilise toujours deux boucles


imbriquées (l’une à l’intérieur de l’autre dont celle de
l’intérieur est pour les colonnes)

Var
M : TABLEAU [0..1 , 0..4] De Entier ;
i, j :Entier ;
DEBUT
POUR i ALLANT DE 0 A 1 FAIRE
POUR j ALLANT de 0 A 4 FAIRE
LIRE (M[i, j])
FINPOUR
FINPOUR
FIN.

Exemple 2

Ecrire un algorithme qui remplace tout élément de la matrice


M2X5 supérieur ou égale 5 par 0.

Supposons que M contient les éléments suivants :

28
Homaloga@gmail.com
En tant qu’être humain, rien que par voir la matrice, on aura le
résultat suivant :

Mais en tant que CPU, quelles instructions faut-il exécuter ?

Var
M : TABLEAU [0..1 , 0..4] De Entier ;
i, j ; Entier ;
DEBUT
POUR i ALLANT DE 0 A 1 FAIRE
POUR j ALLANT DE 0 A 4 FAIRE
SI M[i,j] >=5 ALORS M[i,j] <-0
FINSI
FINPOUR
FINPOUR
FIN.

Déroulons cet algorithme

La boucle « i » se déclenche :

La variable mémoire « i » va contenir 0 (donc la première ligne)

29
Homaloga@gmail.com
La boucle « j » se déclenche :

La variable mémoire « j » va contenir 0 ( donc la première


colonne).

La boucle « j » va répéter l’exécution de l’action


conditionnelle :

SI M[i,j] >=5 ALORS M[i,j] <-0


FINSI

M[i, j] = M[0, 0] = 12

M[0, 0] >=5 ?

VRAI , donc M[0, 0] sera remplacé par 0 et FINSI passe la


main à FINPOUR qui va répéter l’action conditionnelle en
incrémentant la variable mémoire « j » à 1

M[0,1] >=5 ?

FAUX, donc rien ne se passe et FINSI passe la main à


FINPOUR qui va répéter l’action conditionnelle en incrémentant
«j»à2

M[0,2] >=5 ?

FAUX, donc rien ne se passe et FINSI passe la main à


FINPOUR qui va répéter l’action conditionnelle en incrémentant
«j»à3

M[0,3] >=5 ?

VRAI , donc M[0, 3] sera remplacé par 0 et FINSI passe la


main à FINPOUR qui va répéter l’action conditionnelle en
incrémentant la variable mémoire « j » à 4

30
Homaloga@gmail.com
M[0,4] >=5 ?

FAUX, donc rien ne se passe et FINSI passe la main à FINPOUR


qui va arrêter la boucle car la limite est atteinte ; il passe alors la
main au FINPOUR suivant qui lui à son tour va répéter la
boucle « j » en incrémentant la variable mémoire « i » à 1 et
ainsi La boucle « j » se déclenche :

La variable mémoire « j » va contenir 0 ( donc la première


colonne).

La boucle « j » va répéter l’exécution de l’action


conditionnelle :

SI M[i,j] >=5 ALORS M[i,j] <-0


FINSI

M[i, j] = M[1, 0] = 1

M[1, 0] >=5 ?

FAUX , donc rien ne se passe et FINSI passe la main à


FINPOUR qui va répéter l’action conditionnelle en incrémentant
la variable mémoire « j » à 1

M[1,1] >=5 ?

VRAI , don le contenu de M[1, 1] sera remplacé par 0 et FINSI


passe la main à FINPOUR qui va répéter l’action conditionnelle
en incrémentant « j » à 2

M[1,2] >=5 ?

FAUX, donc rien ne se passe et FINSI passe la main à


FINPOUR qui va répéter l’action conditionnelle en incrémentant
«j»à3
31
Homaloga@gmail.com
M[1,3] >=5 ?

FAUX , donc rien ne se passe et FINSI passe la main à


FINPOUR qui va répéter l’action conditionnelle en incrémentant
la variable mémoire « j » à 4

M[1,4] >=5 ?

FAUX, donc rien ne se passe et FINSI passe la main à FINPOUR


qui va arrêter la boucle « j » car la limite est atteinte ; il passe
alors la main à FINPOUR qui lui aussi va arrêter la boucle « i »
car la limite est atteinte.

Le programme correspondant à cet algorithme va s’exécuter de


cette façon. C’est effectivement long ! Heureusement que les
ordinateurs sont très rapides.

32
Homaloga@gmail.com
Les pointeurs

Rappel (architecture des ordinateurs)


Structure physique de la mémoire centrale (MC)

Exemple de MC à mots mémoires de 4 bits

Les questions suivantes sont très intéressantes :

33
Homaloga@gmail.com
1-Si la largeur du bus d’adresse est 12 bits, de combien de mots
mémoires est composée la MC ? comment sont ils numérotés ? et
que représentent ces numéros ?

2-Si la largeur du bus de données est 4 bits, quelle est la taille


des mots mémoires de la MC ?

3-Déduire la capacité de cette MC.

Réponse

1-On peut adresser 2 largeur du bus , c’est-à-dire 212 mots mémoires ;


soit 4096 mots mémoires numérotés de 0 à 4095.

Ces numéros sont des adresses mémoires

2-Etant donné que le bus de données est sur 4 bits, la taille du


mot mémoire est donc de 4 bits.

3- La capacité de cette MC donnée en exemple est :

Taille du mot mémoire X nombre de mots mémoires

4 bits X 4096 = 16384 bits soit (16384 : 8 ) octets

Soit 2048 octets soit (2048 : 1024) Mo

Soit 2 Mo

34
Homaloga@gmail.com
Ce rappel de cours nous montre alors que les fameuses boites
postales, c’est-à-dire les variables mémoires que nous avons sus
citées sont en fait des mots mémoires dans la MC.

Mais dans la MC, chaque mots mémoire est identifié par son
adresse mémoire et non par les identifiants que nous déclarons.

Que se passe –t- il alors ?

C’est pendant la compilation du programme que le compilateur


construit une table de liens entre nos variables mémoires et les
adresses mémoires.

Exemple :

Programmation de l’algorithme de résolution de l’équation du


second degré présenté précédemment :

Ces adresses sont allouées par le système d’exploitation et elles


seront libérées à la fin de l’exécution du programme; c’est pour
cela que ces variables sont dites statiques.

35
Homaloga@gmail.com
Note : La prochaine exécution de ce programme se verra d’autres
adresses libres qui lui seront allouées.

Peut-on et comment utiliser des variables non statiques ?

Une variable non statique est dite dynamique. Son avantage est
que nous pouvons récupérer l’espace qu’elle occupe avant la fin
de l’exécution du programme.

Pour ce faire, il suffit juste de déclarer des variables qui vont


contenir les adresses mémoire où seront stockés nos données.

Ces variables sont appelées POINTEURS

Ces pointeurs sont en fait des variables statiques mais


particulières (car elles contiennent seulement des adresses
mémoires).

Comme toute variable statique, à chaque pointeur, il faut préciser


son type.

En algorithmique, pour déclarer un pointeur, on utilisera le


symbole « ^ ».

Exemple 1

Var

P : ^Entier ;

La variable dynamique pointée est P^.

36
Homaloga@gmail.com
Si le pointeur ne pointe vers aucune variable dynamique, on écrit
p<- NIL

Exemple 2

Ecrire un algorithme qui additionne deux entiers puis désalloue


l’espace mémoire occupé après affichage du résultat.

Ecrire le programme turbo pascal correspondant.

Var

P, Q : ^Entier
DEBUT
Allouer (P)
Allouer(Q)
LIRE(P^)
LIRE(Q^)
P^<- P^ + Q^
Ecrire (P^)
Désallouer(P)
Désallouer(Q)
FIN.

Remarquez que pour utiliser les pointeurs, il faut faire appel à des
programmes spéciaux (primitives) que le langage vous offre.
37
Homaloga@gmail.com
En algorithmique, on se limite simplement à Allouer ou
Désallouer le pointeur.

Programme TURBO PASCAL

Exemple d’exécution

38
Homaloga@gmail.com
Exemple3

Ecrire un algorithme puis un programme turbo pascal qui permet


de lire un vecteur dynamique de 5 caractères puis concaténer ces
caractères dans une variable statique, libérer l’espace alloué au
vecteur et afficher la chaine de caractères obtenue.

Dans ce cas, il faut absolument déclarer le type de vecteur et non


la variable.

TYPE
Vecteur = TABLEAU [0..4] De caractères
Var
P : ^vecteur
I : ^entier
Mot : Texte
DEBUT
Allouer (P)
Allouer(i)
Mot <- ‘’
POUR i ALLANT de 0 A 4 FAIRE
LIRE(P^[i] )
FINPOUR

POUR i ALLANT de 0 à 4 FAIRE


Mot <- Mot + P^[i]
FINPOUR
Désallouer (P)
Désallouer(i)
Ecrire (Mot)
FIN.

39
Homaloga@gmail.com
Programme Turbo Pascal

uses crt;
type
vecteur = ARRAY [0..4] of char;
Var
p :^vecteur;
i :^integer;
mot:string;
begin
new(p);
new(i);
mot :='';
i^:=0;
while i^ <= 4 do
begin
readln(p^ [i^]);
i^:= i^+1
end;

i^:= 0;
while i^ <=4 do
begin
mot := mot + p^[i^];
i^:= i^+1
end;
dispose(p);
dispose(i);
writeln (mot);
repeat until keypressed;
end.

40
Homaloga@gmail.com
Exemple d’exécution

41
Homaloga@gmail.com
Conclusion

C’est avec cette exécution que nous terminons notre livre en


ayant une ultime conviction que cela vous a aidé à surmonter
quelques difficultés en algorithmique, comprendre que les
modules enseignés sont en étroite relation et vous a apporté un
plus à votre base de connaissance.

Enfin nous souhaitons recevoir vos critiques qui nous seront


d’une grande aide quant à l’amélioration de cet ouvrage.

42
Homaloga@gmail.com

Vous aimerez peut-être aussi