Algorithme - Chapitre VII - Notion de Pointeurs Et Initiation Aux Listes

Institut Supérieur Privé de Technologies (IST) Année : 2016 – 2017
Technologie IP Classe : RIT 1ère Année
Chapitre VII - Notion de pointeurs et initiation aux

listes
I. Notion de pointeur
II. Allocation dynamique de mémoire
III. Tableaux et pointeurs
IV. Listes chaînées
I. Notion de procédure et de fonction
I.1 Notion de fonction

I.1.1 Les Fonctions Prédéfinies
I.1.1.1 Définition : fonction

Une fonction est un bloc d’instructions nommé et paramétré, réalisant une certaine tâche. Elle
admet zéro, un ou plusieurs paramètres et renvoie toujours un résultat.
Une fonction en informatique se distingue principalement de la fonction mathématique par le fait
qu’en plus de calculer un résultat à partir de paramètres, la fonction informatique peut avoir des «
effets de bord » : par exemple afficher un message à l’écran, jouer un son, ou bien piloter une
imprimante. Une fonction qui n’a pas d’effet de bord joue le rôle d’une expression évaluable. Une
fonction qui n’a que des effets de bord est appelée une procédure et joue le rôle d’une instruction.
C’est par exemple le cas du calcul du sinus d’un angle : pour en obtenir une valeur
approchée, il faudrait appliquer une formule d’une complexité à vous glacer le sang. Aussi,
que se passe-t-il sur les petites calculatrices que vous connaissez tous ? On vous fournit quelques
touches spéciales, dites touches de fonctions, qui vous permettent par exemple de connaître
immédiatement ce résultat. Sur votre calculatrice, si vous voulez connaître le sinus de 35°, vous
taperez 35, puis la touche SIN, et vous aurez le résultat.
Tout langage de programmation propose ainsi un certain nombre de fonctions ; certaines sont
indispensables, car elles permettent d’effectuer des traitements qui seraient sans elles impossibles.
D’autres servent à soulager le programmeur, en lui épargnant de longs - et pénibles - algorithmes.
Enseignant : ILBOUDO Ibrahim 1

Contacts : 70 69 18 19 - Mail : ibra_ilboudo@yahoo.fr
I.1.1.2 Structure générale des fonctions
Reprenons l’exemple du sinus. Les langages informatiques, qui se doivent tout de même de
savoir faire la même chose qu’une calculatrice à 19F90, proposent généralement une fonction SIN.
Si nous voulons stocker le sinus de 35 dans la variable A, nous écrirons : A ← Sin(35)
Une fonction est donc constituée de trois parties :

• le nom proprement dit de la fonction. Ce nom ne s’invente pas ! Il doit impérativement
correspondre à une fonction proposée par le langage. Dans notre exemple, ce nom est
SIN.
• deux parenthèses, une ouvrante, une fermante. Ces parenthèses sont toujours
obligatoires, même lorsqu'on n'écrit rien à l'intérieur.
• une liste de valeurs, indispensables à la bonne exécution de la fonction. Ces valeurs
s’appellent des arguments, ou des paramètres. Certaines fonctions exigent un seul
argument, d’autres deux, etc. et d’autres encore aucun. A noter que même dans le cas de
ces fonctions n’exigeant aucun argument, les parenthèses restent obligatoires. Le nombre
d’arguments nécessaire pour une fonction donnée ne s’invente pas : il est fixé par le
langage. Par exemple, la fonction sinus a besoin d’un argument (ce n’est pas surprenant,
cet argument est la valeur de l’angle). Si vous essayez de l’exécuter en lui donnant deux
arguments, ou aucun, cela déclenchera une erreur à l’exécution. Notez également que les
arguments doivent être d’un certain type, et qu’il faut respecter ces types.
I.1.1.3 Les fonctions de texte

Une catégorie privilégiée de fonctions est celle qui nous permet de manipuler des chaînes
de caractères. Nous avons déjà vu qu’on pouvait facilement « coller » deux chaînes l’une à
l’autre avec l’opérateur de concaténation &. Mais ce que nous ne pouvions pas faire, et qui va
être maintenant possible, c’est pratiquer des extractions de chaînes.
Tous les langages, je dis bien tous, proposent peu ou presque les fonctions suivantes, même si le
nom et la syntaxe peuvent varier d’un langage à l’autre :
• Len(chaîne) : renvoie le nombre de caractères d’une chaîne
• Mid(chaîne,n1,n2) : renvoie un extrait de la chaîne, commençant au caractère n1 et faisant
n2 caractères de long.
Ce sont les deux seules fonctions de chaînes réellement indispensables. Cependant, pour nous
épargner des algorithmes fastidieux, les langages proposent également :
• Left(chaîne,n) : renvoie les n caractères les plus à gauche dans chaîne.
• Right(chaîne,n) : renvoie les n caractères les plus à droite dans chaîne
• Trouve(chaîne1,chaîne2) : renvoie un nombre correspondant à la position de chaîne2
dans chaîne1. Si chaîne2 n’est pas comprise dans chaîne1, la fonction renvoie zéro.
Exemples :
Len("Bonjour, ça va ?") vaut 16
Len("") vaut 0
Mid("Zorro is back", 4, 7) vaut "ro is b"
Mid("Zorro is back", 12, 1) vaut "c"
Left("Et pourtant…", 8) vaut "Et pourt"
Right("Et pourtant…", 4) vaut "t…"
Trouve("Un pur bonheur", "pur") vaut 4
Trouve("Un pur bonheur", "techno") vaut 0
Il existe aussi dans tous les langages une fonction qui renvoie le caractère correspondant à un code
Ascii donné (fonction Asc), et (fonction Chr) :
Asc("N") vaut 78
Chr(63) vaut "?"
J’insiste ; à moins de programmer avec un langage un peu particulier, comme le C, qui traite
en réalité les chaînes de caractères comme des tableaux, on ne pourrait pas se passer des deux
fonctions Len et Mid pour traiter les chaînes. Or, si les programmes informatiques ont
fréquemment à traiter des nombres, ils doivent tout aussi fréquemment gérer des séries de
caractères (des chaînes). Je sais bien que cela devient un refrain, mais connaître les techniques de
base sur les chaînes est plus qu’utile : c’est indispensable.
I.1.1.4 Trois fonctions numériques classiques

Partie Entière
Une fonction extrêmement répandue est celle qui permet de récupérer la partie entière d’un
nombre :
Après : A ← Ent(3,228) A vaut 3
Cette fonction est notamment indispensable pour effectuer le célébrissime test de parité.
Modulo

Cette fonction permet de récupérer le reste de la division d’un nombre par un deuxième nombre.
Par exemple :
A ← Mod(10,3) A vaut 1 car 10 = 3*3 + 1
B ← Mod(12,2) B vaut 0 car 12 = 6*2
C ← Mod(44,8) C vaut 4 car 44 = 5*8 + 4
Cette fonction peut paraître un peu bizarre, est réservée aux seuls matheux.
Génération de nombres aléatoires

Une autre fonction classique, car très utile, est celle qui génère un nombre choisi au hasard.
Tous les programmes de jeu, ou presque, ont besoin de ce type d’outils, qu’il s’agisse de simuler
un lancer de dés ou le choix d’un caractère au hasard.
Mais il n’y a pas que les jeux qui ont besoin de générer des nombres aléatoires. La modélisation
(physique, géographique, économique, etc.) a parfois recours à des modèles dits stochastiques. Ce
sont des modèles dans lesquels les variables se déduisent les unes des autres par des relations
déterministes (autrement dit des calculs), mais où l’on simule la part d’incertitude par une «
fourchette » de hasard.
I.1.2 Fonctions personnalisées
I.1.2.1 De quoi s'agit-il ?

Une application, surtout si elle est longue, a toutes les chances de devoir procéder aux mêmes
traitements, ou à des traitements similaires, à plusieurs endroits de son déroulement. Par exemple,
la saisie d’une réponse par oui ou par non (et le contrôle qu’elle implique), peuvent être
répétés dix fois à des moments différents de la même application, pour dix questions différentes.
La manière la plus évidente, mais aussi la moins habile, de programmer ce genre de choses, c'est
bien entendu de répéter le code correspondant autant de fois que nécessaire. Apparemment, on ne
se casse pas la tête : quand il faut que la machine interroge l'utilisateur, on recopie les lignes de
codes voulues en ne changeant que le nécessaire. Mais en procédant de cette manière, la pire qui
soit, on se prépare des lendemains qui déchantent...
D'abord, parce que si la structure d'un programme écrit de cette manière peut paraître simple, elle
est en réalité inutilement lourdingue. Elle contient des répétitions, et pour peu que le programme
soit joufflu, il peut devenir parfaitement illisible. Or, le fait d'être facilement modifiable donc
lisible, y compris - et surtout - par ceux qui ne l'ont pas écrit est un critère essentiel pour un
programme informatique ! Dès que l'on programme non pour soi-même, mais dans le cadre
d'une organisation (entreprise ou autre), cette nécessité se fait sentir de manière aiguë. L'ignorer,
c'est donc forcément grave.
En plus, à un autre niveau, une telle structure pose des problèmes considérables de maintenance :
car en cas de modification du code, il va falloir traquer toutes les apparitions plus ou moins
identiques de ce code pour faire convenablement la modification !
Il faut donc opter pour une autre stratégie, qui consiste à séparer ce traitement du corps du
programme et à regrouper les instructions qui le composent en un module séparé. Il ne restera
alors plus qu'à appeler ce groupe d'instructions (qui n'existe donc désormais qu’en un exemplaire
unique) à chaque fois qu’on en a besoin. Ainsi, la lisibilité est assurée ; le programme devient
modulaire, et il suffit de faire une seule modification au bon endroit, pour que cette
modification prenne effet dans la totalité de l’application.
Le corps du programme s’appelle alors la procédure principale, et ces groupes d’instructions

auxquels on a recours s’appellent des fonctions et des sous-procédures (nous verrons un peu
plus loin la différence entre ces deux termes).
Reprenons un exemple de question à laquelle l’utilisateur doit répondre par oui ou par non.
Mauvaise Structure :
...
Ecrire "Etes-vous marié ?"
Rep1 ← ""
TantQue Rep1 <> "Oui" et Rep1 <> "Non"
Ecrire "Tapez Oui ou Non"
Lire Rep1
FinTantQue
...
Ecrire "Avez-vous des enfants ?"
Rep2 ← ""
TantQue Rep2 <> "Oui" et Rep2 <> "Non"

Lire Rep2
FinTantQue
...
On le voit bien, il y a là une répétition quasi identique du traitement à accomplir. A chaque

fois, on demande une réponse par Oui ou Non, avec contrôle de saisie. La seule chose qui change,
c'est le nom de la variable dans laquelle on range la réponse. Alors, il doit bien y avoir un truc.
La solution, on vient de le voir, consiste à isoler les instructions demandant une réponse par Oui
ou Non, et à appeler ces instructions à chaque fois que nécessaire. Ainsi, on évite les
répétitions inutiles, et on a découpé notre problème en petits morceaux autonomes.
I.2 Notion de procédure

Les fonctions, c'est bien, mais dans certains cas, ça ne nous rend guère service.
Il peut en effet arriver que dans un programme, on ait à réaliser des tâches répétitives, mais que ces
tâches n'aient pas pour rôle de générer une valeur particulière, ou qu'elles aient pour rôle d'en
générer plus d'une à la fois. Prenons deux exemples.
Premier exemple. Imaginons qu'au cours de mon application, j'aie plusieurs fois besoin d'effacer
l'écran et de réafficher un bidule comme un petit logo en haut à gauche. On pourrait se dire qu'il
faut créer une fonction pour faire cela. Mais quelle serait la valeur renvoyée par la fonction ?
Aucune ! Effacer l'écran, ce n'est pas produire un résultat stockable dans une variable, et afficher
un logo non plus. Voilà donc une situation où j'ai besoin de répéter du code, mais où ce code n'a
pas comme rôle de produire une valeur.
Deuxième exemple. Au cours de mon application, je dois plusieurs fois faire saisir un tableau
d'entiers (mais à chaque fois, un tableau différent). Là encore, on serait tenté d'effectuer toutes ces
saisies de tableaux dans une seule fonction. Mais problème, une fonction ne peut renvoyer qu'une
seule valeur à la fois. Elle ne peut donc renvoyer un tableau, qui est une série de valeurs distinctes.
Alors, dans ces deux cas, faute de pouvoir traiter l'affaire par une fonction, devra-t-on en rester au
code répétitif dont nous venons de dénoncer si vigoureusement les faiblesses ? Vous vous doutez
bien que non. Heureusement, tout est prévu, il y a une solution. Et celle-ci consiste à utiliser des
procédures.

En fait, les fonctions - que nous avons vues - ne sont finalement qu'un cas particulier des
procédures - que nous allons voir : celui où doit être renvoyé vers la procédure appelante
une valeur et une seule. Dans tous les autres cas (celui où on ne renvoie aucune valeur, comme
celui ou en en renvoie plusieurs), il faut donc avoir recours non à la forme particulière et
simplifiée (la fonction), mais à la forme générale (la sous- procédure).
Parlons donc de ce qui est commun aux procédures et aux fonctions, mais aussi de ce qui les
différencie. Voici comment se présente une procédure :
Procédure Bidule( ... )

...
Fin Procédure
Dans la procédure principale, l’appel à la procédure Bidule devient quant à lui :

Appeler Bidule(...)
Établissons un premier état des lieux.

• Alors qu'une fonction se caractérisait par les mots-clés Fonction ... Fin Fonction, une
sous-procédure est identifiée par les mots-clés Procédure... Fin Procédure.
• Lorsqu'une fonction était appelée, sa valeur (retournée) était toujours affectée à une
variable (ou intégrée dans le calcul d'une expression). L'appel à une procédure, lui, est au
contraire toujours une instruction autonome. "Exécute la procédure Bidule" est un ordre
qui se suffit à lui-même.
• Toute fonction devait, pour cette raison, comporter l'instruction "Renvoyer".
Pour la même raison, l'instruction "Renvoyer" n'est jamais utilisée dans une
procédure. La fonction est une valeur calculée, qui renvoie son résultat vers la procédure
principale. La procédure, elle, est un traitement ; elle ne "vaut" rien.
II. Définition et appel d’une procédure ou d’une fonction :

paramètres formels et paramètres effectifs, mécanismes de
passage des paramètres
I.3 Définition d’une fonction

Comme de nombreuses entités en informatique, une fonction doit être définie avant d’être utilisée,
c’est-à-dire que l’on doit indiquer quelles sont les instructions qui la composent : il s’agit de la
définition de la fonction, où l’on associe les instructions à l’identification de la fonction.
On doit donc trouver une définition de la fonction, qui comporte :
• Une identification ou en-tête de la fonction, suivie des instructions de la fonction, ou corps de la
fonction.
La fonction doit être définie et comporter : un en-tête, pour l’identifier et un corps contenant ses
instructions, pour la définir.
Comment écrire une définition de fonction
I.1.3 En-tête
L’en-tête d’une fonction contient les informations nécessaires pour identifier la fonction : son nom,
ses entrées et leur type, le type de sa sortie (sans la nommer, car c’est inutile).
Syntaxe de l’en-tête
FONCTION nom(liste entrées avec leurs types ): type de la sortie
La liste des entrées avec leur type suit exactement la même syntaxe que les définitions de variables,
et ceci n’est pas un simple hasard, car les entrées sont des variables de la fonction.
La seule différence réside dans le fait que si plusieurs entrées ont le même type, on ne peut pas les
écrire comme on le ferait pour une définition multiple de plusieurs variables du même type. Il faut
rappeler le type de l’entrée pour chacune des entrées.
La sortie ne nécessite pas d’être nommée, car c’est à la fonction ou au programme appelant la
fonction de récupérer cette valeur. Le rôle de la fonction se limite uniquement, dans le cas de la
sortie, à pouvoir fournir une valeur numérique, seul son type est donc important.
I.1.4 Corps
Le corps de la fonction est constitué des instructions de la fonction, et est placé directement à la
suite de l’en-tête de la fonction, entre les mots DEBUT et FIN.
Dans le corps de la fonction, outre les instructions, on peut également trouver des définitions de
variables qui peuvent être utiles pour faire des calculs intermédiaires lorsque l’on utilise la fonction.
Les définitions des variables se trouvent avant le mot DEBUT.
I.1.5 L’instruction de retour

Pour traiter intégralement les fonctions, nous avons besoin d’une nouvelle instruction permettant
que la fonction communique sa sortie à la fonction qui l’utilise. La sortie d’une fonction (il y en a
au maximum une) est en fait une valeur numérique que celle-ci fournit, et la seule information
nécessaire à la bonne interprétation de cette valeur numérique est son type : c’est pourquoi on ne

précise que le type de cette sortie, il est inutile de lui associer un nom. Il nous faudrait donc une
instruction dont l’effet serait : « répondre à la fonction appelante la valeur qu’elle demande ».
Cette instruction existe, son nom est RETOURNER.
Exemple
Syntaxe : RETOURNER expression
Effet : transmet la valeur de l’expression et met fin à l’exécution de la fonction.
Toute instruction placée après l’instruction RETOURNER est purement et simplement ignorée, ce
qui fait que cette instruction s’emploie forcément comme dernière instruction d’une fonction.
La seule contrainte à respecter est que le type de l’expression soit le même que celui de la sortie, qui
est indiqué dans l’en-tête de la fonction.
Lorsqu’une fonction ne possède pas de sortie, il n’est pas indispensable d’utiliser l’instruction
retourner, à part pour indiquer que la fonction se termine, ce qui peut aussi être repéré par le mot
FIN de la fonction.
I.4 Appel des fonctions

L’appel d’une fonction correspond à une demande de son utilisation, ceci est fait dans une autre
fonction, dont par exemple le programme principal. Afin d’appeler une fonction, on doit préciser :
son nom, ainsi que les valeurs que l’on fournit pour les entrées. On ne précise pas la valeur de la
sortie, car c’est la fonction appelée qui est en charge de la fournir !
La fonction (ou programme principal) qui appelle (ou utilise) une fonction est dite : fonction
appelante; la fonction qui est utilisée est dite fonction appelée.
Exemple
Soit une fonction nommée fonc, et possédant une liste d’entrées : type1 entree1, type2
entree2,... ,typen entreen. Son en-tête est donc : FONCTION fonc(entree1 : type1, entree2 :
type2,..., entreen : typen): type_sortie)
Pour appeler cette fonction, la syntaxe est la suivante : fonc(expr1, expr2,...,exprn) où fonc est le
nom de la fonction, et expri, où i est compris entre 1 et n, est une expression dont le type est celui
de l’entrée i.
Gestion des entrées : les arguments
Lors de l’appel de la fonction, une expression donnant une valeur à une entrée de la fonction est
appelée argument de la fonction.
Retenez bien qu’un argument n’est pas forcément une variable, mais peut être une expression.
Dans tous ces cas, l’ordinateur réalise les deux étapes suivantes :
 Calcul de la valeur de l’expression pour chacun des arguments.
 Transmission de cette valeur à l’entrée de la fonction correspondante pour que la fonction
s’exécute avec les valeurs transmises.
Gestion de la valeur de sortie de la fonction : affectation
Lorsqu’une fonction est appelée de cette manière, la valeur de la sortie retournée par la fonction
appelée est obtenue ainsi : la valeur numérique de l’expression suivant l’instruction RETOURNER
est calculée puis transmise à la fonction appelante. Au sein de cette fonction appelante, l’écriture
nom_de_fonction(liste_des_arguments) est en réalité une expression dont le type est celui de la
sortie de la fonction, qui est précisé dans l’en-tête de cette dernière. Il s’agit donc d’une valeur
numérique que l’on doit affecter à une variable si on veut la conserver.
Lorsque vous voulez conserver le résultat retourné par une fonction appelée, il faut affecter ce
résultat (obtenu par un appel) dans une variable du même type que celui de la sortie de la fonction
appelée.
I.5 Passage d'arguments

Reprenons l’exemple qui précède et analysons-le. On écrit un message à l'écran, puis on appelle
la fonction RepOuiNon pour poser une question ; puis, un peu plus loin, on écrit un autre message
à l'écran, et on appelle de nouveau la fonction pour poser la même question, etc. C’est une
démarche acceptable, mais qui peut encore être améliorée : puisqu’avant chaque question, on
doit écrire un message, autant que cette écriture du message figure directement dans la fonction
appelée. Cela implique deux choses :
• lorsqu’on appelle la fonction, on doit lui préciser quel message elle doit afficher avant
de lire la réponse
• la fonction doit être « prévenue » qu’elle recevra un message, et être capable de le
récupérer pour l’afficher.
En langage algorithmique, on dira que le message devient un argument (ou un paramètre) de
la fonction. Cela n'est certes pas une découverte pour vous : nous avons longuement utilisé les
arguments à propos des fonctions prédéfinies. Eh bien, quitte à construire nos propres fonctions,
nous pouvons donc construire nos propres arguments. Voilà comment l’affaire se présente...
La fonction sera dorénavant déclarée comme suit :

Fonction RepOuiNon(Msg en Caractère) : Caractère
Ecrire Msg
Truc ← ""
TantQue Truc <> "Oui" et Truc <> "Non"
Lire Truc
FinTantQue
Renvoyer Truc
Fin Fonction
Il y a donc maintenant entre les parenthèses une variable, Msg, dont on précise le type, et qui
signale à la fonction qu’un argument doit lui être envoyé à chaque appel. Quant à ces appels,
justement, ils se simplifieront encore dans la procédure principale, pour devenir :
...
Rep1 ← RepOuiNon("Etes-vous marié ?")
...
Rep2 ← RepOuiNon("Avez-vous des enfants ?")
...
Et voilà le travail.
Une remarque importante : là, on n'a passé qu’un seul argument en entrée. Mais bien entendu, on
peut en passer autant qu’on veut, et créer des fonctions avec deux, trois, quatre, etc. arguments ;
Simplement, il faut éviter d'être gourmands, et il suffit de passer ce dont on en a besoin, ni plus,
ni moins !
Dans le cas que l'on vient de voir, le passage d'un argument à la fonction était élégant, mais pas
indispensable. La preuve, cela marchait déjà très bien avec la première version. Mais on peut
imaginer des situations où il faut absolument concevoir la fonction de sorte qu'on doive lui
transmettre un certain nombre d'arguments si l'on veut qu'elle puisse remplir sa tâche. Prenons, par
exemple, toutes les fonctions qui vont effectuer des calculs. Que ceux-ci soient simples ou
compliqués, il va bien falloir envoyer à la fonction les valeurs grâce auxquelles elle sera censé
produire son résultat (pensez à une fonction sur le modèle d'Excel, telle que celle qui doit calculer
une somme ou une moyenne). C'est également vrai des fonctions qui traiteront des chaînes de
caractères. Bref, dans 99% des cas, lorsqu'on créera une fonction, celle-ci devra comporter des
arguments.
I.6 Le passage des paramètres

Nous allons étudier, dans cette partie, le mécanisme de passage des paramètres, qui est un point
fondamental concernant les fonctions. Nous allons voir en détail la manière dont se fait la
communication entre les arguments fournis par la fonction appelante et les paramètres (ou entrées)
reçus par la fonction appelée. Ce passage de paramètre est effectué à chaque appel d’une fonction.
Le mécanisme de recopie
Les actions effectuées par l’ordinateur lors du passage des paramètres (transmission de la valeur des
arguments au moment d’un appel de fonction) sont les suivantes :
• Les valeurs des arguments sont calculées (ou évaluées) ;
• Ces valeurs sont recopiées dans les paramètres correspondants de la fonction : l’ordre de
recopie est celui dans lequel les entrées ou paramètres de la fonction sont écrits dans l’en-
tête de la fonction : l’argument 1 dans le paramètre 1, et ainsi de suite ;
• La fonction est exécutée et réalise ses calculs et instructions ;
• L’instruction RETOURNER est exécutée : l’expression contrôlée par cette instruction est
évaluée et retournée au surprogramme qui a appelé cette fonction en tant que sous-
programme.
Intégrité des variables locales
Les variables locales à un programme ou à une fonction ne peuvent pas être modifiées par une autre
fonction lorsque l’on applique ce mécanisme pour des paramètres de type simple (entier, caractère
ou réel). En effet, il ne faut pas confondre les arguments d’une fonction appelée et les variables du
programme qui appelle cette fonction. Un argument n’est pas nécessairement une variable, et même
si c’est le cas, c’est la valeur de l’argument qui est transmis à la fonction et non la variable elle-
même. On peut donc en conclure qu’une variable utilisée comme argument d’un appel de fonction
ne sera pas modifiée par l’appel, car c’est simplement sa valeur qui est recopiée.
I.7 Les fonctions et les tableaux

Syntaxe utilisée pour les entrées de type ’tableau’
Un tableau est une adresse, et c’est donc une adresse qui sera transmise par le biais d’une entrée
d’un tel type. Il n’est pas possible de transmettre, avec un seul paramètre, d’autres informations que
l’adresse, c’est-à-dire la taille utile ou même la taille maximum du tableau. Pour transmettre l’une
de ces informations, il faudra utiliser un paramètre supplémentaire. Ainsi, un paramètre de type
tableau sera défini comme un tableau contenant un certain type de valeurs, mais sans fournir ni la
taille maximum, ni la taille utile.
Exemple
Une entrée de type tableau sera fournie de la manière suivante : nom_entree :
type_des_valeurs_stockées[]
Les crochets ne contiennent aucune valeur, ils sont juste présents pour indiquer que le type de
l’entrée est un tableau contenant des valeurs d’un certain type.

Lorsque l’on voudra traiter les valeurs stockées dans ce tableau, il faudra par contre avoir une
information concernant la taille utile de ce tableau : il faudra donc associer systématiquement cette
entrée à une entrée de type tableau.
N’oubliez pas que, même si la taille utile est définie dans le programme principal ou dans une autre
fonction que celle qui traite le tableau, cette taille utile sera stockée dans une variable à laquelle la
fonction ne pourra pas accéder ! Il faudra donc la lui transmettre.
Appel d’une fonction avec un argument de type tableau
Lorsqu’un tableau est utilisé comme un argument, il est inutile d’utiliser la notation avec les
crochets. En effet, ces crochets sont utilisés pour définir le tableau, ou pour accéder à un élément
particulier stocké dans le tableau. Le tableau lui-même (c’est-à-dire l’adresse à laquelle sont
stockées les valeurs), est repéré par son nom, sans les crochets.
Exemple
Soit la définition suivante : tab_car : caractere[20] cela indique que tab_car est un tableau contenant
au plus 20 caractères. Donc tab_car est de type : tableau de caractere, ou encore pointeur vers des
caractères. tab_car est une adresse.
Lorsque l’on veut fournir à une fonction un argument qui est un tableau, on doit lui fournir une
adresse.
III. Portée des variables (locale, globale)
Nous venons de voir que nous pouvions découper un long traitement comportant éventuellement
des redondances (notre application) en différents modules. Et nous avons vu que les informations
pouvaient être transmises entre ces modules selon deux modes :
• si le module appelé est une fonction, par le retour du résultat
• dans tous les cas, par la transmission de paramètres (que ces paramètres soient passés par
valeur ou par référence)
En fait, il existe un troisième et dernier moyen d'échanger des informations entre différentes
procédures et fonctions : c'est de ne pas avoir besoin de les échanger, en faisant en sorte que ces
procédures et fonctions partagent littéralement les mêmes variables. Cela suppose d'avoir recours
à des variables particulières, lisibles et utilisables par n'importe quelle procédure ou fonction de
l'application.
I.8 Variable locale
Ces variables, définies à l’intérieur de la fonction, sont des variables dites locales, car elles ne sont
connues que par la fonction. C’est logique, car c’est la fonction qui les définit (en quelque sorte)

pour son usage propre. Une autre fonction ou un programme extérieur ne connaissent pas
l’existence de ces variables, et donc à plus forte raison ne connaissent ni leur nom, ni leur type, ni
leur valeur, ni leur adresse. Elles ne peuvent les utiliser.
Les entrées de la fonction, précisées dans l’en-tête, sont également considérées comme des
variables locales de la fonction : c’est pour cela que la syntaxe d’écriture des entrées est si proche
de la syntaxe d’une définition de variable.
Enfin, les définitions des variables locales à la fonction suivent exactement les mêmes règles que
celles que nous avons déjà rencontrées pour les définitions de variables d’un programme.
Par défaut, une variable est déclarée au sein d'une procédure ou d'une fonction. Elle est donc créée
avec cette procédure, et disparaît avec elle. Durant tout le temps de son existence, une telle
variable n'est visible que par la procédure qui l'a vu naître. Si je crée une variable Toto dans
une procédure Bidule, et qu'en cours de route, ma procédure Bidule appelle une sous-procédure
Machin, il est hors de question que Machin puisse accéder à Toto, ne serait-ce que pour connaître
sa valeur (et ne parlons pas de la modifier). Voilà pourquoi ces variables par défaut sont dites
privées, ou locales.
I.9 Variable globale

Mais à côté de cela, il est possible de créer des variables qui certes, seront déclarées dans une
procédure, mais qui du moment où elles existeront, seront des variables communes à toutes
les procédures et fonctions de l'application. Avec de telles variables, le problème de la
transmission des valeurs d'une procédure (ou d'une fonction) à l'autre ne se pose même plus : la
variable Truc, existant pour toute l'application, est accessible et modifiable depuis n'importe quelle
ligne de code de cette application. Plus besoin donc de la transmettre ou de la renvoyer. Une
telle variable est alors dite publique, ou globale.
La manière dont la déclaration d'une variable publique doit être faites est évidemment fonction de
chaque langage de programmation. En pseudo-code algorithmique, on pourra utiliser le mot-clé
Publique : Variable Publique Toto : Numérique
Alors, pourquoi ne pas rendre toutes les variables publiques, et s'épargner ainsi de fastidieux efforts
pour passer des paramètres ? C’est très simple, et c'est toujours la même chose : les variables
globales consomment énormément de ressources en mémoire. En conséquence, le principe qui
doit présider au choix entre variables publiques et privées doit être celui de l’économie de moyens :
on ne déclare comme publiques que les variables qui doivent absolument l’être. Et chaque fois

que possible, lorsqu’on crée une sous-procédure, on utilise le passage de paramètres plutôt que
des variables publiques.
IV. Introduction à la récursivité

Définition
Moyen simple et élégant de résoudre certain problème.
Définition
On appelle récursive toute fonction ou procédure qui s’appelle elle-même.
Algorithme Fact
Entrée : un entier positif N
Sortie : factorielle de N
si N = 0 retourner 1
sinon retourner N x Fact(N-1)
Concept de récursivité
La récursivité est la propriété que possède un objet ou un concept de s'exprimer \en fonction de lui-
même" ;
En algorithmique et en programmation, on dit qu'une fonction est récursive si elle s'appelle elle-
même ;
Exemple (fonction récursive)
Def f(x):
a = f(2*x-17)
return (5*a+18)
Le compilateur (ou l'interpréteur) doit donc « comprendre » que l'appel à f fait partie de la
définition de cette fonction ;
Il s'agit d'un concept important en algorithmique :
 Pour écrire des algorithmes,
 Mais également pour d’écrire ou définir des structures de données ;
Cette technique rend l'écriture de code plus facile ;
Elle a son lot d'avantages, mais également d'inconvénients (voir plus loin) ;
Forme générale d'une fonction récursive

Une fonction est récursive si son exécution peut conduire à sa propre invocation ;
Une telle fonction se présente donc comme suit :

Fonction récursive
deff(P): # P = liste de paramètres
# instructions (1)
x=f(Q) # appel avec d'autres paramètres
# instructions (2)
Returnresultat
Remarque : le renvoi n'est pas obligatoire ;


Algorithme - Chapitre VII - Notion de Pointeurs Et Initiation Aux Listes

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algorithme - Chapitre VII - Notion de Pointeurs Et Initiation Aux Listes

Transféré par

Droits d'auteur :

Formats disponibles

Institut Supérieur Privé de Technologies (IST) Année : 2016 – 2017

Technologie IP Classe : RIT 1ère Année

Chapitre VII - Notion de pointeurs et initiation aux

I. Notion de procédure et de fonction

I.1 Notion de fonction

I.1.1.1 Déﬁnition : fonction

Enseignant : ILBOUDO Ibrahim 1

Une fonction est donc constituée de trois parties :

I.1.1.3 Les fonctions de texte

I.1.1.4 Trois fonctions numériques classiques

Enseignant : ILBOUDO Ibrahim 3

Génération de nombres aléatoires

I.1.2 Fonctions personnalisées

I.1.2.1 De quoi s'agit-il ?

Le corps du programme s’appelle alors la procédure principale, et ces groupes d’instructions

Enseignant : ILBOUDO Ibrahim 5

On le voit bien, il y a là une répétition quasi identique du traitement à accomplir. A chaque

I.2 Notion de procédure

Enseignant : ILBOUDO Ibrahim 6

Procédure Bidule( ... )

Dans la procédure principale, l’appel à la procédure Bidule devient quant à lui :

Établissons un premier état des lieux.

II. Définition et appel d’une procédure ou d’une fonction :

Enseignant : ILBOUDO Ibrahim 7

I.1.5 L’instruction de retour

Enseignant : ILBOUDO Ibrahim 8

I.4 Appel des fonctions

I.5 Passage d'arguments

La fonction sera dorénavant déclarée comme suit :

I.6 Le passage des paramètres

I.7 Les fonctions et les tableaux

Enseignant : ILBOUDO Ibrahim 12

III. Portée des variables (locale, globale)

I.8 Variable locale

Enseignant : ILBOUDO Ibrahim 13

I.9 Variable globale

Enseignant : ILBOUDO Ibrahim 14

IV. Introduction à la récursivité

Forme générale d'une fonction récursive

Enseignant : ILBOUDO Ibrahim 15

Enseignant : ILBOUDO Ibrahim 16

Vous aimerez peut-être aussi