Cours - Matière 3987 - 83987TGPA0007

BTS Informatique de gestion 2e anne
Option administrateur de rseaux locaux dentreprise

Jean-Yves Fvrier
Algorithmique et langages
Cours
Directrice de publication : Valrie Brard-Trigo

Les cours du Cned sont strictement rservs lusage priv de leurs destinataires et ne sont pas destins une utilisation collective. Les personnes
qui sen serviraient pour dautres usages, qui en feraient une reproduction intgrale ou partielle, une traduction sans le consentement du Cned,
sexposeraient des poursuites judiciaires et aux sanctions pnales prvues par le Code de la proprit intellectuelle. Les reproductions par
reprographie de livres et de priodiques protgs contenues dans cet ouvrage sont effectues par le Cned avec lautorisation du Centre
franais dexploitation du droit de copie (20, rue des Grands Augustins, 75006 Paris).
Conseils gnraux
Ce cours est constitu de 3 squences et 3 TD. Il est accompagn dun fascicule
dautocorrection. Pour lvaluation note vous avez un fascicule de 2 devoirs
envoyer la correction.
Voici lordre dans lequel il faut exploiter tout cela :

vous faites les squences 1 2 ;
pour valider vos connaissances, vous envoyez le devoir 1 la correction ;
vous faites la squence 3 ;
ensuite, vous faites le TD 1 ;
pour valider vos connaissances, vous envoyez le devoir 2 la correction ;
ensuite, vous faites le TD 2 ;
ensuite, vous faites le TD 3.
Pour votre option, la programmation est un petit cours. Ne le bclez pas en une semaine ds
octobre, mais tudiez-le de temps en temps pour bien assimiler les concepts tout au long de lanne. Dans le meilleur des cas, vous devriez commencer la squence 1 aprs avoir reu les cours
et envoyer le devoir 2 la correction en fin danne scolaire (cest--dire, pour vous, en mars). Je
vous conseille :
de travailler en un mois ou deux le cours (il nest pas trs long) ;
de passer ensuite beaucoup de temps sur les TD qui, eux, sont longs, et den faire un exercice
de temps en temps pour garder le contact avec la programmation tout au long de lanne.
La place de la programmation
Dans le rfrentiel
Le cours que vous tes en train de lire concerne la programmation en 2e anne de BTS, option
administrateur de rseaux locaux dentreprise.
Cest un cours essentiel pour votre carrire dinformaticien. Certes, vous ne serez normalement pas
amen dvelopper des programmes comme vos collgues de lautre option. Cela dit, la dmarche algorithmique sera toujours prsente dans votre mtier. Lexemple le plus classique, ce sont
les scripts (shells) qui vous permettront dautomatiser considrablement votre travail... si vous tes
capable de les crire. Pour cela, la matrise des boucles et des tests est indispensable.
Dans le rfrentiel de la formation, ce cours est inclus dans le savoir S3 DAIGL (dveloppement
dapplications informatiques et gnie logiciel) avec lanalyse. Plus prcisment, nous traiterons
ici le savoir S35 du rfrentiel intitul conception et dveloppement dapplications laide dun
langage de programmation procdural.
Je vous avoue que vous avez tudi le plus gros en premire anne puisque le tronc commun en
programmation correspond ce que vous, administrateurs rseaux, devez savoir.
3
8 3987 TG PA 00
Ce cours vous apportera quelques complments mais sera pour lessentiel loccasion de rviser et
de mettre en uvre les notions tudies en premire anne.
Si vous aviez des difficults lanne dernire en programmation, donnez-vous une chance : le
recul, lapproche diffrente puisque les exigences ne sont plus les mmes... Tout cela peut vous
permettre, non pas dadorer la programmation, mais au moins den assimiler les bases sans trop
de difficult. lexamen (preuve dtude de cas), vous aurez de lalgorithmique relativement
simple... si vous ntes pas totalement allergique la discipline.
Dans la formation
En formation initiale (en lyce), la seconde anne stend sur 29 semaines (hors stage), le volume
horaire hebdomadaire de la programmation tant pour votre option denviron une heure de
cours et une heure de travaux dirigs. Cela reprsente 60 heures.
Faut-il donc passer 60 heures sur ce support ? Non, sans doute pas, car bien quapportant les
mmes connaissances quun cours en lyce (vous ntes pas vol), il est prsent de faon plus
concise et lapprentissage autonome est plus rapide. Nanmoins, il ne faut pas esprer matriser
la programmation en lisant dune traite ce fascicule. Vous devez apprendre passer du temps sur
les concepts prsents.
Chacun de vous a un rythme de travail diffrent. La question ne doit donc pas tre combien de
temps passer sur un cours ? , mais ai-je compris et retenu les concepts prsents ? . Si la rponse
cette seconde question est oui, vous pouvez passer la squence suivante. Si cest non, il faut
reprendre la squence courante un peu plus tard.
En effet, il y a une grande diffrence entre comprendre plus ou moins le principe et parfaitement assimiler un concept . Dans le premier cas, le savoir nest pas assimil et cela vous bloquera
dans la suite du cours ; dans le second cas, tout ira bien.
Pour chacun des concepts que nous verrons, il faudra dune part apprendre parfaitement sa dfinition (travail de mmoire) et dautre part identifier ce que cela signifie (travail de comprhension).
Prsentation du support de cours

Ce cours a t conu pour pallier au maximum les difficults de lapprentissage distance : les
notions retenir (dfinitions...) sont mises en avant et des exercices et questions sont prsents
tout au long du support pour vous permettre de vrifier votre comprhension.
Mais jinsiste sur le point suivant : quelle que soit la qualit pdagogique de ce cours, il ne vous
permettra pas dassimiler la programmation par simple imprgnation visuelle. Vous devrez fournir un travail dapprentissage (le cours), de rflexion (toujours le cours) et dentranement (les
exercices).
Le cours est constitu de deux fascicules : celui que vous avez en main et un fascicule contenant la
correction de tous les exercices. Les programmes de ce cours sont tlcharger en tapant ladresse
suivante : http://www.campus-electronique.tm.fr/BTS-Informatiquegestion, puis en allant la rubrique tlchargez.
4
8 3987 TG PA 00
Organisation
Le fascicule de cours contient diffrentes choses :
trois squences de cours correspondant aux savoirs de S35 ; la fin de chaque squence, vous
trouverez une fiche synthse vous rappelant les choses essentielles ( apprendre !) ;
des exercices intgrs aux squences de cours. Vous devez faire ces exercices quand vous arrivez dessus puis aller consulter la correction. Attention, ces exercices permettent de vrifier
votre assimilation du cours. Leur corrig, trs dtaill, ne doit pas tre nglig : jy prsente
des situations, des techniques, des ides et des raisonnements qui ne sont pas anecdotiques
et font partie intgrante du cours. Sils ne sont pas physiquement dans le fascicule de cours,
cest uniquement pour conserver une certaine lisibilit au document ;
trois sries dexercices jouant le rle de travaux dirigs. Elles sont places la fin du cours.
Le fascicule dautocorrection comprend :
la correction des exercices intgrs aux squences ;
la correction des TD.
la correction du devoir autocorrectif .
En plus de vous donner la solution des exercices, jai essay de dtailler ces corrections pour envisager les diffrentes solutions possibles, les erreurs viter... Plus que des corrections, ce sont de
vritables lments de cours. Il ne faut donc pas les prendre la lgre !
Contenu
Les trois squences abordent les points suivants :
variables, types et instructions de contrle dans la 1re squence ;
les sous-programmes et les paramtres dans la 2e ;
les tableaux et les types structurs dans la 3e.
Les squences ont t dfinies pour vous aider tablir votre progression. Elles reprsentent donc
approximativement un volume de travail identique. Le dcoupage nest nanmoins pas arbitraire :
les diffrents concepts ont t rpartis au mieux pour que chaque squence reste cohrente.
Notations
Pour vous aider identifier les diffrents constituants du cours, jai utilis les reprsentations
suivantes :
tout ce qui est mis en vert doit tre appris par cur. Cela correspond aux dfinitions ou
explications quil est absolument ncessaire de connatre pour sen sortir en programmation.
Quand je dis apprendre, ce nest pas retenir pour lheure qui suit afin dpater les convives
au prochain repas. Il sagit dune vraie leon, dont vous devez vous souvenir tout au long de
votre vie dinformaticien, ou, plus prosaquement, au moins jusqu lexamen. Ces informations sont reprises la fin de chaque squence dans la fiche synthse ;
les exercices intgrs dans les squences et destins vrifier votre comprhension doivent
tre faits au fur et mesure de la lecture du cours. Leur correction se trouve dans le fascicule
correction des exercices. Ils sont prsents sur un fond vert .
5
8 3987 TG PA 00
Quelques conseils
Le seul conseil utile que je puisse vous donner est de garder lesprit la fable de La Fontaine
Le livre et la tortue : il ne sert rien de travailler comme un fou en juin ; travaillez plutt ds
maintenant quelques heures par semaine r-gu-li--re-ment (jaurais pu crire rgulirement ou
RGULIREMENT, mon but tant juste dinsister sur le mot).
La difficult de lenseignement par correspondance rside dans le fait que, par dfinition, vous
tes seul face au cours, personne nest l pour vous guider, insister sur lessentiel ou tablir la
progression du cours.
Pour vous aider suivre un rythme correct, disons que chaque squence correspond un travail
denviron 4 6 heures.
Attention lenviron ! Vous avez sans doute le souvenir de vos tudes o, pour obtenir un mme
rsultat, certains travaillaient toute la soire et dautres se contentaient dtre prsents en cours. Il
en est de mme ici. Les 5 heures ne sont quun ordre de grandeur signifiant juste que 15 minutes,
ce nest pas assez, mais 25 heures, cest trop.
Retenez quil vaut mieux passer 8 heures sur une squence et la comprendre parfaitement, que
faire exactement 300 minutes (5 heures) en passant ct de lessentiel.
De plus, le cours contient des dizaines de petits exercices faire au fur et mesure. Plus vous
passerez du temps dessus (et cest conseill), plus vous risquez de dpasser les 5 heures.
Sommaire
Squence 1 : Variables et instructions
Squence 2 : Procdures et fonctions
35
Squence 3 : Tableaux, structures et types
53
Travaux dirigs 1
81
Travaux dirigs 2
89
Travaux dirigs 3
93
Devoir autocorrectif ne pas envoyer la correction
95
6
8 3987 TG PA 00
Squence 1
Variables et instructions
Dure indicative : 5 heures
Dans cette squence, nous allons reprendre les lments cls de la premire anne.
Capacits attendues
Se souvenir du cours de lanne dernire
Avec le recul, matriser ces concepts
Contenu
1.
Introduction .............................................................................................. 8
2.
Le programme ......................................................................................... 8
2A.
2B.
Syntaxe gnrale.......................................................................................... 8
Commentaire ................................................................................................ 9
3.
Les variables et les types .................................................................. 11
3A.
3B.
3C.
3D.
3E.
3F.
Dfinition .................................................................................................... 11
Pourquoi le type est-il obligatoire ? ......................................................... 12
Gestion de la mmoire............................................................................... 14
Exemple ....................................................................................................... 14
Pourquoi tant de dtails ? ......................................................................... 19
Manipulation des variables ....................................................................... 19
4.
Lalternative ............................................................................................ 21
5.
Les boucles (rptitives) .................................................................... 23
5A.
5B.
5C.
5D.
Tant que faire .......................................................................................... 23

Rpter jusqu ....................................................................................... 25
Pour ............................................................................................................. 26
Conclusion sur les boucles ......................................................................... 29
6.
Application .............................................................................................. 30
Synthse
7
8 3987 TG PA 00
Squence 1
1.
Introduction
Ma grande ide est que linformatique na rien invent : elle copie tous ses concepts de
ce qui lentoure.
Autrement dit, les concepts que les informaticiens manipulent ne sont que des mtaphores des choses de la vie relle. De plus, rien nest jamais inutile ni incohrent en informatique. Cest ce qui en fait llgance. Lorsque quelque chose ne nous semble pas logique,
cest gnralement parce quil nous manque des lments thoriques.
Nous allons travailler de la faon suivante : je vais vous demander de dfinir prcisment
chaque concept tudi en premire anne. Lobjectif est de vous plonger dans vos souvenirs et de vrifier si vous matrisez rellement ces diffrentes notions. Il faut donc jouer le
jeu et rpondre srieusement. Ne vous contentez pas de rpondre oralement voire dans
votre tte ! Prenez le temps de rflchir et de rdiger votre rponse.
Je vous proposerai ensuite ma dfinition puis quelques exemples.
2.
Le programme
2A.
Syntaxe gnrale
Exercice 1
Commenons simplement : quest-ce quun programme ? Comment lcrit-on ? Comment sexcute-t-il ? Quelle est la diffrence entre programme et algorithme ?
Un programme ou un algorithme est une suite dinstructions. Il doit raliser quelque
chose, savoir un traitement prcis partir de donnes fournies en entre.
Comment lcrit-on ? Et bien, on numre les variables utilises, puis on crit les sousprogrammes (procdures et fonctions) et enfin le programme principal. (Lorsque lon
utilise un langage vnementiel, on peut souvent se passer de programme principal.)
La diffrence entre un algorithme et un programme est assez tnue : lalgorithme est
une construction intellectuelle sur papier avant tout destine rflchir pour trouver
une solution un problme. Le programme, cest la traduction plus ou moins simple
dun algorithme dans un langage de programmation quelconque (VB, Delphi, C) pour
pouvoir lexcuter.
On pourrait dire que lalgorithme, cest le plan de larchitecte et le programme, cest la
maison termine sauf quil est plus difficile de passer du plan la maison que de lalgorithme au programme.
Comment sexcute un programme ? Ma foi, on traite squentiellement (une une dans
lordre) toutes les instructions, de la premire la dernire. (Cela ntant valable quen
absence de plantage !)
8
8 3987 TG PA 00
Il est important de se souvenir quune instruction peut en contenir dautres. Ainsi, excuter une alternative ou une boucle peut conduire excuter dix instructions (nous y
reviendrons).
La syntaxe gnrale dun algorithme (sans sous-programme pour linstant) est :
Algorithme nom de lalgorithme
var
dclaration des variables
dbut
instructions
fin
2B.
Commentaire
2B1. Rle du commentaire
Il est ncessaire de placer des commentaires dans un programme. Ils ne sont destins
quau dveloppeur et sont totalement ignors par le compilateur.
Vous mettrez des commentaires pour expliquer le droulement de vos algorithmes :
pour identifier les diffrentes tapes ;
pour expliquer des instructions complexes ou des indices de boucle malaiss comprendre.
Le commentaire est utile tous :
faire leffort de rdiger une explication vous oblige formaliser les choses beaucoup
plus que lors de la simple criture du code. Cela peut vous permettre de dtecter
une erreur ;
si vous devez intervenir sur votre programme quelques jours ou semaines plus tard,
vous ne comprendrez plus les parties complexes de vos algorithmes. Un commentaire vous rafrachira la mmoire. dfaut, vous devrez recommencer le processus
intellectuel vous ayant amen ce code. Et a, cest assez humiliant ;
dans le cas dun dveloppement professionnel en entreprise, vous interviendrez
constamment sur du code quun autre aura rdig, soit parce que vous travaillerez
plusieurs, soit tout bonnement parce quil faut toujours maintenir les anciennes
applications. Or, chacun possde sa propre logique et ses tics de programmation.
Du coup, lire un code sans commentaire peut se rvler trs complexe. Et face une
instruction bizarre, il faudra beaucoup rflchir pour dterminer si cest un bug (
corriger) ou une astuce de programmation ;
Par exemple, si une boucle va de lindice i i+j+2, il est sans doute intressant dexpliquer
pourquoi la valeur finale contient +2 et pas +1 ou nest pas simplement i+j. En effet, cest
typiquement sur ce genre de choses que le dveloppeur produit des bugs.
Je vous assure que voir un bout de code que lon a crit et ne plus russir comprendre ce quil
signifie, cest vraiment humiliant. Et aprs, plein de questions malsaines viennent lesprit, du
genre est-ce que je serais encore capable dcrire un code aussi efficace ? .
9
8 3987 TG PA 00
Squence 1
un commentaire permet de signaler que, mme si ce nest pas vident au premier

coup dil, votre code prend en compte telle situation ou tel cas derreur ou, au
contraire, il peut expliquer pourquoi cette situation ou cas derreur nest pas prise
en compte (par exemple, parce que du code en amont a dj rgl le problme). Le
lecteur sait alors que ces cas ont t envisags ;
tout ceci est valable quelle que soit votre option. Dans mon lyce, je gre le parc informatique du BTS IG. Jai naturellement dvelopp des scripts pour automatiser certaines tches dadministration du rseau, comme tout administrateur de rseau local
doit le faire. Vous trouverez beaucoup dexemples de scripts dans les documentations
ou sur internet. Je vous assure quils sont beaucoup plus denses et complexes quun
algorithme de gestion standard. Et sans commentaires, les adapter vos besoins est
une gageure.
2B2. criture du commentaire

crire des commentaires, cest tout un art. Il ne faut pas en mettre trop ou trop peu. Vous
viterez les deux cueils qui suivent.
La paraphrase
Rservez le commentaire pour les parties compliques du code et ne faites pas de traduction en franais des instructions.
Par exemple, envisageons ce bout de code :
pour i de 22 LongueurTableau+3 faire
table1[i+3] := table2[i+1]
fin pour
Exercice 2
Concernant ce code, que pensez-vous du commentaire suivant :
On prend la case i+1 de table2 pour la mettre dans la case i+3 de table1 pour toutes les
valeurs de i allant de 22 LongueurTab+3. ?
En revanche, les points qui mritent une explication sont :
pourquoi la boucle va de 22 LongueurTableau+3 et pas de 1 LongueurTableau
comme on pourrait sy attendre ?
pourquoi on affecte la case i+1 dun tableau la case i+3 dun autre ? En effet,
habituellement, on affecte deux cases de mme rang (ici i+1 ou i+3) ;
le corps de la boucle nutilise jamais i directement mais i+1 et i+3. Ce nest pas trs
lisible. Y a-t-il une raison ce dcalage du corps par rapport lindice ?
Dans un code, on commente en fonction des difficults de ce code. Un algorithme simple contiendra des commentaires sur des choses simples. En revanche, il est vident que,
dans un programme trs complexe, les commentaires feront limpasse sur les parties pas
trop dures pour se concentrer sur ce qui est rellement difficile. En clair, un morceau de
code pourra tre valablement expliqu dans un algorithme et tout aussi valablement pas
expliqu dans un autre.
Lorsque vous intervenez sur un petit morceau de code, vous ntes pas au fait de lensemble de
lapplication.
10
8 3987 TG PA 00
Le verbiage
Un commentaire doit tre crit :
dans un franais irrprochable pour lever toute ambigut. Lobjet dun commentaire, cest dexpliquer. Sil nest pas comprhensible, il ne sert rien ;
de faon concise. Plus vos commentaires sont brefs et tranchants, plus ils seront
exploits.
Nous retiendrons que :
Un commentaire est prcd par des caractres // (deux barres de division). Dit
autrement, tout ce qui suit les deux barres est ignor par le compilateur.
Le commentaire doit tre clair, concis, sans ambigut et nexpliquer que ce qui doit
ltre. Ce nest pas une fioriture mais une plus-value votre code.
3.
Les variables et les types
3A.
Dfinition
Exercice 3
Dfinissez variable et type en prcisant bien le lien entre les deux. Expliquez ce
quest la dclaration de variable et quoi elle sert.
Reprenons (et apprenons) la correction :
Type :
Le type dune variable dcrit sa nature, ce quelle contient (entier, boolen, rel,
caractre).
Variable :
Cest un espace mmoire contenant une valeur dun type donn.
Dclaration :
La dclaration dune variable contient un nom de variable explicite (qui a un sens
pour le dveloppeur) et un type. Elle entrane la rservation dun espace mmoire
de taille suffisante (fonction du type) pour y stocker la valeur. Le nom de la variable
est associ lespace mmoire.
Exemple :
var
ge : entier
Je viens de dclarer la variable entire ge. Plus prcisment, je viens de rserver un
emplacement mmoire (o dans la mmoire ? ce nest pas mon problme) de taille suffisante pour y stocker une valeur entire. Cet emplacement mmoire est nomm ge.
11
8 3987 TG PA 00
Squence 1
La syntaxe (lcriture) de la dclaration dpendra du langage utilis mais vous aurez

toujours fournir un nom et un type de donne.
3B.
Pourquoi le type est-il obligatoire ?

3B1. Thorie
Tout est stock sous la forme de 0 et de 1 dans la mmoire de lordinateur (RAM), que ce
soient les instructions en cours dexcution (le programme) ou les donnes en mmoire
(entiers, boolens, rels, caractres).
La mmoire contient des bits (valeur 0 ou 1) regroups par 8 pour former un octet. La
mmoire est donc divise en (beaucoup de) octets.
Jai crit un petit programme sous Delphi et je suis all voir le contenu de la mmoire
en piochant au hasard les seize bits suivants : 0110001011001001. Seize bits, cest deux
octets, soit : 01100010 11001001. En traduction dcimale, cela donne 98 et 201. Nous
allons essayer de comprendre ce que reprsentent ces deux octets.
Dans la mmoire, on trouve la valeur des variables, mais aussi les instructions du programme qui sexcute. Je repose ma question : que reprsentent ces deux octets ? Et
bien, il est totalement impossible de le savoir.
En effet, puisque toute information (valeur dun type quelconque ou instruction) est
code sous la forme de 0 et de 1, on dira de faon symtrique que toute suite de 0 et de
1 est capable de reprsenter une instruction ou une variable dun type quelconque.
3B2. Exemple
Nous allons prendre lexemple de mes deux octets. Sous Delphi, les deux octets
01100010 11001001 sont la reprsentation en mmoire de choses trs diverses :
la chane de caractres b. tant constitue de deux caractres, elle occupe deux
octets en mmoire. Notez que rien nest simple : peut-tre quen vrai, mon programme a stock une chane de 5 caractres (par exemple XbTy) en mmoire et
que, en prenant mes 16 bits au hasard, jai extrait ceux codant les 2e et 3e caractres
de cette chane ;
les deux caractres b et (donc deux valeurs indpendantes mais stockes dans des
zones mmoire contigus) ;
le tableau de deux octets [98,201] ;
les deux octets 98 et 201 (donc deux variables indpendantes) ;
Enfin, certains langages ne demandent pas de type (PHP) ou peuvent sen passer (VB). Le compilateur se dbrouille alors pour dterminer tout seul le type de la variable (si vous crivez une
instruction i := 1, il dterminera que i est un entier) ou il utilise un type gnrique (variant)
permettant, au prix dun gros gchis de ressources et dune nette dgradation des performances,
de stocker nimporte quel type de donne de base. Tout cela pour vous dire quil faut typer
ses variables ds que le langage ly autorise.
Attention aux homonymes ! Le bit informatique est un nom masculin et sans e. Cest vraiment
une coquille viter, loral comme lcrit.
Ce qui suit est exact car jai exploit la documentation de Delphi pour connatre les modes de
codage. Je ne vous les explique pas, il faut me faire confiance.
Loctet (type Byte sous Delphi) est un entier allant de 0 255 cod sur 8 bits (un octet).
12
8 3987 TG PA 00
le mot 51554 ;
linstruction assembleur bound ecx, ecx ;
lentier court 13982 ;
deux valeurs boolennes vrai et vrai (ou le tableau de deux boolens [vrai, vrai]) ;
Mes deux octets peuvent donc tre interprts de multiples faons et, sans plus de prcision, je nai aucun moyen de savoir quelle valeur retenir puisque toutes sont valides. Pour
trancher, je dois imprativement connatre le type de la valeur stocke. Vous remarquerez en passant que rien ne distingue deux valeurs indpendantes dun tableau de deux
valeurs. Nous reviendrons dessus dans la squence 3, paragraphe 2.
Quand jaccde la mmoire, je dois donc savoir quoi y chercher. Par exemple, si je sais
que mes deux octets stockent la valeur :
dun mot, je nai qu appliquer les rgles de codage des mots : un mot m compris
entre 0 et 65 535 sera cod sur deux octets successifs x et y tels que m = x + y*256.
Ici, x et y valent respectivement 98 et 201 donc m = 98 + 201*256 = 51 554 ;
de deux caractres (quils soient dans un tableau ou indpendants ne change rien),
japplique les rgles de codage des caractres : chacun est reprsent par son code
ASCII. Or, les caractres de code 98 et 201 sont respectivement b et ;
3B3. Allons plus loin

Dans les diffrentes interprtations que jai donnes des deux octets, je nai pas parl
de nombres rels. Pourquoi ? Car ces derniers sont stocks sur au moins quatre octets
(trente-deux bits). Ainsi, mes deux octets ne seront au mieux quune partie des bits
ncessaires au stockage dun nombre rel.
Dailleurs, jai bien dit que je prenais mes seize bits au hasard. Peut-tre les ai-je prlevs
en plein milieu de vrais octets (en gras mes seize bits) :
11100110 00101100 10010101
Dans ce cas, il ne sagit plus des deux octets 98 et 201, mais des trois octets 230, 44 et 149.
Ces deux dernires remarques me permettent de prciser une chose importante. Pour
accder une valeur stocke en mmoire, il faut savoir :
quoi chercher ;
o le chercher.
Par exemple, si je cherche un mot (entier de type Word, rpondant quoi), je sais que
je devrai considrer deux octets conscutifs. Si je connais lemplacement mmoire du
premier (rpondant o), je nai plus qu lire les deux puis convertir leur contenu en
une valeur de type mot comme ci-dessus.
Le mot (Word) est un entier entre 0 et 65 535 cod sur 16 bits (deux octets).
Que fait cette instruction ? Je nen sais rien et cela na aucune importance.
Lentier court (SmallInt) est un entier entre 32 768 et 32 767 cod sur 16 bits.
13
8 3987 TG PA 00
Squence 1
3C.
Gestion de la mmoire
Jai dit dans le paragraphe prcdent que la mmoire tait divise en octets. Comme
toujours, pour accder quelque chose, il faut lidentifier. Pour accder un octet de la
mmoire, il faut donc lidentifier. Pas question de dire je veux cet octet l, non, pas le
gros dbraill gauche, celui qui est juste derrire . Il nest videmment pas possible
de nommer les milliards doctets constituant la mmoire. Le plus simple est donc de les
numroter comme le sont les lments dun tableau.
Dans la ralit, on passe par une notion de page quivalente celle dun livre (il est
plus rapide de trouver la 24e ligne de la page 356 que la 17 824e ligne dun livre). Nous
simplifions donc en considrant la mmoire comme un tableau Excel. Cela ne change
rien au propos.
De mme, vous savez que les systmes dexploitation actuels sont multitches. Plusieurs
applications tournant simultanment, chacune doit avoir son propre espace mmoire
pour stocker ses donnes en toute scurit. Nous ne grerons pas cela (cest un problme
de systme dexploitation) et nous considrerons que toute la mmoire est nous.
Dans le paragraphe 3A, jai dit que la dclaration de variable rservait quelque part
dans la mmoire une zone de taille suffisante pour y stocker son contenu. En effet, cest
le compilateur qui gre la mmoire. Ainsi, le programmeur donne un nom sa variable tandis que le systme lui attribue un ou plusieurs octets conscutifs numrots. Le
compilateur doit donc faire le lien entre les deux car lorsque le dveloppeur parle de la
variable ge, lapplication doit savoir :
que cest un entier ;
dans quels octets de la mmoire la valeur de ge est stocke.
Pour cela, lapplication va grer une table (un tableau) associant chaque nom de variable son type et lemplacement dans la mmoire du premier octet quelle occupe.
(Ce tableau est lui-mme stock dans une autre zone de la mmoire.)
3D.
Exemple
3D1. Dbut de programme
Nous sommes au dbut du programme, aucune variable nest dfinie et la mmoire est
vide. Mais que veut dire vide ? En fait, il y a toujours quelque chose, par exemple les
donnes du programme que vous venez de quitter ou des valeurs alatoires dpendant
de ltat lectrique de la mmoire. Les octets correspondants sont nanmoins rputs
libres, dans la mesure o ce quils contiennent na pas de signification pour nous. Cest
pour cette raison que vous devez initialiser vos variables avant usage : pour viter de
rcuprer des donnes stockes par danciens programmes.
Un policier venant arrter quelquun et ne le trouvant pas chez lui dira son suprieur
Lappartement tait vide. Le dmnageur, une fois avoir enlev toutes vos affaires, dira lappartement est vide . Vous tes daccord que ce ne sont pas les deux mmes vides ?
14
8 3987 TG PA 00
Voil ltat de la mmoire au commencement. Jinsiste : le contenu des cases A1 J4 ne

signifie rien. Jai donc crit en gris les donnes pour bien marquer le coup.
VARIABLE
Tableau des variables

TYPE
ADRESSE DBUT
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
22 2 246 235 222 109 20
24 240 41 108 85 45 230
73 213 65 214 206 56 245
224 73 221 153 180 124 122
H
I J
170 225 55
15 145 55
41 92 96
119 8 211
3D2. Dclaration des variables

Je dclare un entier de type mot (stock dans deux octets) et une chane de sept caractres :
var
Taille : mot
Nom : chane[7] // chane de 7 caractres
Lapplication va alors rserver quelque part l o il y a de la place (pour le moment,
partout) deux octets pour le mot et sept pour la chane puis mettre jour le tableau des
variables.
VARIABLE
Taille
Nom

TYPE
ADRESSE DBUT
mot
D2
chane[7]
B4
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
22 2 246 235 222 109 20
24 240 41 108 85 45 230
73 213 65 214 206 56 245
224 73 221 153 180 124 122
H
I J
170 225 55
15 145 55
41 92 96
119 8 211
Notez quil ne sest rien pass en mmoire de A1 J4. Seul le tableau des variables a
t modifi. Cela dit, ds ce moment, les cellules D2, E2 et B4 H4 contiennent quelque
chose pour le programme (la valeur de ses variables), raison pour laquelle elles sont
encadres et crites en noir. Si vous accdez la variable :
Taille, lapplication ira chercher ce qui se trouve en D2 et E2 et linterprtera comme
un entier de type mot ;
Nom, lapplication interprtera le contenu de B4 H4 comme les codes ASCII des
diffrents caractres constituant la chane.
3D3. Valeur avant initialisation

Voyons cela ; supposons alors que, juste aprs les avoir initialises, jaffiche le contenu
de mes variables :
Afficher (Taille)
Afficher (Nom)
Que vais-je obtenir ?
laffichage de Taille donnera 21868 (car 108+85*256 = 21 868, voir le paragraphe 3B2
ci-dessus) ;
laffichage de Nom donnera I|zw. Cette chane est forme par les caractres dont
les codes ASCII sont dans les zones B4 H4. Par exemple, le code ASCII de est 221.
15
8 3987 TG PA 00
Squence 1
3D4. Initialisation des variables

Ces valeurs ont-elles un sens pour notre application ? Non, aucun. Cest la raison pour
laquelle je dois initialiser mes variables dans le programme :
Taille := 51554
Nom := fvrier
Que fait lapplication ? Elle cherche dans le tableau des variables quel endroit de la
mmoire se trouve Taille (elle commence loctet D2 et comme cest un mot, elle se continue sur E2). Elle y stocke le nombre 51 554 cod, nous lavons vu, par les deux octets
98 et 201.
Ensuite, cest le tour de Nom. Nous avons vu prcdemment que pour stocker une chane,
on stockait successivement les codes ASCII de chaque caractre. Au final, on obtient :
VARIABLE
Taille
Nom

TYPE
ADRESSE DBUT
mot
D2
chane [7]
B4
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
22 2 246 235 222 109 20
24 240 41 98 201 45 230
73 213 65 214 206 56 245
224 102 233 118 114 105 101
H
I J
170 225 55
15 145 55
41 92 96
114 8 211
(Ici et dans les tableaux suivants, les changements dans ltat de la mmoire sont en gras.)
3D5. Modifications des variables

Modification de Taille
Dans notre programme, nous incrmentons notre variable numrique :
Taille := Taille+2
Que va faire lapplication ? Toute affectation se ralise en deux temps :
1. on value lexpression droite de loprateur daffectation ;
2. on affecte le rsultat la variable gauche.
Pour calculer lexpression, on va rcuprer la valeur de Taille (soit le contenu des deux
octets D2 et E2 interprts comme un mot), on lui ajoute 2 et on obtient 51 556.
Ce rsultat est ensuite affect la variable Taille, les deux cases D2 et E2 interprtes
comme un mot devenant respectivement 100 et 201.
On obtient ceci :
VARIABLE
TYPE
ADRESSE DBUT
Taille
mot
D2
Nom
chane [7]
B4
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
22 2 246 235 222 109 20
24 240 41 100 201 45 230
73 213 65 214 206 56 245
224 102 233 118 114 105 101
H
I J
170 225 55
15 145 55
41 92 96
114 8 211
Les langages de programmation modernes initialisent automatiquement les variables dclares 0. Nexploitez pas cette caractristique dans vos algorithmes car le correcteur ne saura pas
si vous navez fait aucune initialisation parce que vous saviez que le compilateur la faisait, ou
parce que vous ny aviez pas pens.
Car 98 + 201*256 = 51 554.
16
8 3987 TG PA 00
Modification de Nom
Jappelle alors la fonction Majuscule pour mettre en majuscule la premire lettre du
nom. Comme ma chane est en fait un tableau de caractres, il me suffit de modifier le
premier caractre de ce tableau. Cela donne le code suivant :
Nom[1] := Majuscule(Nom[1])
Que fait lapplication ? Il y a trois tapes :
1. on recherche dans le tableau des variables la position du premier caractre de Nom.
Cest videmment la position de Nom lui-mme, soit B4 ;
2. on rcupre la valeur en B4 et on lui retranche 32. On passe donc du code ASCII 102
(caractre f) au code 70 (caractre F) ;
3. on stocke le rsultat (soit 70) dans la zone mmoire du premier caractre de Nom,
soit B4.
Cela nous donne ltat de la mmoire suivant :
VARIABLE
Taille
Nom

TYPE
ADRESSE DBUT
mot
D2
chane [7]
B4
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
22 2 246 235 222 109 20
24 240 41 100 201 45 230
73 213 65 214 206 56 245
224 70 233 118 114 105 101
H
I J
170 225 55
15 145 55
41 92 96
114 8 211
3D6. Simplification
Maintenant que nous avons vu le fonctionnement prcis de lallocation mmoire, nous
allons nous empresser de tout simplifier. En effet, notre niveau, il est inutile de grer
le codage des donnes. Nous allons donc estimer que les cases D2 et E2 contiennent
directement la valeur de Taille et que les cases B4 H4 contiennent directement celle de
Nom. Cela donne la reprsentation suivante :
VARIABLE
Taille
Nom

TYPE
ADRESSE DBUT
mot
D2
chane [7]
B4
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
H
I J
22 2 246 235 222 109 20 170 225 55
24 240 41
51556
45 230 15 145 55
73 213 65 214 206 56 245 41 92 96
224
Fvrier
8 211
Les zones mmoire qui ne sont pas lies notre programme ne changent pas puisque
leurs valeurs nont pas de sens pour nous.
Du coup, supposons que jexcute ces deux instructions divisant par deux Taille et mettant tout Nom en majuscules :
Taille := Taille/2
Nom := Majuscule(Nom)
Car le code ASCII de chaque lettre majuscule est gal au code de sa minuscule moins 32.
17
8 3987 TG PA 00
Squence 1
Les deux instructions prcdentes ont sur la mmoire limpact suivant :

VARIABLE
Taille
Nom

TYPE
ADRESSE DBUT
mot
D2
chane [7]
B4
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
H
I J
22 2 246 235 222 109 20 170 225 55
24 240 41
25778
45 230 15 145 55
73 213 65 214 206 56 245 41 92 96
224
FVRIER
8 211
3D7. Fin du programme

Laissons le programme continuer tranquillement en supposant quil ne modifie plus ni
Taille ni Nom. Que se passe-t-il lorsquil est fini ? Ma foi, il se termine. En dautres termes,
il sarrte. On pourrait galement dire quil met un terme son excution.
Et la mmoire dans tout cela ? Et bien, les zones mmoire occupes par les variables
du programme (ici D2, E2 et B4 H4) sont libres. Va-t-on parcourir toutes les cases
en mmoire pour les vider ? Non ! Dailleurs, que signifie vider ? Mettre la valeur 0 ?
Ce nest pas acceptable car 0 est une valeur entire tout fait correcte. On ne pourrait
donc pas distinguer le 0 valeur entire du 0 absence de valeur. On va donc simplement
vider le tableau des variables, ce qui a en outre lavantage de la rapidit. Les octets alors
librs sont de nouveau disponibles, ce qui signifie que les valeurs quils stockent ne
correspondent plus rien.
Cest pourquoi plus rien nest encadr et tout est crit en gris dans ltat mmoire cidessous :
VARIABLE

TYPE
ADRESSE DBUT
1
2
3
4
tat de la mmoire
A
B
C
D
E
F
G
22 2 246 235 222 109 20
24 240 41 178 100 45 230
73 213 65 214 206 56 245
224 70 201 86 82 73 69
H
I J
170 225 55
15 145 55
41 92 96
82 8 211
Observez bien le contenu des cases :

D2 et E2. Elles contiennent respectivement 178 et 100, ce qui correspond bien
178+100*256 soit 25 778, la dernire valeur en date de Taille ;
B4 H4. Elles contiennent respectivement les codes ASCII des lettres constituant le
mot FVRIER, soit la dernire valeur en date de Nom.
Vous noterez que jai remis la valeur de chaque octet et que jai effac lencadrement
autour des cellules. Pourquoi ? Car toutes ces zones mmoire sont maintenant indpendantes : les cases D2 et E2 ne stockent plus elles deux un mot (cette variable nexiste
plus) mais possdent des valeurs arbitraires et sans signification laisses l par lexcution
dun programme maintenant termin. Ces valeurs peuvent tre interprtes comme des
caractres, des entiers si un nouveau programme rserve la case C4 pour y stocker :
un entier, elle y trouvera la valeur 201 laisse par le programme que lon vient de
quitter. Do limportance dinitialiser cette variable avant de sen servir :
un caractre, elle y trouvera un laiss par le programme ;
Lintrt de ce mcanisme est vident lorsque vous pensez aux variables locales : quand
vous arrivez dans un sous-programme, ses variables locales sont cres, utilises tout au
long du sous-programme puis dtruites lorsque ce dernier se termine (nous le reverrons).
18
8 3987 TG PA 00
3E.
Pourquoi tant de dtails ?

Je vous ai fait croire que nous faisions des rappels et, mine de rien, je suis all bien plus
loin que le cours de 1re anne. Pourquoi ? Car nous aurons besoin de ces connaissances
plus tard. Cela dit, cest tout de mme visuel et intuitif.
3F.
Manipulation des variables

3F1. En criture
On va modifier la valeur de la variable. Deux techniques : soit on demande lutilisateur
de saisir la valeur (instruction saisir), soit on ralise une affectation (instruction := ).
Saisie
La syntaxe est :
saisir chane, variable
Lorsque cette instruction est excute, que se passe-t-il ? Quelque chose quil faut
apprendre.
1. La chane de caractres chane est affiche lcran.
2. Lapplication attend que lutilisateur rentre (saisisse au clavier) quelque chose.
3. La valeur saisie est affecte la variable (valeur et variable doivent tre de mme
type).
Voici deux exemples permettant de saisir deux variables. Vous noterez que chane est
l pour avertir lutilisateur de la nature de ce quil doit saisir. Il faut donc videmment
mettre quelque chose de lisible.
saisir "Entrez votre nom :", NomPersonne
saisir "Entrez votre ge :", AgePersonne
Affectation
La syntaxe est :
variable := expression
Lorsque cette instruction est excute, que se passe-t-il ? Quelque chose quil faut
apprendre :
1. Lexpression est value (calcule).
2. Le rsultat est affect la variable (lancienne valeur de la variable est perdue car
remplace par la nouvelle). Lexpression et la variable doivent tre de mme type.
Enfin, la thorie le voudrait : affecter une chane de caractres un boolen na pas de sens.
Nanmoins, les affectations cohrentes sont admises : on peut affecter un entier un rel (les
valeurs entires faisant partie des rels, tout entier peut tre converti en rel), un entier court un
entier long
Avec les mmes tolrances que pour la saisie. On dispose de plus de fonctions permettant de
changer le type dune valeur (qui peut sen trouver modifie). La plus connue est int, convertissant
par troncature un rel en un entier. Ainsi, i tant un entier, i := 3.5 est incorrect. En revanche, i :=
int (3.5) est valide puisque int (3.5) est gal la valeur entire 3. On affecte donc bien un entier
une variable entire.
19
8 3987 TG PA 00
Squence 1
3F2. En lecture
On rcupre la valeur de la variable pour lafficher ou pour sen servir. Exemple :
AnnesAvantRetraite := 65 AgePersonne
// AgePersonne est lue
On peut afficher lcran ( destination de lutilisateur) la valeur dune variable avec

linstruction Afficher :
Afficher expression1, expression2, expressionn
Le fonctionnement est simple.
Chaque expression est successivement value puis son rsultat est affich.
Exemple :
Afficher "Vous serez en retraite dans ", 65 gePersonne, " ans."
Que fait cette instruction ? Si gePersonne vaut 34, alors :
elle valuera "Vous serez en retraite dans" (cest vite fait puisque cest une constante) et affichera le rsultat, soit Vous serez en retraite dans ;
elle valuera 65 gePersonne, soit 65 34 soit 31 et affichera donc 31 ;
elle valuera "ans." (cest vite fait puisque cest une constante) et affichera le rsultat, soit ans.
Au final, sur lcran, on obtiendra :
Vous serez en retraite dans 31 ans.
Une remarque importante :
Afficher va la ligne ou pas en fonction de ce qui nous arrange.
Ainsi, le code :
Afficher "Boujour"
Afficher " tous !"
produira au choix lun des deux rsultats suivants :
Bonjour tous !
Bonjour
tous !
En bref, ne vous souciez pas dun retour la ligne quelconque. Lalgorithmique a ceci
de sympathique que, si jai rellement besoin de raliser un algorithme produisant une
sortie trs contrle, je nai qu dire quAfficher ne va jamais la ligne et je dote mon
langage dune instruction ChangeLigne qui, lorsquelle est excute, change de ligne.
20
8 3987 TG PA 00
4.
Lalternative
On parle dinstruction de contrle car lalternative ne ralise rien par elle-mme : pas
daffichage, pas de modification de variable Son objet est de dterminer en fonction
dune condition quelles instructions qui elles, feront quelque chose seront excutes.
Lalternative contrle (dirige) lexcution du programme.
Exercice 4
Allez, sans lire la suite, donnez-moi la syntaxe de lalternative (linstruction si) et expliquez
son fonctionnement.
Lalternative a pour syntaxe gnrale si alors sinon, la branche sinon tant facultative (ce
qui donne si alors). La syntaxe associe une expression boolenne et des suites dinstructions (dans le alors et dans le sinon) :
si boolen
alors
instructions_oui
sinon
instructions_non
fin si
si boolen
alors
instructions_oui
fin si
Sil ny a aucune instruction dans le sinon, on ne met pas le mot sinon et on obtient le
si alors.
Lorsque lexcution arrive linstruction si, voici ce qui se passe :
1. Le boolen est valu (calcul).
2. En fonction de la valeur obtenue :
2.1. si elle vaut vrai, les instructions de la branche alors sont excutes puis lexcution passe linstruction suivant le si (lventuelle branche sinon est ignore) ;
2.2. si elle vaut faux, les instructions de la branche sinon sont excutes (sil y en a)
puis lexcution passe linstruction suivant le si (la branche alors est ignore).
En paraphrasant linstruction, on peut dire que :
Si le boolen est vrai, alors on excute les instructions du alors et sinon on excute
celles du sinon.
21
8 3987 TG PA 00
Squence 1
Lillustration suivante montre les instructions excutes selon la valeur du boolen. Ce qui est
en couleur est ralis par lapplication de faon automatique. (Cest la traduction du si.)
ALGORITHME
instr_1
instr_2
instr_3
si boolen
alors
instr_o_1
instr_o_2
instr_o_3
sinon
instr_n_1
instr_n_2
fin si
instr_4
instr_5
TRACE DE LEXCUTION
instr_1
instr_2
instr_3
valuation boolen
boolen
faux
boolen
vrai
instr_o_1
instr_o_2
instr_o_3
instr_n_1
instr_n_2
instr_4
instr_5
Cela appelle deux remarques.

1. On dduit aisment que les instructions si peuvent tre imbriques (une instruction si
peut contenir un autre si). En effet, les instructions qui sont dans les branches alors et
sinon peuvent tre nimporte quelle instruction : affectation, saisie, autre si
2. Il est trs important dindenter correctement (les instructions des blocs alors et sinon doivent tre dcales vers la droite par rapport au si). Cela augmente la lisibilit du code
pour le dveloppeur qui identifie facilement les instructions appartenant au si.
Exercice 5
Pour sentraner un peu, crivez un programme permettant de dterminer si un nombre est
pair ou impair. Une petite aide : le nombre n est pair si n mod 2 vaut 0 (loprateur mod renvoie le reste de la division entire).
Je vous rappelle lexistence de linstruction selon cas. Je ne la reprends pas ici car cest une
autre forme du si. Il ne faut pas pour autant loublier !
Je vous disais que linformatique na rien invent. Et bien, dans le langage courant, voici
exactement une instruction si :
si jai le bts
alors
je paye le champagne puis je cherche du travail
sinon
je redouble
Cest un euphmisme : cela naugmente pas la lisibilit mais rend le code lisible. Dit autrement,
un code non indent est illisible.
22
8 3987 TG PA 00
Si jinverse le test :
si je nai pas le bts
alors
je redouble
sinon
je paye le champagne puis je cherche du travail
Au fait, dans le dictionnaire, vous verrez que lalternative est un systme logique de deux
propositions o lune est vraie et lautre fausse. Cest pile notre si alors sinon. Pour faire
de linformatique, il vaut mieux tre bon en vocabulaire, cela aide !
5.
Les boucles (rptitives)

On parle dinstructions de contrle car les boucles ne ralisent rien par elles-mmes : pas
daffichage, pas de modification de variable leur objet est de faire excuter 0, 1 ou
plusieurs fois dautres instructions (qui elles, feront quelque chose) en fonction dune
condition. Ces instructions contrlent (dirigent) lexcution du programme.
Les boucles permettent dexcuter une ou plusieurs instructions un certain nombre de
fois (de 0 linfini). chaque excution des instructions de la boucle, on value la valeur
dun boolen pour savoir si on recommence ou non.
Il y a trois instructions de boucle diffrentes. Certaines sont redondantes. Mais alors,
pourquoi sen proccuper ? Car chacune a des caractristiques propres qui la rendront
plus ou moins efficace selon le contexte. Cest le mme principe que le si et le selon cas :
on pourrait se passer de cette dernire instruction, mais elle a t cre pour simplifier
le code dans des cas prcis.
Exercice 6
Donnez-moi les trois boucles (syntaxe et fonctionnement).
5A.
Tant que faire

Je vous prouve que cette instruction existe dj dans la vraie vie :
tant que la fin du cours na pas sonn
les tudiants travaillent.
Voici la syntaxe :
tant que boolen faire
instructions
fin tant que
Le fonctionnement de cette instruction est le suivant :
2. Si sa valeur est vrai, les instructions incluses dans la boucle sont excutes et lon
retourne la premire tape. Sinon, on passe linstruction suivant le tant que.
23
8 3987 TG PA 00
Squence 1

Tant que le boolen est vrai, on excute les instructions dans la boucle.
Lillustration suivante montre les instructions excutes. Je rappelle que ce qui est en couleur est automatiquement ralis par lapplication. (Cest la traduction du tant que.)
ALGORITHME
TRACE DE LEXCUTION
instr_1
instr_2
instr_3
instr_tq_1
instr_tq_2
instr_tq_3
fin tant que
instr_4
instr_5
instr_1
instr_2
instr_3
valuation boolen
boolen
vrai
boolen
faux
instr_tq_1
instr_tq_2
instr_tq_3
instr_4
instr_5
Exercice 7
Vous pensez avoir compris ? Oui, bien sr, puisque vous utilisez cette instruction depuis un
an maintenant. Bien. Dites-moi alors ce que ces quatre blocs dinstructions vont afficher (en
expliquant videmment). Faites attention, il y a de nombreux piges.
1er bloc
afficher "avant boucle"
tant que (2 = 3) faire
afficher "dans boucle"
x := x/0
fin tant que
afficher "aprs boucle"
3e bloc
i := 1
tant que (i > 0) faire
i := i-1
fin tant que
2e bloc
i := 1
i := i+1
fin tant que
4e bloc
i := 5
j := -1
j := j+1
fin tant que
24
8 3987 TG PA 00
5B.
Rpter jusqu
Dans la vraie vie :
tu mangeras
jusqu ce que ton assiette soit vide.
Voici la syntaxe :
rpter
instructions
jusqu boolen
1. Les instructions incluses dans la boucle sont excutes.
2. Le boolen est valu. Sil est faux, on retourne la premire tape. Sinon, on
passe linstruction suivant le rpter.
On rpte les instructions dans la boucle jusqu ce que le boolen soit vrai.
Lillustration suivante montre les instructions excutes. Encore une fois, ce qui est en couleur est ralis par lapplication de faon automatique. (Cest la traduction du rpter.)
ALGORITHME
instr_1
instr_2
rpter
instr_rjq_1
instr_rjq_2
instr_rjq_3
jusqu boolen
instr_3
TRACE DE LEXCUTION
instr_1
instr_2
instr_rjq_1
instr_rjq_2
instr_rjq_3
valuation boolen
boolen
vrai
boolen
faux
instr_3
Exercice 8
Vous pensez avoir compris ? Dites-moi alors ce que ces deux blocs dinstructions vont afficher
(en expliquant videmment).
1er bloc
rpter
saisir "Entrez lge : ", ge
jusqu (ge > 0) et (ge < 120)
2e bloc
rpter
x := x/0
jusqu x = x
25
8 3987 TG PA 00
Squence 1
5B1. Comparons Tant que et rpter

Ce sont deux surs trop souvent confondues. Il faut donc apprendre ce qui suit.
Comparaisons des deux boucles
TANT QUE ... FAIRE
test du boolen
la 1re excution de la boucle

nombre ditrations (dexcutions des instructions de la
boucle)
on sort de la boucle quand le
boolen est
REPETER ... JUSQU'A
avant
aprs
faux
vrai
Les deux boucles partagent une rgle de validation que je vais vous livrer. Cest un
rsum des deux exercices 7 et 8. Assimilez-la et vrifiez-la chaque boucle que vous
crivez. Elle vous permettra dviter une erreur trop frquente dans les copies que vous
menvoyez la correction et qui me peine car jai limpression que mon cours na pas t
assimil ou quil nest pas bien rdig.
Reprenons les remarques des deux exercices prcdents :
une boucle dont les instructions lintrieur ne modifient pas les constituants du
boolen est forcment fausse (voir blocs 1 et 4 de lexercice 7) ;
une boucle dont les instructions modifient les constituants du boolen peut tre
correcte (bloc 3 de lexercice 7, bloc 1 de lexercice 8) mais ce nest pas une certitude
(blocs 2 des exercices 7 et 8).
Voici donc la rgle de validation qui constitue une condition ncessaire (mais pas suffisante) la correction de la boucle.
Une boucle rpter ou tant que excute les instructions quelle contient jusqu ce
quun test soit ou non vrifi. La seule chose qui change entre deux valuations du
test, cest que le corps de la boucle a t excut.
Ainsi, pour avoir une chance que la boucle sarrte, les variables constituant le boolen du test doivent tre modifies par les instructions de la boucle. Si ce nest pas
le cas, le test est une constante vis--vis de la boucle et vaudra donc toujours vrai
ou faux (ce qui est une erreur).
5C.
Pour
Syntaxe
Les deux boucles prcdentes ralisaient un nombre ditrations variable. La boucle pour
est utile ds que lon connat le nombre ditrations raliser. Voici la syntaxe :
pour variable de entier1 entier2 pas entier3
instructions
fin pour
Dans la prcdente version de ce cours, je ne prsentais pas cette rgle de validation, les commentaires des exercices 7 et 8 me semblant suffisant. Mais aprs avoir retrouv cette erreur trs
frquemment dans vos copies, jai compris que je devais la formaliser dans le cours. Et la voil.
26
8 3987 TG PA 00
Lorsque entier3 vaut 1 (cest le cas gnral), on peut omettre la clause pas. Le principe
gnral est le suivant :
Variable est une variable entire appele lindice de la boucle. Lide est que lindice
va aller de entier1 entier2 en ajoutant entier3 chaque fois. chaque tape (itration), le corps de la boucle sera excut.
La progression de lindice
Il est facile de passer de 5 15 en ajoutant 1 : on passera par 5, 6, 7, 8 jusqu 15. Idem
pour passer de 0 3 en ajoutant 1 (soit en retranchant 1) : on passera par 0, 1, 2 puis
on atteindra 3.
Dune faon gnrale, si entier1 est infrieur entier2, entier3 doit tre positif. Si entier1
est suprieur entier2, entier3 doit tre ngatif. Sinon, la progression de entier2 entier1
est impossible.
1. Lindice de boucle est initialis entier1.
2. Tout dpend des indices :
2.1 [si entier1 < entier2 et donc entier3 > 0]
Si lindice de boucle est infrieur ou gal entier2,
alors les instructions incluses dans la boucle sont excutes.
sinon lexcution de la boucle est termine et on passe
linstruction suivant le pour.
2.2 [si entier1 > entier2 et donc entier3 < 0]
Si lindice de boucle est suprieur ou gal entier2,
alors les instructions incluses dans la boucle sont excutes.
sinon lexcution de la boucle est termine et on passe
linstruction suivant le pour.
3. On incrmente lindice de boucle de entier3 et on retourne ltape 2.
Notez bien que la troisime tape incrmentant lindice de entier3 fera :
augmenter lindice si entier3 est positif ;
diminuer lindice si entier3 est ngatif.
Lillustration suivante montre les instructions excutes. Dois-je rappeler que ce qui est
en couleur est ralis par lapplication de faon automatique ? (Cest la traduction du
pour.) Cela prouve que le pour est une instruction complexe qui travaille dans lombre.
Je prsente le cas habituel entier1 < entier2
Jai un ami qui a essay daller de 10 13 en ajoutant 1. Eh bien, il essaye toujours. (Sa sur
a voulu prendre le problme dans lautre sens et a tent daller de 13 10 en ajoutant 1. Et bien,
elle tente toujours.) Je ne les frquente plus, ils sont trop occups essayer pour lun et tenter
pour lautre.
27
8 3987 TG PA 00
Squence 1
ALGORITHME
instr_1
instr_2
pour indice de e1 e2 pas e3
instr_p_1
instr_p_2
instr_p_3
fin pour
instr_4
instr_5
TRACE DE LEXCUTION
instr_1
instr_2
indice := e1
indice e2 ?
non
oui
instr_p_1
instr_p_2
instr_p_3
indice := indice + e3
instr_4
instr_5
Exercice 9
Vous pensez avoir compris ? Dites-moi alors ce que vont afficher lcran ces deux blocs dinstructions (en expliquant videmment).
1er bloc
pour i de 1 10 pas 5
afficher i
fin pour
2e bloc
pour i de 10 1 pas -1
pour j de 10 1 pas -1
afficher i, "x", j, "=", i*j
fin pour
fin pour
Exercice 10
Que penser de linstruction suivante ?
pour i de 1 5
afficher i
i := i-1
fin pour
Cet exercice nous fournit la rgle de validation suivante :
Dans une boucle pour, linitialisation puis lincrmentation de lindice est gr par
lapplication. Il est donc interdit (et dailleurs sans intrt) de modifier dans le code
la valeur de lindice. Vous nutilisez cette variable quen lecture.
Si vous avez un super algorithme optimis qui vous conduit modifier la valeur de lindice, changez-le (lalgorithme, pas lindice). Nutilisez pas une boucle pour mais un tant
que ou un rpter.
Loptimisation du code nest pas un argument magique autorisant faire nimporte quoi.
Jaime le ct direct et sans complaisance de cette phrase. De plus, si vous respectez son
message, vous viterez beaucoup dneries.
28
8 3987 TG PA 00
Ainsi :
Exercice 11
Transformez la boucle suivante en boucle rpter puis en boucle tant que :
pour i de 1 10
afficher i
fin pour
La leon de cet exercice est la suivante :
Une boucle pour peut toujours tre crite sous la forme dun tant que ou dun rpter.
Mais cela oblige le dveloppeur grer lui-mme lindice. Cest moins lisible et
source derreur.
Ainsi, chaque fois que cest possible, on emploiera une boucle pour la place dun
tant que ou dun rpter.
Notez bien quil nest pas toujours possible demployer un pour. Nous dirons que cette
boucle existe pour simplifier les deux autres types de boucle dans des cas particuliers.
5D.
Conclusion sur les boucles

Concernant la boucle de lexercice 11 (quelle que soit sa version), nous dirons que :
lexcution de la boucle affiche les valeurs de 1 10 ;
une itration de la boucle affiche la valeur courante de lindice.
En formalisant, on obtient deux dfinitions.
Lexcution dune boucle regroupe tous les traitements qui sont raliss jusqu ce
que lexcution passe linstruction suivant la boucle.
Une itration dune boucle, cest une excution des instructions incluses dans la
boucle.
Ainsi, une excution de boucle, cest une itration, puis un test pour savoir si on continue ou pas, puis une itration, puis un test, puis une itration, puis un test, puis une
itration puis un test. (On sarrte toujours aprs un test qui dcide que linstruction
est termine.)
Voici une remarque base sur la conclusion de lexercice 10 mais sappliquant toutes les
boucles (pour, rpter et jusqu).
Dans le cas de boucles imbriques (lune est lintrieur de lautre), chaque itration
de la boucle externe entrane une excution complte de la boucle interne.
Si vous avez compris ces deux paragraphes apprendre, vous matrisez les boucles.
Les exercices qui suivent ne seront quune formalit.
29
8 3987 TG PA 00
Squence 1
Exercice 12
Appliquez lalgorithme suivant :
tant que vous navez pas compris
faites une pause (de une heure quelques jours)
recommencez ltude du paragraphe 5
fin tant que
Exercice 13
Supposons que jaie donn cet algorithme en dbut de paragraphe 5 et non la fin. Donnez
alors son code pour quil ait exactement le mme sens que celui de lexercice 12.
Attention, cest un vrai exercice, ce nest pas une nerie. Le code ne sera plus le mme.
Exercice 14
Et si je vous disais que, quel que soit votre degr de comprhension, il faut lire le paragraphe
5 cinq fois pour bien sen imprgner, quel algorithme obtiendriez-vous ?
Exercice 15
En fait, la vie nest pas simple. Travailler raisonnablement, cest faire preuve de srieux mais
pas dacharnement. Nous dirons donc que vous devez lire le paragraphe 5 au maximum 5 fois.
Ds que vous lavez compris, vous passez la suite du cours et si, au bout de 5 lectures, ce
nest toujours pas clair, vous devez quand mme passer la suite.
Si ce conseil vous est donn en fin de paragraphe 5, quel est lalgorithme correspondant ?
[Passez du temps sur cet exercice.]
6.
Application
Nous allons mettre tout ce savoir (boucles, alternative et variables) en pratique.
Exercice 16
Je vous demande dcrire un algorithme affichant les heures et minutes de 00:00 (minuit)
23:59. Je veux donc : 00:00, 00:01, 00:02 23:58, 23:59.
Attention, il y a une petite difficult pas vidente voir !
30
8 3987 TG PA 00
Synthse
Syntaxe gnrale dun algorithme

(Sans sous-programme pour le moment.)
Algo nom de lalgorithme
var
dclaration des variables
dbut
instructions
fin
Un commentaire est prcd par des caractres // (deux barres de division). Dit
autrement, tout ce qui suit les deux barres est ignor par le compilateur.
Le commentaire doit tre clair, concis, sans ambigut et nexpliquer que ce qui
doit ltre. Ce nest pas une fioriture mais une plus-value votre code.
Les variables
Quelques dfinitions
Type
Le type dune variable dcrit sa nature, ce quelle contient (entier, boolen,
rel, caractre).
Variable
Cest un espace mmoire contenant une valeur dun type donn.
Dclaration
La dclaration dune variable contient un nom de variable explicite (qui a un
sens pour le dveloppeur) et un type. Elle entrane la rservation dun espace
mmoire de taille suffisante (fonction du type) pour y stocker la valeur. Le
nom de la variable est associ lespace mmoire.
Manipulation
Saisie
saisir chane, variable
Fonctionnement
1. La chane de caractres chane est affiche lcran.
2. Lapplication attend que lutilisateur rentre (saisisse au clavier) quelque chose.
3. La valeur saisie est affecte la variable (valeur et variable doivent tre de
mme type).
31
8 3987 TG PA 00
Affectation
variable := expression
Fonctionnement
1. Lexpression est value (calcule).
2. Le rsultat est affect la variable (lancienne valeur de la variable est perdue car remplace par la nouvelle). Lexpression et la variable doivent tre
de mme type.
Affichage
Afficher expression1, expression2, expressionn
Chaque expression est successivement value puis son rsultat est affich.
Alternative
si boolen
alors
instructions_oui
sinon
instructions_non
fin si
si boolen
alors
instructions_oui
fin si

2. En fonction de la valeur obtenue :
2.1. Si elle vaut vrai, les instructions de la branche alors sont excutes puis
lexcution passe linstruction suivant le si (lventuelle branche sinon
est ignore).
2.2. Si elle vaut faux, les instructions de la branche sinon sont excutes
(sil y en a) puis lexcution passe linstruction suivant le si (la branche
alors est ignore).
Si le boolen est vrai, alors on excute les instructions du alors et sinon on
excute celles du sinon.
Boucles
Tant que
instructions
fin tant que
1. Le boolen est valu.
2. Si sa valeur est vrai, les instructions incluses dans la boucle sont excutes
et lon retourne la premire tape. Sinon, on passe linstruction suivant
le tant que.
32
8 3987 TG PA 00
Tant que le boolen est vrai, on excute les instructions dans la boucle.
Rpter
rpter
instructions
jusqu boolen
1. Les instructions incluses dans la boucle sont excutes.
2. Le boolen est valu. Sil est faux, on retourne la premire tape. Sinon,
on passe linstruction suivant le rpter.
On rpte les instructions jusqu ce que le boolen soit vrai.
Comparaisons tant que et rpter
TANT QUE ... FAIRE
test du boolen
la 1re excution de la boucle

nombre ditrations (dexcutions
des instructions de la boucle)
on sort de la boucle quand le
boolen est
REPETER ... JUSQU'A
avant
aprs
faux
vrai
Une boucle rpter ou tant que excute les instructions quelle contient jusqu ce
quun test soit ou non vrifi. La seule chose qui change entre deux valuations du
test, cest que le corps de la boucle a t excut.
Ainsi, pour avoir une chance que la boucle sarrte, les variables constituant le
boolen du test doivent tre modifies par les instructions de la boucle. Si ce nest
pas le cas, le test est une constante vis--vis de la boucle et vaudra donc toujours
vrai ou faux (ce qui est une erreur).
Pour
pour variable de entier1 entier2 pas entier3
instructions
fin pour
Variable est une variable entire appele lindice de la boucle. Lide est que lindice va aller de entier1 entier2 en ajoutant entier3 chaque fois. chaque tape
(itration), le corps de la boucle sera excut.
1. Lindice de boucle est initialis entier1.
2. Tout dpend des indices :
2.1 [si entier1 < entier2 et donc entier3 > 0]
Si lindice de boucle est infrieur ou gal entier2,
alors les instructions incluses dans la boucle sont excutes
sinon lexcution de la boucle est termine et on passe linstruction
suivant le pour.
33
8 3987 TG PA 00
2.2 [si entier1 > entier2 et donc entier3 < 0]

Si lindice de boucle est suprieur ou gal entier2,
alors les instructions incluses dans la boucle sont excutes
sinon lexcution de la boucle est termine et on passe linstruction
suivant le pour.
3. On incrmente lindice de boucle de entier3 et on retourne ltape 2.
Dans une boucle pour, linitialisation puis lincrmentation de lindice est gr
par lapplication. Il est donc interdit (et dailleurs sans intrt) de modifier dans
le code la valeur de lindice. Vous nutilisez cette variable quen lecture.
Une boucle pour peut toujours tre crite sous la forme dun tant que ou dun
rpter. Mais cela oblige le dveloppeur grer lui-mme lindice. Cest moins
lisible et source derreur. Ainsi, chaque fois que cest possible, on emploiera une
boucle pour la place dun tant que ou dun rpter.
Quelques remarques sur les boucles
Lexcution dune boucle regroupe tous les traitements qui sont raliss jusqu
ce que lexcution passe linstruction suivant la boucle.
Une itration dune boucle, cest une excution des instructions incluses dans la
boucle.
Dans le cas de boucles imbriques (lune est lintrieur de lautre), chaque itration de la boucle externe entrane une excution complte de la boucle interne.
Aphorisme
34
8 3987 TG PA 00
Squence 2
Procdures et fonctions
Dans cette squence, nous terminons ltude des lments cls de la premire anne.
Capacits attendues
Se souvenir du cours de lanne dernire
Avec le recul, matriser ces concepts
Contenu
1.
Introduction ............................................................................................ 36
1A.
1B.
1C.
Dfinition .................................................................................................... 36
Dfinition du sous-programme ................................................................. 36
Intrt .......................................................................................................... 36
2.
Les procdures et les fonctions ...................................................... 36
2A.
2B.
Dfinitions .................................................................................................. 36
Syntaxe ....................................................................................................... 37
3.
Les paramtres ...................................................................................... 40
3A.
3B.
3C.
3D.
Syntaxe ....................................................................................................... 40
Mode de passage ....................................................................................... 41
Corrigeons lexercice .................................................................................. 42
Une fonction est une procdure qui signore .......................................... 46
Synthse
35
8 3987 TG PA 00
Squence 2
1.
Introduction
1A.
Dfinition
Les sous-programmes ne constituent pas des notions complexes. Pourtant, les tudiants
font souvent des erreurs assez grossires. Nous allons tenter dviter cela en reprenant
quelques concepts essentiels.
Il existe deux types de sous-programmes : les procdures et les fonctions.
1B.
Dfinition du sous-programme
Un sous-programme est un ensemble dinstructions ralisant quelque chose de prcis.
Tiens, cela ressemble fort la dfinition dun programme ! Et bien oui.
La diffrence essentielle entre un sous-programme et un programme, cest que :
le programme communique avec lutilisateur qui fournit les donnes en entre du
programme et rcupre les donnes en sortie ;
le sous-programme communique avec le programme : cest le programme qui
fournit les donnes en entre et qui rcupre et exploite les rsultats du sous-programme.
Tout langage de programmation possde de nombreux sous-programmes intgrs que
vous utilisez sans vous en rendre compte. Par exemple ? Et bien afficher, saisir, sin (la
fonction sinus), random (la fonction alatoire)
1C.
Intrt
La grande force des langages de programmation, cest que lutilisateur peut crire ses
propres sous-programmes. Cest utile pour plusieurs raisons :
lorsque vous excutez plusieurs fois la mme suite dinstructions, soit vous les crivez plusieurs fois, soit, et cest prfrable, vous crivez une seule fois le sous-programme correspondant et vous lappelez autant de fois que ncessaire ;
lorsque vous crivez une application, il est plus simple de diviser le travail en petites
tches autonomes (sous-programmes) car vous divisez la difficult ;
un sous-programme est autonome vis--vis de lapplication. Vous pouvez le copier/
coller dans un autre programme si vous en avez besoin. Cest la rutilisation du
code que nous reverrons avec la programmation objet (option dveloppeur dapplications).
2.
Les procdures et les fonctions
2A.
Dfinitions
On utilisera une fonction lorsque le sous-programme renvoie un seul rsultat. Dans
le cas contraire (il renvoie aucun ou plusieurs rsultats), il faut une procdure.
Quand je parle de rsultat, cest au sens large. Ce peut tre un paramtre en entre qui est
modifi. Par exemple, jenvoie un tableau au sous-programme qui me le retourne tri.
De mme que la boucle pour est un cas particulier de boucle tant que (tout pour peut
scrire sous la forme dun tant que), la fonction est un cas particulier de procdure. Nous
le vrifierons dans le paragraphe 3D.
36
8 3987 TG PA 00
Procdures et fonction
Mais, ds prsent, nous retiendrons :

Toute fonction peut scrire sous la forme dune procdure.
La fonction est donc un concept redondant. Mais alors, pourquoi lavoir cr ? Pour la
mme raison que le pour existe : cest trs pratique. Cela dit, parfois, on doit sen passer
comme lexplique le paragraphe qui suit.
En pratique (avec un langage de programmation et non plus un algorithme), on peut
se trouver face des limitations techniques : la majorit des langages nacceptent
comme rsultat de fonction que des types de base (entier, boolen, chane, caractre). Ainsi, mme si dun point de vue algorithmique il est correct de vouloir faire
une fonction, vous devrez parfois la coder sous la forme dune procdure.
La fonction est une analogie de la fonction mathmatique.
2B.
Syntaxe
2B1. Introduction
Rsumons ce qui prcde :
Un sous-programme ralise une tche prcise, il prend des valeurs en entre et
retourne aucun rsultat (procdure), un seul (fonction) ou plusieurs (procdure). Un
sous-programme doit tre autonome (donc doit pouvoir tre utilis dans un programme par simple copier/coller). Un sous-programme est constitu dinstructions.
Pour raliser cela, chaque sous-programme devra possder :
un nom permettant de lappeler lorsque lon souhaite sen servir ;
la description des donnes en entre et en sortie (les paramtres) ;
les instructions ralisant le traitement du sous-programme ;
les variables locales au sous-programme.
Nous allons voir comment traduire cela sous la forme de procdure ou de fonction. Pour
le moment, on ne dtaille pas les paramtres.
2B2. La procdure
Voici la syntaxe :
procdure nom (paramtres)
var
dclarations
dbut
instruction1
...
instructionn
fin
Comment utiliser la procdure dans un programme ? On lappelle par son nom comme
on le ferait avec une instruction.
37
8 3987 TG PA 00
Squence 2
2B3. La fonction
Voici la syntaxe :
fonction nom (paramtres) : type
var
dclarations
dbut
instruction1
...
instructionn
Retourner (expression) // Retour du rsultat
fin
Rappelez-vous que la fonction renvoie toujours un rsultat. Cest pourquoi :
la fin de len-tte (ligne contenant le mot-cl fonction), on indique le type du
rsultat ;
il faut explicitement indiquer quel est le rsultat renvoy par la fonction. Je choisis
la convention de linstruction Retourner dont le paramtre contient le rsultat.
Dans ce cas, excuter Retourner termine la fonction (il est donc sans objet de mettre
des instructions derrire).
Il est classique doublier de renvoyer le rsultat (ici, cela revient oublier dappeler
Retourner). Dans ce cas, la fonction renvoie un rsultat indtermin (alatoire). Cest
vraiment une erreur bte mais classique (mais bte). Comme je lai trop souvent vue dans
vos copies, je rajoute en rgle de validation :
Une fonction renvoyant toujours un rsultat, son code comprend toujours le type du
rsultat dans len-tte et se termine toujours par un appel linstruction Retourner
pour renvoyer un rsultat prcis.
Comment utiliser une fonction ? On lappelle par son nom mais ce nest pas une instruction. Par exemple, sin(8) est un nombre, pas une instruction. On utilisera donc une fonction renvoyant une valeur dun type donn la place dune expression de mme type.
Je reviens sur le prt--apprendre prcdent. Lorsque je dis que la fonction doit se terminer par un appel Retourner, cela signifie que toute excution de la fonction, quelles
que soient les instructions excutes (cela dpend des tests) doit se terminer par un
Retourner.
Pour comprendre cela, prenons lexemple de Nom1 et Nom2 :
fonction Nom2 (paramtres) : type
fonction Nom1 (paramtres) : type
dbut
instruction1
...
instructionn
Retourner (expression)
fin
dbut
si boolen
alors
instruction1
sinon
instruction2
fin si
fin
38
8 3987 TG PA 00
Dans les deux cas, Retourner est la dernire instruction excute donc tout va bien : les
fonctions renvoient toujours un rsultat.
Prenons maintenant lexemple de Nom3 et Nom4 :
01 fonction Nom3 (paramtres) : type

02
03 dbut
04 si boolen
05
alors
06
instruction1
07
sinon
08
instruction2
09
10 fin si
11 fin
01 fonction Nom4 (paramtres) : type

02
03 dbut
04 si boolen
05
alors
06
si boolen2
07
alors
08
instruction1
09
10
sinon
11
12
fin si
13
sinon
14
instruction2
15 fin si
16 fin
Les deux fonctions sont incorrectes :

la branche alors de Nom3 ne contient pas dinstruction Retourner. Ainsi, si le test
est vrai, on nexcutera que la ligne 6 (instruction1) et cest tout, la fonction ne
retournera aucun rsultat ;
de mme, dans Nom4, la branche sinon (ligne 14) du si externe (le premier, des
lignes 4 15) ne contient pas de Retourner, donc dans ce cas, la fonction ne renvoie
rien. Comme Nom4 est relativement complexe, nous allons envisager tous ses cas
dexcution.
La fonction est constitue dune instruction si ligne 4. Si son boolen est :
vrai, on excute la partie alors, soit le si des lignes 6 12. Si le test ligne 6 est :
vrai, on excute la branche alors, soit les lignes 8 et 9. Cette dernire instruction
est Retourner donc tout va bien ;
faux, on excute la branche sinon, soit la ligne 11 qui est linstruction Retourner
donc tout va bien ;
faux, on excute la partie sinon, soit linstruction ligne 14 et cest tout. Aucun
Retourner nest excut donc la fonction ne renvoie rien dans ce cas, cest une
erreur.
Ltude de Nom3 et Nom4 tait relativement vidente car javais des structures vides.
Dans le cas dune vraie fonction, plus longue et contenant plus dalternatives dpendant
des paramtres, la vrification est beaucoup moins simple. Cest pourquoi je reois rgulirement des copies contenant des fonctions ne renvoyant rien ; comme cela me peine,
je vous demande dapprendre ce qui suit.
Une fonction contient gnralement des tests et des boucles qui peuvent entraner
une excution complexe. On ne sait donc pas immdiatement quelles instructions
seront excutes et lesquelles seront ignores ; cela dpendra des tests dans les
alternatives et les boucles.
39
8 3987 TG PA 00
Squence 2
Comme une fonction renvoie toujours un rsultat, il faut sassurer que, quels que
soient les paramtres, la dernire instruction excute est toujours Retourner.
2B4. Smantique des sous-programmes

Je reprends ce qui prcde car cest important.
Une procdure est une instruction, une fonction est une expression du mme type
que son rsultat.
Ainsi :
partout o vous mettez une instruction, vous pouvez mettre lappel une procdure ;
partout o vous mettez un boolen (exemple : dans un test ou une boucle), vous
pouvez mettre lappel une fonction renvoyant un boolen, partout o vous mettez un entier, vous pouvez mettre lappel une fonction renvoyant un entier ;
plus gnralement, partout o vous mettez une expression dun type T, vous
pouvez mettre lappel dune fonction renvoyant une valeur de type T.
3.
Les paramtres
Cela terminera ltude des sous-programmes. Attention, cest encore une notion trs
importante.
3A.
Syntaxe
Nous avons vu que les sous-programmes possdaient des paramtres. Ce sont les donnes qui entrent et sortent du sous-programme.
La syntaxe sera simple : on indique le nom de chaque paramtre suivi dun : et de son
type. On retrouve lobligation dassocier toute donne un type. Les paramtres sont
spars par une virgule.
Exemples :
procdure change (a : entier, b : entier)
dbut
fin
fonction Maximum (n1 : rel, n2 : rel) : rel

dbut
Retourner ()
fin
Je voudrais attirer votre attention sur un point trs important.

Nous avons dj vu quun sous-programme formait un ensemble cohrent et indpendant de tout programme. Ainsi, le nom des paramtres est tout fait arbitraire
et na aucun lien avec les variables du programme.
40
8 3987 TG PA 00
Si lon nomme les paramtres, cest pour pouvoir y faire rfrence dans le corps du sousprogramme. Le nom est juste une tiquette napportant aucune smantique lapplication. (Mais cest utile pour le dveloppeur. Dire Paramtre1 est moins explicite que ge.)
Pour tre certain que vous en tes conscient, je vous conseille de mettre systmatiquement des noms diffrents aux paramtres et aux variables.
3B.
Mode de passage
On distingue deux modes de passage de paramtre.
Le passage par valeur :
Mme si la valeur du paramtre change dans le sous-programme, la variable correspondante dans le programme principal reste inchange. Le paramtre est une variable locale au sous-programme initialise avec la valeur de la variable du programme.
Le passage par adresse :
Si la valeur du paramtre change dans le sous-programme, la variable correspondante est modifie dans le programme principal. Le paramtre est la mme
adresse mmoire que la variable du programme ; concrtement, le paramtre est
la variable.
Le passage par valeur est le mode par dfaut. Pour passer un paramtre par adresse,
on met le mot var devant.
Exemple :
procdure Retraite (ge : entier, var DateRetraite : entier, var MontantPension : entier)
ge est pass par valeur, DateRetraite et MontantPension par adresse.
Vous allez faire un petit exercice pour fixer tout cela.
41
8 3987 TG PA 00
Squence 2
Exercice 17
Envisageons lalgorithme suivant :
Algorithme change
var
e1, e2 : entier
var
c : entier
dbut
c := a
a := b
b := c
fin
dbut
saisir "Entrez le premier nombre ", e1
saisir "Entrez le second nombre ", e2
afficher "Vos nombres dans lordre : ", e1, " et ", e2
change (e1, e2)
afficher "Vos nombres permuts :", e1, " et ", e2
fin
Indiquez comment sont passs les deux paramtres dans la procdure change : par valeur ou
par adresse ? Donnez et expliquez laffichage ralis par le programme quand on lexcute.
Modifiez le mode de passage (qui doit devenir par adresse si lon tait par valeur ou linverse)
puis donnez nouveau laffichage du programme.
3C.
Corrigeons lexercice
Pour voir la diffrence entre les deux modes de passage, nous allons tudier la mmoire tout
au long du droulement du programme en reprenant le formalisme de la squence 1, paragraphe 3D. On supposera que les entiers occupent deux octets (ce sont donc des mots).
Pour allger lcriture, les zones mmoire dont je ne me sers pas seront vides. Je vous rappelle quen vrai, elles contiennent des valeurs alatoire qui ne me concernent pas.
Voici donc ltat de la mmoire avant cration des variables.
VARIABLE

TYPE
ADRESSE DBUT
tat de la mmoire
D
E
F
G
1
2
3
4
Jinsiste : du point de vue du programme qui sexcute, la mmoire est vide.
42
8 3987 TG PA 00
Quel que soit le mode de passage des paramtres, le programme dbute de la mme
faon. Les deux variables globales sont cres. Elles ne sont pas encore initialises donc
leur contenu est indtermin pour le programme. Cela donne :
VARIABLE
TYPE
ADRESSE DBUT
e1
entier
a1
e2
entier
f1
A
1
2
3
4
B
???
tat de la mmoire
C
D
E
F
G
???
(Ici et dans les tableaux suivants, les changements dans ltat de la mmoire sont en gras.)
On excute les deux saisies. Lutilisateur rentre 50 et 100. La mmoire est alors :
VARIABLE
e1
e2

TYPE
ADRESSE DBUT
entier
a1
entier
f1
A
1
2
3
4
50
tat de la mmoire
D
E
F
G
100
Lapplication affiche :
Vos nombres dans lordre : 50 et 100
Nous appelons ensuite la procdure change. Et l, il y a deux cas.
3C1. Premier cas : passage par valeur

Comme nous avons un passage par valeur, les paramtres vont tre des variables nouvelles et temporaires initialises avec la valeur des variables appelantes (soit a initialis
par e1 et b par e2).
Ltat de la mmoire est alors le suivant.
VARIABLE
e1
e2
a
b

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
c3
entier
g4
A
1
2
3
4
50
tat de la mmoire
D
E
F
G
100
50
100
Il est vident que modifier a ou b nentrane aucune modification de e1 ou e2 puisque ce

sont des variables physiquement diffrentes. De la mme faon, lorsque vous lavez votre
voiture la mienne reste sale.
Nous arrivons dans la procdure. La variable locale c est cre.
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
c3
entier
g4
entier
c5
A
1
2
3
4
5
B
50
tat de la mmoire
D
E
F
G
100
50
100
???
43
8 3987 TG PA 00
Squence 2
On ralise laffectation c := a :
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
c3
entier
g4
entier
c5
A
1
2
3
4
5
50
tat de la mmoire
D
E
F
G
100
50
100
50
Puis a := b :
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
c3
entier
g4
entier
c5
A
1
2
3
4
5
50
tat de la mmoire
D
E
F
G
100
100
100
50
Enfin b := c :
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
c3
entier
g4
entier
c5
A
1
2
3
4
5
50
tat de la mmoire
D
E
F
G
100
100
50
50
La procdure est termine. Que se passe-t-il alors ? Et bien, les variables temporaires (ici c) et
les paramtres (ici, a et b) sont supprims comme le montre ltat de la mmoire suivant.
VARIABLE
e1
e2

TYPE
ADRESSE DBUT
entier
a1
entier
f1
A
1
2
3
4
B
50
tat de la mmoire
D
E
F
G
100
On revient dans le programme principal et on affiche alors :

Vos nombres permuts : 50 et 100.
Bref, les valeurs de e1 et e2 nont pas chang.
3C2. Second cas : passage par adresse

procdure change (var a : entier, var b : entier)
Comme nous avons un passage par adresse, les paramtres vont tre la mme adresse
mmoire que les variables appelantes. On utilise alors le mme espace mmoire appel
par deux noms diffrents.
44
8 3987 TG PA 00
Ltat de la mmoire est le suivant.

VARIABLE
TYPE
ADRESSE DBUT
e1
entier
a1
e2
entier
f1
a
entier
a1
b
entier
f1
A
1
2
3
4
B
50
tat de la mmoire
C
D
E
F
G
100
Il est vident que modifier a revient modifier e1 (et modifier b, cest modifier e2).
De la mme faon, si mon frre lave la voiture de son frre, la mienne devient propre
(cela fonctionne car je nai quun frre).
Nous arrivons dans la procdure. La variable locale c est cre.
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
a1
entier
f1
entier
c3
A
1
2
3
4
5
50
tat de la mmoire
D
E
F
G
100
???
On ralise laffectation c := a :
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
a1
entier
f1
entier
c3
A
1
2
3
4
5
50
tat de la mmoire
D
E
F
G
100
50
Puis a := b :
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
a1
entier
f1
entier
c3
A
1
2
3
4
5
100
tat de la mmoire
D
E
F
G
100
50
Puis b := c :
VARIABLE
e1
e2
a
b
c

TYPE
ADRESSE DBUT
entier
a1
entier
f1
entier
a1
entier
f1
entier
c3
A
1
2
3
4
5
B
100
tat de la mmoire
D
E
F
G
50
50
45
8 3987 TG PA 00
Squence 2
La procdure est termine. Que se passe-t-il alors ? Eh bien, les variables temporaires (ici c) et
les paramtres (ici, a et b) sont supprimes comme le montre ltat de la mmoire suivant.
VARIABLE
e1
e2

TYPE
ADRESSE DBUT
entier
a1
entier
f1
A
1
2
B
100
tat de la mmoire
D
E
F
G
50
On revient dans le programme principal et on affiche alors :

Vos nombres permuts : 100 et 50
Bref, les valeurs de e1 et e2 ont t modifies.
Exercice 18
crivez un algorithme ralisant la saisie de deux nombres et affichant le plus grand. Il devra
contenir et utiliser un sous-programme renvoyant le plus grand de deux nombres. Attention
aux modes de passage des paramtres.
Exercice 19
crivez un algorithme calculant la remise, le port et le net payer (qui vaut montant facture
remise + port) associs une commande, sachant que :
la remise totale est de 5 % partir de trois articles achets, 10 % ds cinq et 15 % pour
huit ou plus ;
le port est de 7,7 pour une commande de moins de 77 (remise comprise), 4 de 77
150 et gratuit au-del.
Lexercice est simple. Je ne vous demande donc pas de faire juste le programme, mais de
rflchir trs srieusement aux donnes ncessaires et aux sous-programmes. Je vous demande
notamment de faire un sous-programme pour calculer la remise et un autre pour le port.
La conclusion de lexercice mrite dtre apprise. Dailleurs, nous lavions dj vu en fin
de paragraphe 2B3. Retournez-donc le lire !
3D.
Une fonction est une procdure qui signore

Jai divis les sous-programmes en deux clans (les procdures et les fonctions) en prcisant que ctait une erreur grave demployer lun pour lautre.
Ce discours, je lavais dj eu avec les boucles, tout en vous montrant quune boucle pour
pouvait scrire sous la forme dun tant que.
Eh bien, toute fonction peut scrire sous la forme dune procdure. Le rsultat de la
fonction devient alors un paramtre pass par adresse dans la procdure.
Exercice 20
Prenons une petite fonction toute simple : Minimum, qui renvoie le minimum de deux nombres entiers. crivez cette fonction ainsi quune instruction faisant appel elle.
Dans un second temps, recommencez sous la forme dune procdure Minimum.
46
8 3987 TG PA 00
Exercice 21
Gnralisons : prenez la syntaxe gnrale dune fonction (voir paragraphe 2B3) et transformez-la en procdure.
Corrigeons cela. Voici une fonction :
var
dclarations
dbut
instruction1
...
instructionn
fin
Pour la transformer en procdure, il suffit de rajouter un paramtre pass par adresse et
contenant le rsultat de feue la fonction. Ainsi, partout o dans la fonction on mettait
Retourner (xxx), on remplacera par Param := xxx, Param tant le nouveau paramtre.
Comme dans lexercice prcdent, mon nouveau paramtre sappellera Rsultat pour
simplifier.
Cela donne (en gras ce qui est important) :
procdure nom (paramtres, var Rsultat : type)
var
dclarations
dbut
instruction1
...
instructionn
Rsultat := expression
fin
Jinsiste sur le fait que cette transformation ne signifie pas que vous deviez dornavant
vous passer de fonction. Je vous ai propos ces exercices pour vous aider bien assimiler
les paramtres et les sous-programmes.
Mais, partout o lon peut crire une fonction, on crit une fonction !
Vous pouvez, ds maintenant, faire et envoyer la correction le devoir 1 (voir fascicule

Devoirs rf, 3987 DG).
47
8 3987 TG PA 00
Synthse
Sous-programme
Rle et constitution des sous-programmes :
un sous-programme ralise une tche prcise ;
il prend des valeurs en entre et retourne aucun rsultat (procdure), un
seul (fonction) ou plusieurs (procdure) ;
un sous-programme doit tre autonome (donc pouvoir tre utilis dans un
programme par simple copier/coller) ;
un sous-programme est constitu dinstructions.
On utilisera une fonction lorsque le sous-programme renvoie un seul rsultat. Dans
le cas contraire (il renvoie aucun ou plusieurs rsultats), il faut une procdure.
Toute fonction peut scrire sous la forme dune procdure. En pratique (avec
un langage de programmation et non plus un algorithme), on peut se trouver
face des limitations techniques : la majorit des langages nacceptent comme
rsultat de fonction que des types de base (entier, boolen, chane, caractre).
Ainsi, mme si dun point de vue algorithmique il est correct de vouloir faire une
fonction, vous devrez parfois la coder sous la forme dune procdure.
Une procdure est une instruction, une fonction est une expression du mme
type que son rsultat. Ainsi :
partout o vous mettez une instruction, vous pouvez mettre lappel une
procdure ;
partout o vous mettez un boolen (exemple : dans un test ou une boucle),
vous pouvez mettre lappel une fonction renvoyant un boolen ;
partout o vous mettez un entier, vous pouvez mettre lappel une fonction
renvoyant un entier ;
plus gnralement, partout o vous mettez une expression dun type T, vous
pouvez mettre lappel dune fonction renvoyant une valeur de type T.
Procdure
Syntaxe de la procdure :
procdure nom (paramtres)
var
dclarations
dbut
instruction1
...
instructionn
fin
49
8 3987 TG PA 00
Squence 2
Fonction
Syntaxe de la fonction
var
dclarations
dbut
instruction1
...
instructionn
Retourner : (expression)
fin
Une fonction renvoyant toujours un rsultat, son code :
comprend toujours le type du rsultat dans len-tte ;
se termine toujours par un appel linstruction Retourner pour renvoyer un
rsultat prcis (fourni en paramtre de linstruction).
Une fonction contient gnralement des tests et des boucles qui peuvent entraner une excution complexe. On ne sait donc pas immdiatement quelles instructions seront excutes et lesquelles seront ignores ; cela dpendra des tests dans
les alternatives et les boucles.
Comme une fonction renvoie toujours un rsultat, il faut sassurer que, quels que
soient les paramtres, la dernire instruction excute est toujours Retourner.
Paramtres
Nous avons dj vu quun sous-programme formait un ensemble cohrent et indpendant de tout programme. Ainsi, le nom des paramtres est tout fait arbitraire
et na aucun lien avec les variables du programme.
Pour tre certain que vous en tes conscient, je vous conseille de mettre systmatiquement des noms diffrents aux paramtres et aux variables.
On distingue deux types de passage de paramtre :
le passage par valeur : mme si la valeur du paramtre change dans le sous-programme, la variable correspondante dans le programme principal reste inchange. Le paramtre est une variable locale au sous-programme initialise avec la
valeur de la variable du programme ;
le passage par adresse : si la valeur du paramtre change dans le sousprogramme, la variable correspondante est modifie dans le programme
principal. Le paramtre est la mme adresse mmoire que la variable du
programme ; concrtement, le paramtre est la variable.
Le passage par valeur est le mode par dfaut. Pour passer un paramtre par
adresse, on met le mot var devant.
Remarque
Je ne la reprends pas ici, mais jaimerais bien que vous reteniez la faon dont sont
implants les deux modes de passage de paramtres (nous lavons vu dans le paragraphe 3C). Cela vous sera utile pour votre apprentissage.
50
8 3987 TG PA 00
Squence 3
Tableaux, structures et types

Nous allons terminer les rappels de premire anne en tudiant les tableaux. Nous
introduirons ensuite les types de donnes dfinis par lutilisateur, les structures et
les tableaux de structures.
Capacits attendues
Savoir dfinir ses propres types de donnes
Contenu
1.
Introduction ............................................................................................ 52
2.
Les tableaux ........................................................................................... 53
2A.
2B.
2C.
2D.
2E.
2F.
Smantique ................................................................................................. 53
Syntaxe ....................................................................................................... 54
Remarque sur lindice ................................................................................ 58
Tableau, lment et indice ........................................................................ 59
Gestion mmoire ........................................................................................ 61
Indice et contenu ........................................................................................ 65
3.
Dfinir ses propres types .................................................................. 65
3A.
3B.
3C.
3D.
3E.
Introduction ................................................................................................ 65
Syntaxe de la dfinition ............................................................................ 67
Intrt des dfinitions de type ................................................................. 67
Les types structurs ................................................................................... 67
Quand utiliser une structure ? .................................................................. 70
4.
Allons plus loin avec les structures ............................................... 70
4A.
4B.
4C.
4D
Introduction ................................................................................................ 70
Structure contenant un tableau ................................................................ 70
Tableau contenant une structure .............................................................. 74
Ce qui est venir ....................................................................................... 75
Synthse
51
8 3987 TG PA 00
Squence 3
1.
Introduction
Dans un premier temps, nous allons rviser les notions relatives aux tableaux.
Dans un second temps, nous dcouvrirons des notions nouvelles. Nous apprendrons
notamment dfinir nos propres types de donnes (oui, je dis bien type !).
Dfinir un type est trs simple, il suffit de lcrire. Lintrt, cest de dfinir un type structur (nous ltudierons finement).
Enfin, nous mlangerons les deux notions de la squence pour faire des tableaux de
structures, des structures de tableaux, des structures de tableaux de tableaux de structures de tableaux
Cette squence est trs importante pour les deux options :
cest la dernire squence pour loption administrateur de rseaux. Les concepts
abords sont les plus importants du cours car ce sont les plus pointus. De plus, la
manipulation de tableaux de structures est un sujet dexamen classique. Cela ne
pose pas de difficult si lon matrise bien les notions, mais, si lon est fragile, cest
redoutable ;
pour les tudiants de loption dveloppeur dapplications, cette squence est une
charnire entre les concepts de base et avancs (pointeurs et objets). Les types
structurs sont trs importants car ils apportent une partie de la syntaxe et du formalisme utiliss en programmation objet.
Raison pour laquelle cest en effet un bon thme dexamen : lalgorithme crire est court, mais
ne se devine pas.
Je suis certain que les administrateurs rseau qui ont lu ce paragraphe regrettent de ne pas avoir
choisi lautre option. (Dailleurs, pour lire un paragraphe consacr aux dveloppeurs, il faut dj
avoir des doutes sur son orientation, non ?)
52
8 3987 TG PA 00
2.
Les tableaux
2A.
Smantique
2A1. Quest-ce quun tableau ?
Un tableau est avant tout une variable. ce titre, il possde un nom, un type et une
valeur. Cela dit, un tableau est une variable complexe. (La notion de variable complexe
est une invention didactique de ma part. Ne lemployez donc pas sans explication dans
un examen.)
Attention, je nutilise pas complexe dans le sens difficile mais dans le sens qui contient
plusieurs lments.
Ainsi, joppose :
les variables simples (classiques) qui nont quune valeur. Il sagit des variables entires, boolennes et de type caractre, chane
les variables complexes, qui sont des variables contenant plusieurs variables. Par
cohrence, nous dirons quen tant que variable, elles ne possdent quune valeur
(la leur), mais que cette valeur est dcomposable en plusieurs valeurs. Il sagit des
tableaux et des structures.
Le tableau est une variable complexe dans la mesure o :
un tableau dentiers contient plusieurs variables entires ;
un tableau de caractres contient plusieurs variables caractres
On ne parlera donc pas de tableau (tout court), mais de tableau de quelque chose,
sous-entendu de tableau contenant des lments dun type donn . Un tableau ne
peut contenir que des lments de mme type.
Mlanger des entiers et des caractres dans un tableau est donc interdit. Pourquoi ? Cela
vient de la nature du tableau que nous abordons maintenant.
2A2. Que contient un tableau ?

Dj, un peu de vocabulaire. (Attention, chaque mot compte ici.)
Un tableau est un ensemble de variables de mme type. Chacune de ces variables
est un lment du tableau. Au sein dun tableau, chaque lment est identifi par
un numro entier appel indice.
Ainsi, au lieu de dfinir un tableau de dix entiers, je peux trs bien dfinir les variables entires a, b, c, d, e, f, g, h, i et j ou Nina, Pollen, Flocon, Alf, Neko, PetiteChose1,
PetiteChose2, Bipsie, Zo et Dmon.
Et je fais bien, car cette acception hlas frquente est abusive.

Cela permettra daffecter ou de comparer tableaux et structures en une seule instruction : on
pourra crire si a=b alors que a et b soient des entiers, des tableaux, des chanes, des structures La seule contrainte est toujours que, quel que soit le type de a et b, ce doit tre le mme
pour les deux.
Pour les dveloppeurs : la programmation objet nous permettra de lever cette contrainte en distinguant des types statiques et dynamiques.
53
8 3987 TG PA 00
Squence 3
Que mapporte la dfinition dun tableau vis--vis de variables indpendantes ? Deux

choses :
la simplicit de la dclaration. Chaque variable indpendante doit tre explicitement dclare, tandis que la dclaration dun tableau se fait en une fois, quel que
soit son nombre dlments ;
luniformisation : les variables indpendantes sont identifies par un nom, tandis que
celles dun tableau ne sont identifies que par un numro (indice) au sein du tableau.
Ainsi, je parlerai de la variable PrixTTC et de llment numro 4 du tableau t.
Attention ne pas en faire trop, ces deux caractristiques ne font pas dun tableau la
panace tous vos problmes de variable. Son emploi nest pas toujours intressant :
pour grer des prix TTC et HT et un taux de TVA, des variables indpendantes sont prfrables car chaque valeur possde une smantique propre.
Mais alors, quand un tableau est-il utile ?
On utilisera un tableau pour stocker un grand nombre de variables quivalentes et
interchangeables (un ensemble de quelques choses : dadresses, de notes, de ports
rseau). Le fait que, au sein dun tableau, chaque lment soit identifi par un
indice permet des traitements trs puissants avec une simple boucle pour.
2B.
Syntaxe
2B1. Dclaration
Un tableau peut avoir une dimension, deux dimensions (comme une feuille de calcul
Excel), trois dimensions ou n dimensions.
La dclaration est simple : on donne le nom du tableau, suivi du mot-cl tableau puis,
entre crochets la taille (nombre dlments) de chaque dimension. On indique ensuite le
type de tous les lments prcd du mot-cl de :
var
Nom : tableau[dim1, dim2, dim3, , dimn] de type
Cest la mme problmatique que sous Excel. Une feuille de calcul tant un tableau
deux dimensions, une cellule est identifie par ses deux coordonnes (par exemple, C5 pour colonne C et ligne 5). Lorsquune cellule prend de limportance et contient
une valeur qui possde une smantique, il faut la nommer. Ainsi, en programmation,
les variables sont par dfaut nommes mais on peut les dfinir dans un tableau. Sous
Excel, cest le contraire : elles sont par dfaut dans un tableau mais on peut les nommer.
Ne poussez cependant pas trop loin la comparaison. Sous Excel, on peut nommer toute cellule de
la feuille ; un mme espace mmoire pourra donc la fois avoir un nom et tre dans le tableau. En
programmation, un espace mmoire sera associ soit un lment dun tableau, soit une variable
indpendante, mais pas les deux la fois. (En vrai, si, cest possible, mais pas votre niveau.)
Si la feuille Excel est un tableau deux dimensions, on peut considrer le classeur comme un
tableau trois dimensions, la premire identifiant la feuille et les deux suivantes la cellule dans
la feuille.
54
8 3987 TG PA 00
Exemples :
Moyennes : tableau[20] dentiers
Je dispose de vingt variables entires pour stocker les moyennes (arrondies
lentier le plus proche) de mes vingt tudiants.
Notes : tableau[5,20] de rels
Jai ralis cinq interrogations ce trimestre. Chacun de mes vingt tudiants possde une note par interrogation. Ce tableau me permet de les stocker.
Attention, cest moi qui dcide arbitrairement que le premier indice reprsente
les interrogations (et variera donc de 1 5) et le second les lves (de 1 20).
NotesBis : tableau[20,5] de rels
Jai vingt tudiants dans ma classe, tous ayant une note chacun des cinq contrles que jai ralis ce trimestre.
Attention, cest moi qui dcide arbitrairement que le premier indice reprsente mes
tudiants (et variera donc de 1 20) et le second les contrles (de 1 5).
Concernant ces trois exemples, je vous dois une remarque importante.
Comme nous rdigeons un algorithme et pas un programme dans un langage spcifique, la syntaxe doit rester flexible. Toute dclaration donnant sans ambigut les trois
caractristiques dun tableau (le fait que cest un tableau, ses dimensions et le type de
ses donnes) est correcte. Il est vident quune grammaire rigide dans un algorithme est
un non-sens.
Cest pourquoi jai dcid de respecter autant que possible la langue franaise en me
permettant :
le pluriel pour les types (entiers et rels au lieu dentier et rel).
lapostrophe (dentiers et non de entiers).
Observez bien les deux tableaux Notes et NotesBis. Ils sont identiques car ils modlisent
la mme ralit. Les deux versions sont absolument quivalentes, tout traitement fait
avec lun pouvant tre fait avec lautre par une simple permutation des indices. En revanche, une fois que lon a choisi une de ces deux versions, il faut sy tenir : si lon dfinit
Notes avec le deuxime indice reprsentant ltudiant, pas question de changer dide
en cours de route.
Souvent, trop souvent, mes tudiants me demandent ce que lon doit mettre en ligne
et en colonne dans le tableau. Cest parce quils nont pas compris que cela ne change
rien. Tout dpend de votre perception des donnes.
Par exemple, sous Excel, que je parle de la cellule ligne 5, colonne 6 ou de la cellule
colonne 6, ligne 5, cest pareil ! Cela dit, pour viter toute ambigut ou interrogation
draisonnable, Excel utilise des chiffres pour identifier les lignes et des lettres pour
La ligne tant la premire dimension, la colonne la seconde ou linverse ! Cela na toujours

pas dimportance tant que lon conserve les mmes notations.
Draisonnable car, nous venons de le voir, tant que vous restez cohrent, il ny a pas derreur
possible.
55
8 3987 TG PA 00
Squence 3
les colonnes. Ainsi, que vous parliez de la cellule F5 ou 5F, tout le monde comprend.
Dailleurs, si vous permutez les coordonnes, Excel est capable de corriger comme le
prouve cette copie dcran :
Exercice 22
Je veux stocker toutes les notes de ma section de BTS. Dclarez les tableaux correspondant aux
diffrentes situations suivantes, de plus en plus prcises :
ma section contient 60 tudiants et je stocke leur moyenne annuelle ;
en fait, jai 2 classes de BTS (1re et 2e anne) contenant chacune 30 tudiants. Je
stocke toujours leur moyenne annuelle ;
jai 2 classes de BTS de 30 tudiants chacune et je stocke les vingt notes que chacun obtient sur toute lanne scolaire.
Vous avez compris le corrig ? Alors on continue encore plus fort.
Exercice 23
Je veux stocker toutes les notes de ma section de BTS. Dclarez les tableaux correspondant aux
diffrentes situations suivantes, de plus en plus prcises :
jai 2 classes de BTS de 30 tudiants chacune et lanne est divise en 2 semestres.
Jeffectue 10 contrles par semestre ;
le BTS est divis en 11 matires. Chacune attribue 10 notes par semestre chacun
des 30 tudiants de mes 2 annes de BTS.
En fait, dans mon lyce, il y a deux BTS (IG et NRC). Si lorganisation du BTS NRC est identique
celle du BTS IG (mmes nombres dannes, tudiants, semestres, matires et notes), peut-on
regrouper lensemble des notes des BTS dans un tableau ? Si oui, donnez sa dclaration. Si non,
dites pourquoi.
56
8 3987 TG PA 00
Exercice 24
Avez-vous bien compris ? Dans ce cas, en considrant le dernier tableau de lexercice prcdent, donnez les syntaxes et le principe du traitement (une ligne, ncrivez pas dalgorithme)
permettant dobtenir :
la troisime note dconomie (8e matire) du premier semestre pour ltudiant 17
en seconde anne de BTS IG (1er BTS) ;
les notes dconomie au troisime contrle du premier semestre pour tous les
tudiants de seconde anne de BTS IG ;
les notes dconomie au premier semestre pour tous les tudiants de seconde
anne de BTS IG ;
les notes dconomie au premier semestre pour tous les tudiants de BTS IG ;
les notes dconomie au premier semestre pour tous les tudiants, tous BTS
confondus ;
les notes dconomie, toutes classes, semestres et tudiants confondus.
La correction tait claire ? Vrifions
Exercice 25
En utilisant le tableau de lexercice prcdent, calculez la moyenne dconomie pour lensemble
de mes BTS (toutes annes, semestres et tudiants confondus). Faites un sous-programme et
jouez le jeu du sous-programme qui gnralise !
2B2. Accs un lment

Nous avons dj dit que chaque lment dun tableau tait identifi par un indice. Nous
avions alors prcis que lindice tait un nombre entier. En pratique, comment cela
fonctionne-t-il ? De la faon la plus naturelle qui soit : lindice correspond au numro de
llment. Par exemple :
si jai un tableau de 20 entiers, le premier sera indic par 1, le deuxime par 2, le
troisime par 3 et ainsi de suite jusquau vingtime qui sera indic par 20.
le principe sera le mme avec un tableau plusieurs dimensions. Si une dimension
possde x lments, lindice correspondant ira de 1 x.
Pour accder un lment dun tableau, il faut faire rfrence son indice. La syntaxe
est simple : on crit le nom du tableau, suivi entre crochets de lindice.
Voici ce que cela donne avec nos trois tableaux Moyennes et Notes et NotesBis du
paragraphe 2B1:
pour accder la ie note de mon tableau Moyennes, jcrirai Moyennes[i]. Mes vingt
notes seront donc accessibles par Moyennes[1], Moyennes[2] Moyennes[20] ;
si je veux obtenir la note de ltudiant numro 15 mon troisime contrle, jcrirai
Notes[3,15] ;
la mme note (tudiant numro 15, troisime contrle) sera accessible par
NotesBis[15,3].
Vous ne pouvez pas lavoir oubli car ctait juste au-dessus (paragraphe 2A2) et ctait
apprendre !
57
8 3987 TG PA 00
Squence 3
On retiendra :
Pour accder un lment dun tableau, il faut prciser le tableau dont il est question puis, au sein de ce tableau, les indices de llment voulu.
Syntaxe : on crit le nom du tableau, suivi entre crochets des indices spars par
des virgules. Par exemple, pour accder au troisime lment du tableau Tab ( une
dimension), on crira Tab[3].
2C.
Remarque sur lindice

Je vous dis ici que lindice dun lment est son numro. Ainsi, si jai 20 lments, les
indices iront de 1 20.
Sachez que dans certains langages de programmation, les indices commencent 0. Dans
ce cas, mes 20 lments seraient indics de 0 19. Rien ne change (cest une bte translation) mais cela complexifie le code et est source derreur car on a tendance parcourir
le tableau non pas des indices 0 19, mais de 0 20 ; on tente alors daccder llment
numro 21 (dindice 20) qui nexiste pas.
Commencer 0 est classique en informatique car 0 est une valeur valide qui peut servir
didentifiant. Ctait important jadis de ne pas gcher une valeur car les espaces
dadressage ntaient pas grands. Ce nest plus vrai maintenant, donc nous choisissons
une version plus simple.
Encore une fois, cela ne change rien. De faon thorique, rien ne mempche (sinon,
peut-tre, un peu de bon sens) dindicer mes 20 lments :
par les valeurs 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52 et
53 ;
ou, pire encore, par les valeurs 14, 73, 18, 56, 42, 27, 83, 37, 43, 73, 20, 17,
89, 54, 84, 88, 54, 5, 39 et 16.
Pourquoi ces deux versions, dont la seconde avec des valeurs priori alatoires, sontelles correctes dun point de vue thorique mais pas en pratique ? Noubliez pas le double rle de lindice :
pour lapplication, lindice identifie llment. Comme nous lavons vu en analyse,
toute valeur respectant les rgles de lidentifiant (notamment son unicit) est valide ;
pour lutilisateur, lindice permet daccder llment. Plus lindice est simple, plus
le code sera facile crire.
Le numro de llment est alors un indice parfait :
cest trivialement un identifiant donc lapplication est contente ;
on lutilise trs facilement avec une boucle pour parcourir le tableau donc le dveloppeur est tout joyeux.
Cela dit, indicer ainsi (par des valeurs conscutives commenant par un nombre particulier) peut
tre utile. Certains langages le permettent dailleurs.
Je les ai gnres par la fonction alea.entres.bornes dExcel. Elles sont donc bien alatoires.
58
8 3987 TG PA 00
2D.
Tableau, lment et indice

2D1. lment et variable
Un tableau est constitu dlments dun type donn. Lindice (tableau une dimension)
ou les indices (tableau plusieurs dimensions) me permettent daccder un lment.
Un lment donn est une variable comme une autre. Avec mes tableaux prcdents :
Moyennes[4] est un entier comme un autre. Tout ce que je peux faire avec une variable entire (affectation, test, lecture, saisie, calcul), je peux le faire avec nimporte
quel lment de Moyennes ;
Notes[5,2] est un rel comme un autre. Tout ce que je peux faire avec une variable
relle (affectation, test, lecture, saisie, calcul), je peux le faire avec nimporte quel
lment de Notes.
Finalement, quest-ce qui change entre une variable autonome et un lment dun
tableau ? Strictement rien, si ce nest la syntaxe pour lidentifier :
un lment dun tableau est identifi par le nom du tableau puis le ou les indices ;
une variable autonome est identifie par son nom.
Un lment dun tableau est strictement quivalent une variable du mme type
(un lment dun tableau dentiers est un entier, un lment dun tableau de chanes
est une chane).
2D2. Accs un lment

Jai constat dans vos copies beaucoup de confusions entre le tableau, lindice et llment. Je vais donc ajouter quelques explications.
Pour commencer, une remarque pas trs claire mais dont lexplication suit :
Pour accder un lment dun tableau, il faut fournir une valeur pour chaque indice
(soit un indice par dimension).
Pour comprendre cela, tudions nos deux tableaux ftiches.
Cas du tableau Moyennes : tableau[20] dentiers
Pour obtenir une note, je dois donner son indice. Le tableau ayant un seul indice (une
dimension), je ne dois naturellement donner quun seul indice. Par exemple, Moyennes
est le tableau et Moyennes[12] est une note.
Exercice 26
quoi correspond lcriture Moyennes[3,4] ? (Il y a deux interprtations possibles.)
Je nai rien ajouter, le cas du tableau une dimension nest jamais complexe.
Cas du tableau Notes : tableau[5,20] de rels
Ce tableau contient 5*20 = 100 notes, soit une par contrle (jen ai 5) et par tudiant
(jen ai 20).
Ainsi, pour obtenir une note (soit une variable relle), je dois identifier le contrle et ltudiant. Par exemple, Notes est le tableau et Notes[1,15] est la premire note de ltudiant 15.
59
8 3987 TG PA 00
Squence 3
Exercice 27
quoi correspond lcriture Notes[3] ?
La conclusion de ces exercices est :
Pour accder un lment dun tableau, il faut fournir une valeur pour chaque indice
(soit un indice par dimension). Toute autre criture est incorrecte.
Exercice 28
Je souhaite stocker les tempratures releves 13 h tous les jours dune anne donne. Mon
objectif est videmment de raliser ensuite des statistiques (moyennes pour un mois ou une
saison donne). Dfinissez la ou les variables permettant de stocker toutes ces donnes.
Attention, cest moins simple quil ny parat. Prenez en compte lusage que je veux faire de
ces donnes.
Exercice 29
La solution retenue pour lexercice prcdent nous conduit avoir des lments qui ne doivent
pas tre utiliss. Par exemple, si je veux faire la moyenne des tempratures davril, que penser
du code suivant ?
moyenne := 0
pour i de 1 31
moyenne := moyenne + temp[i,4]
fin pour
moyenne := moyenne/31
Proposez une faon efficace de remdier au problme. Par efficace, jentends une solution utilisable pour tous les mois et pas seulement avril. Vous envisagerez deux solutions : un tableau
ou une fonction.
Exercice 30
Continuons sur la correction de lexercice prcdent. crivez la fonction NbrJours renvoyant
le nombre de jours dun mois donn (ne tenez pas compte des annes bissextiles).
Exercice 31
Nous continuons sur la correction de lexercice 29. Dfinissez le tableau NbrJours stockant le
nombre de jours de chaque mois puis un sous-programme initialisant le tableau (soit chaque
lment).
60
8 3987 TG PA 00
Exercice 32
crivez un sous-programme calculant la temprature moyenne dun mois donn. Vous utiliserez la fonction NbrJours de lexercice 30.
Exercice 33
Idem, cette fois en utilisant le tableau NbrJours de lexercice 31. Attention, nutilisez aucune
variable globale !
2E.
Gestion mmoire
Cette partie est lire attentivement, comprendre, mais pas apprendre.
On est parfois tent de mettre tout et nimporte quoi dans un tableau. Or, comme je lai
dj dit, un tableau ne peut contenir que des lments de mme type.
Pourquoi ? Pour laccs direct ! Expliquons un peu cela.
2E1. Reprsentation en mmoire dun tableau plusieurs dimensions

Mise en ligne dun tableau
Je vous rappelle ce que nous avons vu dans la squence 1 (paragraphe 3A) : lorsque lon
dclare une variable, on rserve sa place en mmoire et on linscrit dans le tableau des
variables.
Que se passe-t-il lors de la dclaration dun tableau ? La nouveaut, cest que notre
tableau contient lui-mme des variables. Est-ce que seule la variable tableau est stocke
dans le tableau des variables, ou stocke-t-on tous ses lments ? Placer tous les lments
dans le tableau des variables reviendrait crer des variables indpendantes, ce qui est
loppos du but cherch. On ne stocke donc que la variable tableau elle-mme. Mais
alors, comment le programme fait-il pour accder un lment ?
En fait, le tableau est toujours stock en ligne, cest--dire sous la forme dune ligne,
donc dun tableau une dimension. Si le tableau est dj une dimension, cela ne
change rien. Sil est deux dimensions, on stockera toutes ses lignes les unes la suite
des autres. Le principe reste le mme pour 3 dimensions ou plus.
Par exemple, supposons que je dclare un tableau t : tableau[4,3] contenant quatre
lignes et trois colonnes. Je le reprsente ci-dessous en marquant dans chaque case le
nom de llment correspondant :
t[1,1]
t[1,2]
t[1,3]
t[2,1]
t[2,2]
t[2,3]
t[3,1]
t[3,2]
t[3,3]
t[4,1]
t[4,2]
t[4,3]
Pour la cinquante-sept mille trois cent quatre-vingt-douzime fois, dire que le premier indice
reprsente les lignes et lautre les colonnes est une convention. Prendre loption inverse ne changerait rien. Limportant est de rester constant tout au long du programme.
61
8 3987 TG PA 00
Squence 3
Ce tableau sera en fait stock en mmoire avec les lignes au bout les unes des autres :
t[1,1] t[1,2] t[1,3] t[2,1] t[2,2] t[2,3] t[3,1] t[3,2] t[3,3] t[4,1] t[4,2] t[4,3]
Ainsi, le compilateur ne grera pas un tableau de quatre lignes et trois colonnes, mais
un tableau dune ligne et de 12 colonnes.
Finalement, le tableau t est deux dimensions pour le dveloppeur mais une dimension pour le compilateur. Voici la correspondance des diffrents lments :
t[1,1] t[1,2] t[1,3] t[2,1] t[2,2] t[2,3] t[3,1] t[3,2] t[3,3] t[4,1] t[4,2] t[4,3]
t[1]
t[2]
t[3]
t[4]
t[5]
t[6]
t[7]
t[8]
t[9]
t[10]
t[11]
t[12]
Ainsi, on voit que chaque lment de t deux dimensions correspond un unique lment de t une dimension et rciproquement. Plus prcisment, chaque couple dindices ligne,colonne de t deux dimensions ne correspond quun indice colonne dans t
une dimension. Par exemple, t[3,2], cest t[8].
Je conserve le mme nom de tableau avec les deux reprsentations pour insister sur le
fait que nous navons affaire qu un seul tableau, manipul selon des points de vue
diffrents.
Maintenant, comment le passage dun formalisme lautre seffectue-t-il ? Quand vous :
dclarez var t : tableau[4,3] dentiers, le compilateur transformera cela en
var t : tableau[12] dentiers ;
crivez t[3,2] := t[1,1] + t[4,3], le compilateur le traduira en t[8] := t[1] +t[12].
La question en suspens, cest : comment le compilateur passe-t-il dun format de tableau
lautre ? Stocke-t-il toutes les correspondances entre les deux systmes dindices ?
Passage de deux une dimension
Reprenons : le systme stocke-t-il toutes les correspondances entre les deux systmes
dindices ? Non ! Il lui suffit de raliser un petit calcul.
Dans le cas de notre tableau, le passage de deux une dimension est ralis en appliquant la formule t[i,j] = t[(i-1)*3+j]. Par exemple :
t[3,2] = t[(3-1)*3+2] = t[2*3+2] = t[8]
Dune faon gnrale, si un tableau possde l lignes et c colonnes, on aura :
t[i,j] = t[(i-1)*c+j]
Que prouve ce raisonnement ? Que les deux reprsentations sont strictement quivalentes. Le principe est le mme quel que soit le nombre de dimensions du tableau. Je ne vous
donne pas les formules, cest sans intrt et vite trs complexe. Faites-moi confiance.
Intrt de ce va-et-vient
Maintenant, reste savoir quoi sert cette gymnastique : pourquoi tout tableau est-il
stock en ligne et non comme on le dclare ? Pour des raisons doptimisation mmoire :
si lon remplit la mmoire avec des lignes, on lexploitera mieux car on peut les mettre
bout bout, tandis que si lon y place des rectangles, on risque davoir des trous, donc
de lespace mmoire gch. Une petite analogie pour tre sr de bien comprendre ? Eh
bien, supposons que vous vouliez carreler une pice : plus vous prendrez de petits carrelages, moins vous aurez de dcoupes faire.
En fait, ce nest pas tant une raison doptimisation quune obligation. Comme la mmoire
est reprsente par un tableau deux dimensions, il est trivial dy stocker des tableaux
deux dimensions. On se demande donc quoi sert leur mise en ligne. Cependant, stocker
62
8 3987 TG PA 00
un tableau trois dimensions dans un tableau nen ayant que deux est moins vident. Et
pour les dimensions plus leves ? Cest impossible. De mme, sur une feuille de papier
(deux dimensions), dessiner des objets plats est vident, reprsenter une perspective
pour grer trois dimensions est moins simple et au-del on ne sait pas faire.
Finalement, la vraie question poser, cest le contraire : pourquoi le langage se fatiguet-il prsenter au dveloppeur des tableaux plusieurs dimensions alors quen interne
il ne les gre quavec une seule ?
Le langage gre en interne des tableaux une dimension par obligation ; les calculs
raliser pour accder une case donne sont lmentaires pour lui. En revanche, ces calculs seront trs complexes pour le dveloppeur et source derreurs. Imaginez-vous faisant
une boucle sur un indice dun tableau quatre dimensions : traduire cela avec le tableau
linaris serait pnible et trs peu intuitif ! Cest pourquoi cette tche est rserve au
compilateur.
La conclusion est amusante : vous manipulez des variables qui nexistent pas. Vos
tableaux plusieurs dimensions ne sont quun habillage destin vous simplifier la vie.
Cest un peu de lergonomie !
Les dimensions dun tableau sont tellement illusoires que lon peut facilement percevoir
tout tableau comme tant une seule dimension. Je vous rappelle quun tableau contient des lments dun type donn qui peut lui-mme tre un tableau. Ainsi :
un tableau dentiers deux dimensions est un tableau de tableaux dentiers une
dimension (une feuille Excel peut tre vue comme un tableau de lignes ou de colonnes) ;
un tableau de rels trois dimensions est un tableau de tableaux de rels deux
dimensions, soit un tableau de tableaux de tableaux de rels une dimension ;
2E2. Accs direct un lment

Un exemple
Nous continuons travailler sur notre tableau t : tableau[4,3] dentiers avec quatre lignes
et trois colonnes du paragraphe prcdent.
Jai toujours une question en suspens : comment accder llment t[3,2] alors que je ne
connais que la position en mmoire du tableau lui-mme (donc celle de la premire case) ?
Dj, la mise en ligne du tableau me simplifie la tche puisquen fait, je dois accder
t[8]. Ensuite, un tableau contient des lments de mme type. Cela signifie que chaque
lment occupe le mme nombre doctets en mmoire. Et cela change tout.
Reprenons notre tableau reprsentant la mmoire des squences prcdentes. Pour
simplifier les calculs, notez que jinverse ma numrotation (lignes reprsentes par des
lettres et colonnes par des chiffres).
Comme les multiples dimensions sont faites pour aider le dveloppeur, vous seriez fort mal
venu de trouver cela complexe.
63
8 3987 TG PA 00
Squence 3
Voici comment notre tableau t, dclar t : tableau[4,3] dentiers, va tre stock (on suppose que les entiers occupent deux octets en mmoire) :
VARIABLE
t

TYPE
ADRESSE DBUT
entier
B2
Vous remarquerez que rien nindique dans le tableau des variables que jai affaire un
tableau. Pour le compilateur, je nai quun entier dans les cases B2 et B3. Nous en reparlerons.
tat de la mmoire
1
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
A
B
C
t[1,1]
t[1,3]
t[2,1]
t[4,3]
On sait passer de t[i,j] t[i]. Maintenant, comment traduire une notation t[i] en adresse
mmoire ? Voici quelques correspondances :
Cas gnral
Tableau
(notation deux dimensions)
t[1,1]
t[1,2]
t[1,3]
t[4,3]
t[i,j]
Tableau
(notation une dimension)
t[1]
t[2]
t[3]
t[12]
t[(i-1)*3+j]
Adresse mmoire du 1er octet
B2
B2
B4
B6
B24
t[i]
B(2*i)
Vrifions le passage de t[i] B(2*i) : t[5] devrait tre ladresse mmoire B(2*5) soit B10.
Cest exact !
Si lon part de la notation deux coordonnes, on aura :
t[i,j] = t[(i-1)*3+j] = B(2*((i-1)*3+j)) = B(6*i+2*j-6)
Vrifions : t[4,3] = t[(4-1)*3+3] = t[12] = B(6*4+2*3-6) = B24. Cest parfait !
Cas gnral
Prenons le cas gnral dun tableau t :
l lignes et c colonnes ;
contenant des lments occupant chacun o octets en mmoire ;
dont le premier lment est ladresse Ba (a reprsentant le nombre identifiant la
colonne comme prcdemment).
Dans ce cas, lorsque le programmeur veut accder en lecture ou criture llment
t[i,j], le compilateur ira lespace mmoire B(((i-1)*c+j-1)*o+a) et le lira avec les (o-1)
suivants.
64
8 3987 TG PA 00
Il est totalement inutile de retenir cette formule. Par contre, elle vous prouve quelque
chose qui faut apprendre :
Un tableau est un ensemble de variables (lments) de mme type. Ces lments
sont identifis par des indices permettant au programme daccder directement
lespace mmoire de llment requis. Laccs est donc immdiat.
Je ne vous le dmontre pas, mais, faites-moi confiance, pour un tableau trois, quatre,
n dimensions, cest la mme chose. La formule sera juste un peu plus complexe !
Petite remarque pointue et amusante
Retournez squence 1, paragraphe 3B2. Javais comment les diffrentes interprtations
possibles des deux octets piochs brutalement en mmoire en disant que lon ne savait
pas si on avait affaire un tableau ou des valeurs indpendantes. Les dimensions des
tableaux ne sont donc pas stockes. Cela signifie que si vous crivez t[90,78], le compilateur vous fera confiance en supposant que le tableau possde effectivement au moins
90 lignes et 78 colonnes. Si ce nest pas le cas, que se passe-t-il ? Et bien, Joe le compilo
va effectuer le calcul vu ci-dessus, ce qui donnera une adresse mmoire. Lapplication lira
ou crira cette adresse, bien quil y ait une information sans rapport avec le tableau.
En gnral, cela plante le programme ou modifie dautres donnes.
En clair, lapplication ne vrifie pas si vous vous cantonnez au tableau ou allez au-del,
ce qui est trs dangereux.
Cest une erreur suffisamment dlicate pour que certains langages proposent de vrifier
les accs au tableau et prviennent si vous utilisez un indice invalide. Le problme, cest
qu chaque accs, la vrification est faite. Lapplication sen trouve ralentie. Une bonne
habitude de programmation consiste activer cette vrification lors des tests pour
dbusquer ce type de bug assez frquent, puis la dsactiver lors de lutilisation relle
(la mise en production) pour gagner en efficacit.
2F.
Indice et contenu
Attention ne pas confondre llment dun tableau avec son indice. Bref, ne confondez pas i et t[i].
froid, cela vous semble vident pourtant, ds que vous faites des exercices de tri ou
de recherche (bref, ds que vous travaillez sur les indices), vous faites lerreur. Je ne vous
jette pas la pierre car cest un pige classique. Si je vous en parle, cest pour qu chaque
programme crit, vous vrifiez bien que vous ntes pas tomb dans le pige.
Les dveloppeurs dapplications et moi retrouverons ce problme avec les pointeurs.
3.
Dfinir ses propres types
3A.
Introduction
Vous connaissez les types classiques : entier, rel, tableau, boolen, chane de caractres,
date
Et bien, de mme que vous pouvez crer vos propres instructions (procdures) et fonctions, vous pouvez crer vos propres types.
65
8 3987 TG PA 00
Squence 3
Attention, il est impossible de crer le type Teckel puis de dfinir une variable Nina de
type Teckel. Enfin, cest impossible si lon pense au brave animal de chair, de truffe et
de sang.
Je veux dire par l que pour fabriquer nos propres types, nous ne disposons comme
briques que des types de base (de mme que pour crer nos propres sous-programmes,
nous navions accs quaux instructions classiques). Ainsi, pas de miracle.
Imaginez-vous face un MCD, bauche dune informatisation venir. Prenons par exemple lentit Client :
CLIENT
num_client
nom_client
prnom_client
adr_client
tl_client
date_client
date_client reprsente la date de la premire commande du client

(ce qui permet, par diffrence avec la date du jour, de connatre
lanciennet du client).
Lentit Client possde six proprits : une date, un entier (lidentifiant) et quatre chanes (nom, prnom, adresse et tlphone). Lorsque vous manipulerez des occurrences de
Client dans votre application, comment dfinirez-vous les variables correspondantes ?
Prenons lexemple concret de loccurrence Client1.
Pour le moment, la seule solution consiste dfinir une variable par proprit :
var
NumClient_Client1 : entier
NomClient_Client1 : chane
PrnomClient_Client1 : chane
AdrClient_Client1 : chane
TlClient_Client1 : chane
DateClient_Client1 : date
Maintenant, comment faire pour utiliser loccurrence dans un sous-programme ? Il faut
passer chacune de ces variables en paramtre. Cest un peu fastidieux !
Imaginez maintenant que jai aussi besoin des occurrences Client2, Client3, Client4 Il
me faudrait dfinir six variables par client. Tout cela nest pas bien raisonnable.
Je souhaiterais pouvoir dfinir un type Client, contenant toutes les proprits de lentit.
Je pourrais alors dfinir mes occurrences ainsi :
var
Client1, Client2, Client3, Client4 : Client
Mieux encore, si jai 1 000 clients, je pourrais alors les stocker dans un tableau :
var
TabClients : tableau[1000] de Client
Il sagit de transposer les concepts danalyse entit et occurrence en concepts de programmation type et variable.
66
8 3987 TG PA 00
3B.
Syntaxe de la dfinition
Comme toujours, tout ce qui est dfini (variable, procdure, fonction mais aussi type)
doit possder un nom.
Pour dfinir un type, on utilisera le mot type suivi de son nom, du caractre = et de
sa description.
type
nom = description
Une fois le type dfini, on peut lutiliser comme nimporte quel type de base (de
mme quune fois un sous-programme dfini, on peut sen servir comme sil avait
toujours exist).
Notez bien que lon dclare un type avec un = et une variable avec un : . Est-ce
une coquetterie ? Non, il y a une raison smantique : la dfinition du type est une quivalence puisque le nouveau type est quivalent (gal) sa description. Au contraire, une
variable est dun type donn mais nest pas ce type.
Dun point de vue algorithmique, il est intressant de faire la distinction pour bien montrer notre comprhension des concepts.
3C.
Intrt des dfinitions de type

Voyons un exemple de dclaration de type :
type
Teckel = entier
Une fois mon type Teckel dfini, je peux men servir comme tout autre type dj existant.
Je peux notamment dfinir des variables de ce type :
var
i,j : Teckel
Maintenant, analysons ce que nous venons de faire. Teckel est dfini comme tant strictement quivalent un entier. Ainsi, mes variables i et j, tant de type Teckel, sont de
type entier. En clair, en dclarant deux teckels i et j, jai en fait dclar deux entiers.
O veux-je en venir ? Et bien, jai redfini le type entier en crant un synonyme. Quel
est lintrt de cela ? Strictement aucun, dautant que le terme Teckel nest pas trs
explicite.
Dfinir ses propres types nest intressant que sils sont nouveaux. Cest ce que nous allons
voir dans le paragraphe suivant o nous allons dclarer le type Client du paragraphe 3A.
3D.
Les types structurs

Un type structur va permettre de dfinir des variables contenant plusieurs autres variables. Vous allez me dire que ce nest pas nouveau puisque les tableaux taient dj des
variables en contenant dautres.
Vous avez raison. Cependant, il y a une norme diffrence : un tableau ne peut contenir
que des variables de mme type, tandis quune variable structure peut contenir des
variables de type quelconque.
67
8 3987 TG PA 00
Squence 3
La syntaxe de dfinition du type est simple : entre les mots cl structure et fin structure,
on numre les diffrentes variables (et leur type) constituant la structure :
type
nom = structure
variable1 : type1
variable2 : type2
...
variablen : typen
fin structure
Les variables constituant le type structur sont appeles des champs. Toute variable dun type structur possde tous les champs dfinis dans le type. Lordre des
champs dans la structure na aucune importance.
Exercice 34
Essayez dappliquer cela en dfinissant le type structur Client correspondant lentit du
paragraphe 3A.
Nous pouvons maintenant dclarer un client de type Client :
var
Cl : Client
Maintenant, comment faire pour indiquer que notre client Cl sappelle Nina ? Il faut
dfinir son champ NomClient.
Exercice 35
votre avis, comment faire ?
La premire ide qui vient est dcrire :
NomClient := "Nina"
Hlas, cette solution est incorrecte : le compilateur vous dira que la variable NomClient
nexiste pas. Et le compilateur aura raison ! En effet, nous navons pas dclar de variable
NomClient (ou autre), mais une variable Cl contenant un champ NomClient.
Bref, il faut passer par Cl pour accder NomClient. Cest assez logique finalement : si nous
avions cinq variables de type Client, utiliser directement NomClient serait ambigu puisque
lon naurait aucun moyen de savoir laquelle de ces cinq variables on fait allusion.
Cest exactement le mme raisonnement que pour accder un lment dun tableau :
on ne dit jamais je veux llment i mais je veux llment i du tableau t .
68
8 3987 TG PA 00
Rsumons-nous : comment accder au champ c de la variable structure s ? Nous avons

besoin dune nouvelle syntaxe (enfin, nouvelle vous la connaissez dj). Cest loprateur . , parfois appel oprateur de qualification car il qualifie (identifie) le champ.
La syntaxe sera s.c, soit :
variable.champ
Pour accder au champ NomClient de la variable Cl, jcrirai Cl.NomClient.
Vu la dclaration du type Client, la variable Cl.NomClient est une chane de caractres
comme une autre. Ainsi, partout o jutilise une chane, je peux utiliser Cl.NomClient.
Voici un petit rsum de tout cela.
Quand une variable en contient dautres (tableau t, structure s), il faut toujours passer par la variable contenant pour accder une des variables contenues :
pour un tableau t, on met lindice entre crochets : t[i] identifie llment i du
tableau t ;
pour une structure s, on utilise loprateur . pour sparer la variable et ses
champs : s.champ identifie le champ champ de la variable structure s.
Avec un tableau Tab, Tab[i] identifie une variable de mme type que les lments
du tableau. Avec une structure Str contenant un champ Ch, la variable Str.Ch est de
mme type que le champ Ch.
Ainsi, si nous avons :
type Bidon = structure
Ch : chane
...
fin structure
var
a : chane
b : tableau[50] de chanes
c : Bidon
Les trois variables a, b[8] et c.Ch sont absolument quivalentes : ce sont des chanes de
caractres. La seule chose qui les distingue, cest la faon dont on les nomme : pour une
variable simple, le nom suffit mais pour une variable incluse dans une autre, il faut passer par la variable contenant (tableau ou structure) puis spcifier ce que lon veut (un
lment ou un champ).
Dans le cours SQL de premire anne, nous avons vu cet oprateur pour prciser la table dorigine
dun champ dans une jointure.
Cest le mme principe que pour les lments dun tableau qui sont je lai abondamment
dit utilisables partout o jai des expressions de mme type.
69
8 3987 TG PA 00
Squence 3
Exercice 36
crivez un sous-programme permettant dinitialiser une variable de type Client (les valeurs
doivent tre demandes lutilisateur). Vous ferez deux versions : avec une fonction puis
une procdure.
3E.
Quand utiliser une structure ?

En tant quinformaticien de gestion, vous ne devez pas avoir de difficult cerner lintrt des structures (classiquement, les entits seront codes sous la forme de structures).
Voici nanmoins la rgle gnrale :
Lorsque vous voulez dfinir une chose dcrite par plusieurs valeurs, il faut dfinir
un type structur. Dit autrement, un concept doit tre reprsent par une seule
variable. Si une variable simple ne suffit pas, on dfinit un type structur contenant
toutes les informations ncessaires.
Attention, pour dclarer une variable structure, il faut avoir pralablement dfini
le type correspondant.
4.
Allons plus loin avec les structures
4A.
Introduction
Une fois le type structur dfini, on peut dclarer une variable structure qui est alors
une variable comme nimporte quelle autre. Elle peut donc faire partie dune autre
structure.
De mme, un tableau est une variable comme une autre. Il peut donc galement faire
partie dune structure.
Dans le mme thme, un type structur est un type comme un autre. On peut donc dfinir un tableau contenant des variables structures.
Nous allons mettre tout cela en uvre.
4B.
Structure contenant un tableau

4B1. Posons le problme
Cest hyper-classique : un tableau possde un nombre dlments fix lors de lcriture
du programme. Impossible de rajouter des lments en cours de route. Depuis que
nous savons comment fonctionne lallocation mmoire lors de la dclaration des variables, nous pouvons comprendre pourquoi rajouter des lments aprs coup nest pas
possible : les cases mmoire situes aprs le tableau sont sans doute dj occupes par
dautres variables.
Les langages de programmation modernes proposent des tableaux de taille variable, mais cest
hors sujet ici.
70
8 3987 TG PA 00
Reprenons le cours de notre raisonnement : on ne peut pas rajouter dlments un

tableau. Sa dfinition dans le programme est donc grave dans le marbre. Pour tre
certain quil ne sera jamais trop petit, il faut le prvoir trop grand. Eh oui !
Je mexplique : il vaut mieux avoir trop dlments (certains ne seront simplement pas
remplis) que pas assez car alors toutes les donnes ne pourront pas tre stockes. Ce
nest absolument pas neuf :
la mmoire de votre ordinateur se compte en gigaoctets. Vous nutilisez sans doute pas
toute la mmoire constamment. Mais il vaut mieux en avoir beaucoup au cas o ;
quelle est la capacit de votre disque dur ? Sans doute plusieurs centaines de
gigaoctets. Le jour o vous utiliserez toute sa capacit (en pratique mme un peu
avant), vous le trouverez trop petit ;
une feuille de calcul Excel contient 65 536 lignes et 256 colonnes soit 16 777 216 cellules. Jinsiste, il y prs de 17 millions de cellules par feuille. Ainsi, si vous aviez peur
den manquer, vous quitterez ce cours rassrn. Vous naurez sans doute jamais
besoin dautant de cellules, mais bon, il vaut mieux en avoir mille fois trop et ne pas
sen servir que de manquer dune seule.
Prenons un exemple concret : pour effectuer des statistiques, je souhaite stocker lge
des lves des diffrentes classes dun lyce. Je dfinirai donc un tableau par classe.
Maintenant, combien dlments par tableau ? Le proviseur mindique que les classes
ont de vingt quarante lves, quarante tant une limite fixe par le ministre (donc
infranchissable).
Je vais donc dclarer des tableaux de quarante lments. Ainsi, je suis certain de pouvoir
stocker nimporte quelle classe dans un tableau. Mais que se passera-t-il dans le tableau
si la classe possde moins de quarante lves ? Comment grer les lments du tableau
dont je ne me sers pas ? Il ne faut pas que jutilise les quarante lments du tableau pour
calculer une statistique si seulement vingt sont valides.
Pour rsumer, jai un tableau de quarante lments dont seulement certains sont utiliss donc possdent une valeur devant tre prise en compte. Comment grer cela ? Trs
simplement : pour chaque tableau, je dfinirai une variable entire stockant le nombre
dlments utiliss.
Comprenez bien le principe ! Si je nai besoin que de vingt lments dans un tableau de
quarante, pas question dutiliser un lment sur deux. On utilisera les vingt premiers, les
vingt suivants restant inoccups. Avec notre mcanisme, un tableau est donc toujours
rempli de la gauche vers la droite, la variable associe indiquant le nombre dlments
rellement utiliss, soit lindice du dernier lment utilis.
Ainsi, chaque tableau sera accompagn dune variable entire indiquant le nombre
dlments utiliss (soit lindice du dernier lment utilis).
Bien entendu, chaque ajout ou suppression dlments dans le tableau, il faut mettre
jour sa variable associe. Chaque boucle (parcours de tableau) ne fera pas rfrence
au nombre maximal dlments (taille du tableau), mais notre variable indiquant le
nombre dlments rellement utiliss.
71
8 3987 TG PA 00
Squence 3
Exercice 37
Dfinissez deux variables : un tableau de quarante lments et sa variable indiquant le nombre
dlments rellement utiliss. Ce tableau servira stocker les ges de mes tudiants.
crivez ensuite un sous-programme remplissant trente-cinq lments de ce tableau (jai une
classe de trente-cinq lves). Vous mettrez des valeurs alatoires entre 18 et 23. Pour cela, utilisez la fonction alatoire(i) renvoyant un nombre entier entre 0 et i-1. vous de trouver une
formule permettant dobtenir des valeurs entre 18 et 23. (Cest une rponse ceux qui se pose
la question de lintrt des mathmatiques en BTS informatique.)
Exercice 38
crivez maintenant un sous-programme calculant lge moyen des tudiants du tableau.
Attention, comme un sous-programme est indpendant, vous devez utiliser votre variable
stockant le nombre dlments du tableau. Plus question de considrer que le tableau contient trente-cinq lments : un autre peut nen contenir que vingt-sept.
Le moment est venu de poser le problme : dans les deux exercices prcdents, nous
avons d systmatiquement traner deux variables : le tableau et la variable associe
indiquant le nombre dlments de ce tableau.
Les deux variables sont indissociables. Jinsiste : elles forment un tout, un concept cohrent. Cela ne vous dit rien ? Relisez le paragraphe 3E. Nous allons dfinir un type structur contenant deux variables : le tableau et le nombre dlments de ce tableau.
Exercice 39
Dfinissez le type puis une variable de ce type. Quelle est la syntaxe pour accder un lment du tableau ?
Reprenons la correction :
type
Tableauge = structure
lment : tableau[40] dentiers
Nbrlments : entier
fin structure
var
Bts1 : Tableauge
72
8 3987 TG PA 00
Exercice 40
Question finaude : je vous demande daccder un lment du tableau lment. Mais ce
tableau, il appartient qui ? Au type Tableauge ? Bts1 ? Nbrlments ? une autre
variable ? un autre type ? Hein ?
La question en suspens est : comment accder un lment du tableau de Bts1 ?
Supposons que je veuille llment lindice 12. Comment y accder ? Mes tudiants de
BTS ont souvent des difficults pour rpondre. Sils narrivent pas accder un lment,
cest parce quils apprennent mal le cours. En effet, en lappliquant rigoureusement, il
ny a aucune difficult. Nous allons progresser par tapes.
1. Pour accder un champ champ dune variable structure VarStruct, on utilise la syntaxe VarStruct.champ. Ici, on veut le champ lment de la variable Bts1, ce qui donne
Bts1.lment (le fait que lment soit un tableau ne change rien).
2. Comme nous lavons vu ci-dessus (paragraphe 3D), la syntaxe VarStruct.champ donne
accs une variable de mme type que le champ champ. Ici, Bts1.lment est donc
une variable du mme type que lment. En clair, Bts1.lment est un tableau avec un
nom un peu long, mais cest un tableau quand mme.
3. Pour accder llment situ lindice indice dun tableau tableau, on utilise la syntaxe tableau[indice].
4. Rsumons : Bts1.lment est un tableau ; pour avoir le ie lment dun tableau Tab, on
crit Tab[i]. En mixant ces deux critures, on obtient que le ie lment du tableau Bts1.
lment sera accessible par lcriture Bts1.lment[i].
5. Conclusion : pour avoir le 12e lment, cela donne lcriture Bts1.lment[12] que vous
devez lire ainsi : je veux le douzime lment du tableau lment de la structure Bts1.
(Ou, ce qui revient au mme : dans la structure Bts1, jaccde au champ lment et
je prends son douzime lment. )
Exercice 41
Rcrivez les deux sous-programmes des exercices 37 et 38 en utilisant la structure Bts1.
Voici la leon retenir :
chaque fois que vous tes confront un tableau ayant un nombre variable dlments (cest le cas le plus frquent), vous devez utiliser une structure (variable structure) contenant deux champs :
le tableau ;
une variable entire stockant le nombre dlments rellement utiliss. Cette
variable doit tre mise jour chaque volution du contenu du tableau.
La dfinition dun type structur est alors indispensable pour pouvoir dclarer la
structure.
Apophtegme du bon professeur Fvrier : On peut apprendre sans comprendre mais on ne peut
pas comprendre sans apprendre. Il veut sans doute dire par l que si les bases ne sont pas apprises, les concepts suivants ne seront pas compris. (Et si cest ce quil veut dire, il a raison.)
73
8 3987 TG PA 00
Squence 3
4C.
Tableau contenant une structure

Un tableau contient des lments dun type quelconque. Or, un type structur est un
type. On peut donc sans problme dfinir un tableau contenant des lments qui sont
des variables structures.
Ce genre de choses est dun usage courant. Par exemple, nous pouvons stocker dans un
tableau lensemble des clients de lentreprise, les informations dcrivant un client tant
stockes dans une structure (je reprends celle de lexercice 34) :
type Client = structure
NumClient : entier
NomClient : chane
PrnomClient : chane
AdrClient : chane
TlClient : chane
DateClient : date
fin structure
Le tableau est alors :

var
TabCl : tableau[50] de Client
Pour accder au nom du 8e client, la syntaxe sera : TabCl[8].NomClient, savoir que lon
accde au 8e lment du tableau (cest un client) et, dans cet lment, on accde au
champ NomClient.
Attention, distinguez bien lindice de tableau et le champ NumClient. Ce sont deux informations diffrentes.
Exercice 42
Ne perdons pas nos bonnes habitudes : les clients, cela va, cela vient. Autant dire que je peux
parfois en avoir 120, dautres fois 470. On supposera que je naurai jamais plus de mille clients.
Dfinissez une structure contenant le tableau de clients et le nombre de clients quil contient
comme nous lavons vu dans le paragraphe 4B.
Exercice 43
crivez un sous-programme affichant le nom de chaque client (les clients sont stocks dans une
variable structure du type dfini dans lexercice prcdent).
74
8 3987 TG PA 00
4D
Ce qui est venir

Le cours est termin : nous avons comme convenu abord les tableaux de structures et
les structures contenant un tableau.
Nous allons maintenant systmatiser cela par deux TD. Je veux vous entraner manipuler ce type de variables (notamment les tableaux de structures) dans tous les sens : tri,
recherche dlments, parcours Vous pourrez ensuite vous jeter dans les devoirs.
75
8 3987 TG PA 00
Synthse
Les tableaux
On ne parlera pas de tableau (tout court), mais de tableau de quelque chose,
sous-entendu de tableau contenant des lments dun type donn . Un
tableau ne peut contenir que des lments de mme type. Mlanger des entiers
et des caractres dans un tableau est donc interdit.
Un tableau est un ensemble de variables de mme type. Chacune de ces variables
est un lment du tableau. Au sein dun tableau, chaque lment est identifi
par un numro appel indice.
On utilisera un tableau pour stocker un grand nombre de variables quivalentes
et interchangeables (un ensemble de quelque chose : dadresses, de notes, de
ports rseau). Le fait que, au sein dun tableau, chaque lment soit identifi par un indice permet des traitements trs puissants avec une simple boucle
pour.
Syntaxe de dclaration :
var
Nom : tableau[dim1, dim2, dim3, , dimn] de type
Pour accder un lment dun tableau, il faut prciser le tableau dont il est
question puis, au sein de ce tableau, les indices de llment voulu. La syntaxe est
simple : on crit le nom du tableau, suivi entre crochets des indices spars par
des virgules. Par exemple, pour accder au troisime lment du tableau Tab (
une dimension), on crira Tab[3].
Pour accder un lment dun tableau, il faut fournir une valeur pour chaque
indice (soit un indice par dimension). Toute autre criture est incorrecte.
Un lment dun tableau est strictement quivalent une variable du mme
type (un lment dun tableau dentiers est un entier, un lment dun tableau
de chanes est une chane). Laccs la valeur dun lment quelconque du
tableau est immdiat puisque le compilateur na quun calcul simple raliser
pour dterminer lemplacement de cet lment en mmoire par rapport la
position du tableau.
Pour accder un lment dun tableau, il faut fournir une valeur pour chaque
indice (soit un indice par dimension).
Un tableau est un ensemble de variables (lments) de mme type. Ces lments
sont identifis par des indices permettant au programme daccder directement
lespace mmoire de llment requis. Attention ne pas confondre llment
dun tableau avec son indice. Bref, ne confondez pas i et t[i].
77
8 3987 TG PA 00
Types
Syntaxe de dclaration
type
nom = description
Une fois le type dfini, on peut lutiliser comme nimporte quel type de base (de
mme quune fois un sous-programme dfini, on peut sen servir comme sil avait
toujours exist).
Types structurs
Syntaxe de dclaration
type
nom = structure
variable1 : type1
variable2 : type2
...
variablen : typen
fin structure
Les variables constituant le type sont appeles des champs. Toute variable dun
type structur possde tous les champs dfinis dans le type. Lordre des champs
dans la structure na aucune importance.
Lorsque vous voulez dfinir une chose dcrite par plusieurs valeurs, il faut dfinir
un type structur. Dit autrement, un concept doit tre reprsent par une variable. Si une variable simple ne suffit pas, on dfinit un type structur contenant
toutes les informations ncessaires.
Attention, pour dclarer une variable structure, il faut avoir pralablement
dfini le type correspondant.
Accs aux valeurs des variables composes

Quand une variable en contient dautres (tableau t, structure s), il faut toujours
passer par la variable contenant pour accder une des variables contenues :
pour un tableau t, on met lindice entre crochets : t[i] identifie llment i
du tableau t ;
pour une structure s, on utilise loprateur . pour sparer la variable et
ses champs : s.champ identifie le champ champ de la variable structure s.
Avec un tableau Tab, Tab[i] identifie une variable de mme type que les lments
du tableau. Avec une structure Str contenant un champ Ch, la variable Str.Ch est
de mme type que le champ Ch.
78
8 3987 TG PA 00
Tableaux dfinis dans une structure

Chaque tableau sera accompagn dune variable entire indiquant le nombre
dlments quil contient (soit lindice du dernier lment utilis).
chaque fois que vous tes confront un tableau ayant un nombre variable
dlments (cest le cas le plus frquent), vous devez utiliser une structure (variable structure) contenant deux champs :
le tableau ;
une variable entire stockant le nombre dlments rellement utiliss. Cette
variable doit tre mise jour chaque volution du contenu du tableau.
La dfinition dun type structur est alors indispensable pour pouvoir dclarer la
structure.
Les TD qui suivent proposent des lments de cours : les algorithmes classiques
de parcours des tableaux. Si vous les matrisez, vous serez au point pour ltude
de cas.
Vous pouvez maintenant raliser le TD 1.
79
8 3987 TG PA 00
Travaux dirigs 1 : un seul tableau

Dure indicative :
4 heures
Lobjet des exercices qui suivent est de mettre en uvre de faon systmatique les concepts vus dans le cours pour que cela devienne un automatisme.
Vous allez donc manipuler tableaux et structures dans tous les sens !
Ces exercices vous permettront galement dtudier les algorithmes classiques
de manipulation des tableaux. Plus que de simples exercices dapplication, ils
sont plutt un complment de cours. Ne les bradez pas !
Enfin, faites-les dans lordre, la difficult tant croissante.
Lanne dernire, vous avez tudi les parcours de tableaux et les tris.
Nous allons revoir cela en manipulant un tableau de structures. Comme lobjet de ces exercices est de vous rendre laise avec les structures, nous allons reprendre celles de lexercice
42, savoir :
une structure Client ;
une structure TabClient contenant un tableau et un entier stockant le nombre dlments dans le tableau.
Je vous rappelle les deux types (je renomme le champ Nbrlments de TabClient en NbrClients
car jen ai assez de taper le ) :
type
Client = structure
NumClient : entier
NomClient : chane
PrnomClient : chane
AdrClient : chane
TlClient : chane
DateClient : date
fin structure
TabClient = structure
lment : tableau[1000] de Client
NbrClients : entier
fin structure
Le champ NumClient est lidentifiant du client au sens analyse (Merise) du terme. Ses diffrentes valeurs sont donc uniques.
Dans tous les exercices, vous devez crire les sous-programmes les plus gnraux possibles.
Pour ne pas alourdir les algorithmes, ne prenez nanmoins pas en compte le cas du tableau
vide. On supposera que ce sont les programmes appelant qui testeront ce cas.
le corrig du TD figure dans le fascicule Autocorrection .

tudiez-le aprs chaque exercice.
81
8 3987 TG PA 00
Exercice 1
Parcours complet dun tableau
Nous supposons ici que le champ AdrClient contient la ville du client. crivez un sous-programme comptant le nombre de clients habitant la ville dAubusson. Modifiez ensuite ce
sous-programme pour quil retourne le nombre de clients habitant une ville donne.
Exercice 2
Recherche dun lment 1/2 (parcours du tableau sous condition)
crivez un sous-programme renvoyant le nom dun client (NomClient) dun numro donn.
Attention, le numro de client est stock dans le champ NumClient, ce nest pas lindice!
Vous crirez deux sous-programmes, un pour chacune des deux hypothses suivantes :
1. on suppose que le client existe forcment ;
2. on suppose que le client demand peut ne pas exister.
Si je ne vous avais rien prcis sur lexistence du client, laquelle des deux hypothses auriezvous d prendre?
Exercice 3
Recherche dun lment 2/2 (parcours du tableau)
Dans lexercice prcdent, vous cherchiez un client prcis qui pouvait ou non exister. Je vous
demande maintenant dcrire un sous-programme retournant le client le plus ancien. Vous
supposerez que lon peut comparer les dates avec les oprateurs habituels (<, >).
Si nous grons un champ NbrClients indiquant combien de clients sont actuellement stocks
dans le tableau, cest parce que ce nombre peut varier. Nous allons maintenant travailler
dans ce cadre, en ajoutant ou en supprimant des lments du tableau.
Exercice 4
Ajout dun lment dans un tableau
crivez un sous-programme permettant dajouter un client au tableau. Faites particulirement attention aux paramtres et au choix de llment dans lequel ajouter le client.
Exercice 5
Supprimer le dernier lment dun tableau
crivez un sous-programme permettant de supprimer le dernier client de notre tableau.
82
8 3987 TG PA 00
Exercice 6
Supprimer un lment prcis dun tableau
crivez un sous-programme permettant de supprimer un client ayant un numro NumClient
donn. Pour faire cela, vous devrez crire deux sous-programmes :
un sous-programme renvoyant lindice dun client ayant un numro donn. Cela permettra de trouver quel lment doit tre supprim. Vous supposerez que le client peut
ne pas exister ;
un sous-programme supprimant un client ayant un numro donn (voir ci-dessous). Ce
sous-programme utilisera le prcdent.
Voici une petite aide pour se souvenir comment supprimer un lment dun tableau. Il faut
viter les trous : avant la suppression, on a NbrClients lments dindices 1 NbrClients.
Aprs la suppression, on en aura NbrClients-1, de 1 NbrClients-1.
Ainsi, tous les lments droite de llment supprim sont dcals dun cran vers le dbut
du tableau. Une petite mtaphore ? Imaginez une file dattente. Une des personnes faisant
la queue en a assez et sen va. Que se passe-t-il ? Pour les personnes qui sont devant celle qui
est partie, rien. Pour les autres, cest Nol : ils gagnent une place.
Faisons la manipulation sur un tableau dentiers contenant 6 lments :
8
79
Si je veux supprimer le deuxime, je vais dcaler le 3e pour le mettre dans le 2e :

8
79
79
79
79
79
Puis le 4e dans le 3e :
Et cest fini. Les esprits chagrins me diront que le 6e lment, qui devrait tre vide, contient
toujours la valeur 1. Certes. Mais maintenant, je nai plus 6 lments, mais 5. Le contenu des
6e, 7e lments na donc aucune importance. Cest le mme principe que pour lexercice
prcdent (voir sa correction).
Notez bien que lon dcale les lments en partant de llment suivant celui que lon supprime et en allant jusquau dernier. Si lon allait dans lautre sens, on effacerait les valeurs
donc cela ne fonctionnerait pas.
Au fait, soyons prcis avec le vocabulaire : techniquement, on a cras llment plus quon
ne la supprim !
83
8 3987 TG PA 00
Les exercices suivants vont traiter du tri et de la gestion des tableaux tris.
Exercice 7
Expliquez lintrt dun tableau tri par rapport un tableau non tri.
Exercice 8
crivez un sous-programme triant le tableau des clients daprs leur identifiant (NumClient).
Vous devez connatre une mthode de tri et savoir lappliquer (par exemple, le tri bulles
vu en premire anne). Il existe de nombreuses mthodes de tri, plus ou moins efficaces (en
gnral, plus elle est simple programmer, moins elle est efficace).
Je vais vous prsenter la mthode par insertion que je vous demande de programmer. Elle
nest pas plus efficace que celle bulles mais cela vous changera !
Le principe est trs simple : trier un tableau du plus petit lment au plus grand revient
mettre le plus petit en premier, puis celui juste un peu plus grand, puis le suivant et ainsi de
suite :
nous allons chercher le plus petit lment du tableau et le permuter avec le premier. On
sait alors que le premier lment est tri ;
on cherche alors le plus petit lment sans prendre en compte le premier (on va donc
de lindice 2 lindice NbrClients). On trouve alors le 2e plus petit que lon permute avec
le deuxime lment du tableau ;
on continue. la ie itration, on cherche le plus petit lment de lindice i lindice
NbrClients. On trouve alors le ie plus petit que lon permute avec le ie lment du tableau ;
on sarrte lorsque lon a trouv non pas le plus grand lment, mais celui juste avant.
On le place alors en avant-dernire position. Le dernier lment est forcment le plus
grand.
Nous allons essayer cet algorithme sur un tableau exemple. Pour bien se reprer, les cases
encadres en noir seront tries , les cases encadres en vert seront non-tries .
Prenons lexemple du tableau suivant, pas tri du tout.
5
10
On cherche le plus petit lment (cest la valeur 1 lindice 3) et on le permute avec le premier lment. On permute donc les lments dindice 1 et 3.
1
10
On cherche maintenant le plus petit lment sans prendre en compte le premier. On va donc
travailler sur les huit derniers lments. Le plus petit est alors la valeur 2 (indice 4). Je permute donc les lments dindice 2 et 4.
1
10
84
8 3987 TG PA 00
Je continue. Le plus petit lment (les deux premiers tant exclus) est la valeur 5 lindice
3. Je le permute donc avec llment lindice 3, soit avec lui-mme. Cela ne change rien
(llment tait dj bien plac).
1
10
Ensuite vient llment dindice 5 que je permute avec celui dindice 4.

1
10
Je permute ensuite llment dindice 9 avec celui dindice 5.

1
10
Il me reste les quatre derniers lments. Le plus petit de ceux-l est la valeur 8. Ce peut tre
celui dindice 7 ou 9 selon mon algorithme de recherche. Cela ne change rien. Je prends celui
dindice 7 et je le permute avec celui dindice 6.
1
10
Dans les trois derniers lments, le plus petit est mon second 8 que je permute avec llment
dindice 7.
1
10
Il ne me reste que deux lments trier. Ainsi, trouver le plus petit des deux dtermine aussi
le plus grand. Positionner le plus petit revient donc positionner le plus grand.
Le plus petit est lindice 9, je permute donc les deux dernires cases.
1
10
Jai lassurance que mon tableau est tri. Et, en effet, il lest.
Si nous avions fait encore une itration, on aurait cherch le plus petit lment parmi le
dernier et on laurait permut avec lui-mme inutile !
Pour raliser ce tri, vous aurez besoin des sous-programmes suivants :
un pour permuter deux lments (clients) dindices donns ;
un recherchant le plus petit lment dun tableau (le critre est la valeur du
champ NumClient). Attention, il faut fournir en paramtre lindice de dpart
partir duquel on cherche llment. On a vu ci-dessus qu la premire itration, on va du 1er au dernier lment, litration suivante du 2e au dernier
puis du 3e au dernier
enfin, il faut un sous-programme ralisant le tri proprement dit.
videmment, les sous-programmes sappelleront les uns les autres. Ne perdez pas de vue
que mon exemple ci-dessus triait selon les lments, tandis que lexercice demande le tri sur
NumClient, soit un champ des lments.
85
8 3987 TG PA 00
Exercice 9
crivez un sous-programme cherchant un client dun numro donn. Vous supposerez que le
tableau est tri sur les numros et que le client peut ne pas exister.
Comme le tableau est tri, il faut appliquer la recherche dichotomique vue en premire
anne.
Voici un petit rappel de cette mthode. Dans un tableau tri, on compare llment du milieu
avec celui que lon cherche :
si les deux sont gaux, on a trouv notre lment ;
si llment du milieu est plus grand, cest que llment cherch est dans la premire
moiti du tableau. On recommence donc en prenant en compte le premier demi-tableau
(lment du milieu except) ;
sil est plus petit, cest que llment cherch est dans la deuxime moiti du tableau.
On recommence donc en prenant en compte le second demi-tableau (lment du milieu
except).
Pourquoi ne prend-on jamais llment du milieu lors du dcoupage en demi-tableau ? Car,
si lon dcoupe le tableau, cest parce que cet lment du milieu nest pas celui que lon
cherche. Inutile donc de sen embarrasser ! De plus, cela permettra dobtenir une condition
darrt si lon ne trouve pas notre lment.
Vous devez donc grer deux variables : une indiquant lindice de dbut du tableau, lautre
lindice de fin. Ces variables volueront en fonction des sous-tableaux retenus. Pensez grer
une condition darrt dans la boucle pour le cas o llment nest pas prsent !
Je ne vous donne pas plus dindications car la recherche dichotomique, cest du cours : vous
devez savoir la mettre en uvre quand vous en avez besoin. Si vous avez des difficults,
excutez lalgorithme la main sur un petit tableau.
Une remarque nanmoins. Pour dterminer le milieu du tableau, ne divisez pas par 2 avec la
division relle mais utilisez div qui ralise la division entire. Par exemple :
si vous considrez le sous-tableau qui va de lindice 10 lindice 20, llment du milieu
sera lindice (10+20) div 2 soit 15 ;
avec un sous-tableau possdant un nombre pair de cases, cela fonctionne galement. Si
mon sous-tableau va des indices 11 18, llment du milieu sera lindice (11+18) div
2 soit 14. (Nous ne sommes pas parfaitement au milieu, mais cest impossible avec un
nombre pair de cases.)
Ce nest pas un exercice qui se traite en dix minutes. Prenez votre temps.
Exercice 10
Dernier exercice : je vous demande dcrire un sous-programme ajoutant un client donn au
tableau tri sur le numro NumClient. Le principe est le suivant :
il faut localiser dans quel lment du tableau on va ajouter le client. Lobjectif est que
le tableau soit toujours tri aprs lajout ;
une fois lindice trouv, il faut carter les lments de droite (qui sont plus grands) pour
faire une petite place notre lment.
86
8 3987 TG PA 00
Exemple, voici un tableau dont 8 lments sont utiliss :

1
Je souhaite ajouter la valeur 4. Elle se positionnera entre 2 et 5, donc entre les lments
dindice 2 et 3. On dcale donc vers la droite les lments des indices 3 8 (qui seront donc
aux indices 4 9) :
1
Jajoute maintenant mon 4 dans llment dindice 3 qui vient dtre libr (en pratique, je
remplace la valeur 5 lindice 3 par ma nouvelle valeur ; lancienne valeur 5 est lindice 4
depuis le dcalage) :
1
Mon tableau possde un lment de plus (donc 9 au total).

Ces deux tapes ont un got de dj vu :
la recherche de lindice o ajouter llment sera faite par dichotomie (il faudra adapter
lalgorithme de lexercice 9 en consquence) ou, moins efficace mais plus simple, par un
parcours squentiel du tableau ;
le dcalage des lments a t vu dans lexercice 6, sauf quici on dcale dans lautre
sens (on agrandit le tableau au lieu de le rtrcir).
Voici une petite aide pour la recherche de lindice o lon doit insrer le client. Il y a deux
techniques :
la plus simple mais la moins efficace consiste parcourir le tableau jusqu trouver la case
o insrer notre client. Faites attention aux cas extrmes (dbut et fin de tableau) ;
on peut aussi exploiter le fait que le tableau est tri et chercher lindice par dichotomie
en faisant semblant de chercher llment que lon veut ajouter (on sait quil nexiste
pas puisque la valeur de chaque champ NumClient est unique mais on obtient plus ou
moins sa position thorique).
La seconde technique est trs efficace mais est assez difficile mettre en uvre car il faut
extraire de nombreux cas particuliers. Je vous en dispense donc.
Finalement, je veux trois sous-programmes : le premier cherchera lindice o ajouter llment, le deuxime dcalera les lments et le troisime utilisera les prcdents pour raliser
linsertion proprement dite.
Passez suffisamment de temps sur cet exercice. Il est plus complexe que les autres. Vous devez
absolument essayer la main les techniques proposes pour tre certain de les comprendre.
Il vous faudra ensuite vrifier soigneusement vos algorithmes et notamment les cas extrmes.
Si vous arrivez faire correctement cet exercice, vous pourrez vous estimer parfaitement au
point sur la manipulation des tableaux et des structures.
Vous pouvez, ds maintenant, faire et envoyer la correction le devoir 2 (voir fascicule Devoirs rf 3987 DG).
87
8 3987 TG PA 00
Travaux dirigs 2 : deux tableaux

Dure indicative :
8 heures
Le premier TD vous avait rafrachi la mmoire concernant tout ce que lon

peut faire avec un tableau.
Ce second TD met en uvre deux tableaux lis afin de faire des recherches de
lun dans lautre. Ce genre de choses est rgulirement demand lexamen.
En effet, cest relativement court rdiger mais il faut de bonnes connaissances pour savoir le faire.
Prsentation du TD
En fait, nous allons plus ou moins reprogrammer le langage SQL (soyons modestes, plutt
moins que plus).
Dj, dans le TD prcdent, lorsque nous recherchions un client donn ou le client le plus
ancien si le tableau avait t table, nous aurions retrouv des instructions SQL classiques.
Pour garder le lien entre tableaux et base de donnes, le premier TD utilisait un seul tableau
(table). Ce dernier TD va en utiliser plusieurs. Nous allons donc raliser lquivalent de jointures.
Je men voudrais de vous sembler vieillot. Pourquoi, vous demandez-vous peut-tre, manipuler des tableaux pour muler une base de donnes et raliser des traitements assez complexes alors quune requte SQL fait cela mieux que nous ? Certes, une base de donnes est
faite pour cela. Mais est-il vraiment utile de dranger (voire dacheter) un tel outil complexe
pour raliser un traitement somme toute restreint ? On ne ralise plus de grosse application
de gestion sans base de donnes : le faire avec des fichiers et des tableaux serait de lescroquerie. Mais pour de toutes petites applications les tableaux sont au poil.
Le corrig du TD figure dans le fascicule dautocorrection.

tudiez-le aprs chaque exercice.
89
8 3987 TG PA 00
Exercice 1
Dfinissons nos types
Comme nous allons manipuler plusieurs tableaux, jen profite pour vous faire dfinir les
diffrentes donnes.
Voici le sujet sur lequel nous allons travailler. Il sagit de raliser des statistiques sur les horaires darrive des diffrents trains dans une gare donne.
Un train est caractris par son type : TGV, TER, son numro, les nombre de places en 1re et
en 2nde et sa ville dorigine (on ne stocke pas la ville darrive puisque cest systmatiquement
celle de la gare que lon informatise). Tous les trains sont stocks dans un tableau.
Pour chaque train arrivant en gare, on relve son numro et le dcalage larrive en minutes par rapport lhoraire prvu (0 pour un train lheure, -5 pour un train en avance de 5
minutes, 75 pour un retard dune heure quinze). Ces deux informations sont stockes dans
un tableau.
Pour changer un peu par rapport au TD prcdent, on supposera que 95 trains sarrtent
dans cette gare et sont donc concerns. Jinsiste : cest 95, ni 94 ou 96. Ce nombre est constant.
En revanche, on stocke les arrives des trains au fur et mesure. Un historique trop important ntant pas utile, vous dimensionnerez le tableau pour quil puisse contenir 10 000 arrives. Lorsque le tableau est plein et que vous ajoutez une nouvelle arrive, la plus ancienne
(contenue dans le premier lment) doit tre supprime.
Je vous demande de dnir les types de donnes ncessaires au stockage de ces
informations.
Exercice 2
Parcours dun seul tableau (dbut)
crivez deux sous-programmes :
un calculant la moyenne des dcalages larrive de tous les trains ;
un autre calculant le plus petit, le plus grand et le dcalage moyen dun train donn
(identifi par son numro). Attention, ce nest pas un algorithme si simple quil y parat :
il ne faut prendre en compte que les arrives concernant notre train et non toutes celles du tableau. Pour simplifier (temporairement), vous supposerez que le train existe
forcment.
Exercice 3
Parcours dun seul tableau (fin)
Rcrivez le dernier sous-programme calculant le plus petit, le plus grand et le dcalage
moyen dun train donn. Vous prendrez maintenant le cas gnral du train qui nexiste pas
forcment.
90
8 3987 TG PA 00
Exercice 4
Parcours des deux tableaux
crivez un sous-programme dterminant combien darrives de trains de type TGV ont eu
lieu en retard. (Un mme train TGV arrivant trois fois en retard sera comptabilis trois fois.)
Exercice 5
Recherche
crivez la fonction de recherche indique la fin de la correction de lexercice prcdent
(on cherche lindice dun train dont le numro est donn) puis rcrivez NbrTGVRetard en
utilisant cette fonction.
Exercice 6
crivez un algorithme complet (et donc plus seulement un sous-programme) permettant de
savoir si un train donn sarrte dans notre gare (donc sil fait partie ou non de notre tableau
des trains).
Vous supposerez que la procdure InitTrains (var Trains : tableau[95] de Train) est fournie
(vous pouvez donc vous en servir !). Elle permet de remplir le tableau des trains.
Pour les quatre derniers exercices, nous supposons que le tableau des arrives est tri par
numro de train. Ainsi, si nous avons les trains numro 15, 87 et 665, le tableau contient
dabord toutes les arrives du train 15 puis celles du train 87 et enfin celles du 665.
Exercice 7
Il ny a quun train en provenance de Limoges. Combien darrives a-t-il effectu ? (On supposera quil est arriv au moins une fois.) Faites des sous-programmes !
En premire approche, pour trouver les arrives dun train donn, nous nallons exploiter
que partiellement le fait que le tableau des arrives est tri par train : parcourez squentiellement le tableau jusqu trouver les arrives de votre train. Ensuite, vous avancerez dans le
tableau jusqu ce que les arrives ne concernent plus votre train. Comme le tableau est tri
par train, vous tes assurs de navoir loup aucune des arrives cherches.
Exercice 8
Modifiez lalgorithme prcdent en supposant que le train de Limoges peut ntre encore
jamais arriv dans notre gare.
91
8 3987 TG PA 00
Exercice 9
Cest toujours le mme sujet : combien darrives du train de Limoges ont t enregistres ?
Nous allons maintenant exploiter pleinement la potentialit de notre tableau darrives tri.
Vous allez faire une recherche dichotomique pour trouver une arrive du train cherch. Cela
vous donnera une arrive quelconque de ce train. Vous devrez donc reculer puis avancer
dans le tableau pour trouver toutes les arrives.
Voici une illustration. Prenons le tableau dentiers suivants :
1
Si je cherche les lments de valeur 4, la premire tape de la dichotomie me renvoie immdiatement (jai eu de la chance, dans le cas gnral, il faudra raliser des itrations avec
les sous-tableaux) llment dindice 5 contenant effectivement un 4. Il faut ensuite que je
recule (lments dindices 4 et 3) puis que javance (lment dindice 6) pour obtenir toutes
les occurrences de mes valeurs 4.
Bien entendu, nous nous situons toujours dans le cas gnral o le train peut ntre jamais
arriv. Quand vous reculez pour chercher les premires arrives, attention ne pas sortir du
tableau ; et quand vous avancez idem.
Exercice 10
Pour terminer cette squence de TD, je vous demande dcrire un algorithme complet
(comme dans lexercice 6) permettant dindiquer lutilisateur combien de voyageurs sont
arrivs dans notre gare en provenance dune ville donne. La SNCF vous indique que statistiquement, 65 % des places de premire et 79 % des places de seconde sont occupes.
Vous avez videmment toujours votre disposition la fonction InitTrains (var Trains :
tableau[95] de Train). De mme, vous supposerez que tout ce dont vous avez besoin concernant linitialisation du tableau des arrives est fourni.
Cet exercice nest quune extension des prcdents : il faut reprendre des bouts de code
gauche droite et les complter.
Je vous propose de commencer lexercice ds maintenant. Si vraiment vous ny arrivez pas ou,
mieux encore, une fois votre algorithme crit, lisez ce qui suit et vrifiez votre algorithme la
lumire des indications. Corrigez alors si besoin est votre travail avant dtudier la correction.
Voici quelques indications pour raliser lexercice. Partez de lexercice 9. Ce qui change, cest :
on ne cherche plus un seul train venant de Limoges, mais de 0 n trains venant dune
ville prcise. Tout le traitement de lexercice 9 doit donc tre encadr par une boucle
cherchant ces trains en parcourant le tableau des trains ;
ensuite, cest trivial mais il faut penser le faire, le nombre darrives dun train donn ne suffit plus, il faut raliser une opration arithmtique avec ce nombre et la capacit du train.
Vous pouvez raliser le TD 3.

92
8 3987 TG PA 00
Travaux dirigs 3 : sur machine

Dure indicative :
autant de temps que possible
Le dveloppement, c'est sur machine !

Savoir raisonner sur le papier, cest une chose. Mais le dveloppement dapplications doit
conduire une application !
Vous devez donc reprendre les algorithmes du cours et les coder dans un langage de programmation (par exemple WinDev dj utilis lanne dernire).
Utilisez le dbogueur, modifiez les algorithmes et voyez ce qui se passe. Cest comme cela
que vous comprendrez exactement pourquoi une boucle doit sarrter 1 et pas 0, pourquoi un test est ncessaire
93
8 3987 TG PA 00
Devoir autocorrectif
Lobjet de ce devoir autocorrectif est lcriture de sous-programmes

manipulant des liens entre tableaux. Laccent sera mis sur les diffrents parcours et accs.
Cela veut-il dire que lon peut mettre nimporte quel type de sous-programme
avec un passage par valeur ou par adresse alatoire ? Certainement pas !
Exercice 1
Nous voulons grer les notes des diffrents tudiants dune classe. Pour cela, nous disposons
de trois tableaux :
un contenant les tudiants ;
un contenant les diffrentes matires. Notez que chacune est affecte dun coefficient ;
un troisime contenant une note (et ltudiant et discipline concerns).
Voici les types concernant les tudiants :
type tudiant =
structure
Num : entier
// Numro de ltudiant (identifiant)
Nom : chane
Prnom : chane
fin structure
type Classe =
structure
t : tableau [50] dEtudiant
Nbrtudiants : entier
fin structure
Je dfinis un type Classe contenant un tableau dtudiants avec une variable Nbrtudiants
indiquant combien dlments du tableau sont effectivement initialiss (soit combien jai
dlves dans ma classe).
Il ne faut pas envoyer ce devoir la correction. Le corrig se trouve dans le

fascicule Autocorrection .
95
8 3987 TG PA 00
Voici les types concernant les matires :

type Matire =
structure
Num : entier // Numro de la matire (identifiant)
Libell : chane
Coefficient : entier
fin structure
type TabMatires =
structure
t : tableau [20] de Matire
NbrMatires : entier
fin structure
Voici les types concernant les notes :

type Note =
structure
Numtudiant : entier
NumMatire : entier
Note : entier // je suppose que les notes sont arrondies
fin structure
type TabNotes =
structure
t : tableau [1000] de Note
NbrNotes : entier
fin structure
Soyons srs de bien comprendre.
Si je veux les notes de ltudiant Nina TECKEL dans la matire Programmation, comment
faire ? Il y a trois tapes :
1. Je vais chercher dans le tableau des tudiants le numro de ltudiant Nina
TECKEL. Imaginons que ce soit 4.
2. Je vais chercher dans le tableau des matires le numro de la matire Programmation.
Imaginons que ce soit 13.
3. Dans le tableau des notes, je cherche celle de ltudiant 4 dans la matire 13.
On supposera quun tudiant possde exactement une note par matire et que le tableau des
notes est tri par matires (on a donc toutes les notes de la matire 1 puis toutes celles de
la matire 2).
96
8 3987 TG PA 00
Travail faire
1. crivez un sous-programme renvoyant la moyenne des notes pour une matire donne
(identifie par son libell). Vous supposerez que la matire existe.
Je vous rappelle que la moyenne dun tudiant se calcule en additionnant le produit de chaque note par son coefficient et en divisant le tout par la somme des coefficients.
Par exemple, si jai 15 en tude de cas (coefficient 5), 12 en preuve pratique (coefficient 3) et
19 en note de synthse (coefficient 4), ma moyenne sera :
15 x 5 + 12 x 3 + 19 x 4 187
=
= 15,58
5+3+4
12
2. crivez un sous-programme renvoyant la moyenne dun tudiant dont on vous fournit le
nom et le prnom. Attention, cet tudiant peut ne pas exister (on supposera nanmoins
quil ny a pas dhomonyme). Vous veillerez prendre en compte les coefficients des diffrentes matires.
Exercice 2
Vous avez enfin trouv enfin l'oprateur tlphonique qui est vraiment, vraiment moins cher
que tous les autres.
Le problme, cest que sa grille de tarification est la plus complexe du march :
tout appel abouti (le correspondant dcroche) est factur dun frais fixe (0,046 ) ;
les 0,046 de frais de connexion donnent droit des secondes gratuites. Combien ? Cela
dpend de la tranche horaire ;
le prix des secondes supplmentaires (au-del des secondes gratuites) dpend galement de lheure dappel.
On retrouve les vingt-quatre tranches dune heure formant une journe et numrotes de 1
24. Elles possdent deux proprits : le nombre de secondes gratuites par appel et le prix
de la seconde.
Par exemple :
la tranche horaire 0 h 1 h possde le numro 1. Les 60 premires secondes sont gratuites (incluses dans les 0,046 ) et les secondes suivantes sont factures 0,0002 . (Cest
bien peu ? Certes, mais une seconde, cest bien court !) ;
la tranche horaire 14 h 15 h possde le numro 15. Un appel pass cette heure dispose
de 28 secondes gratuites (incluses dans les 0,046 ) puis chaque seconde cote 0,0005 .
Trs fortement paranoaque, vous tes convaincu que les factures que vous recevez sont errones. Vous bricolez un circuit lectronique reli votre PC remplissant un fichier contenant,
pour chaque tranche horaire, la liste de tous les appels avec leur dure.
En effet, connatre le nombre dappels et leur dure totale nest plus suffisant cause des
premires secondes gratuites : il faut imprativement connatre la dure de chaque appel.
Vous allez ensuite crire un programme exploitant ces donnes.
La ralisation de ce botier nest pas demande.
97
8 3987 TG PA 00
Pour informatiser cela, vous dfinissez un type structur Tarif dfinissant, pour une tranche
horaire, le nombre de secondes gratuites et le tarif de la seconde supplmentaire :
type Tarif =
structure
NbrSecGratuites : entier
TarifSeconde : rel
fin structure
var
Tab Tarifs : tableau [24] de Tarif
Nous avons donc un tableau de vingt-quatre tarifs, lindice dterminant la tranche horaire.
Par exemple pour les appels pays de 14 15 h :
TabTarifs[15].NbrSecGratuites = 28 ;
TabTarifs[15].TarifSeconde = 0,0005.
Pour suivre vos communications, vous rcuprez les informations que votre botier lectronique ( ne pas raliser) a stock dans des fichiers.
Pour cela, vous avez les types suivants :
type Appel =
structure
TrancheHoraire : entier
Dure : entier
fin structure
type TypeTabAppels =
structure
t : tableau [10000] de Appel
NbrAppels : entier
fin structure
On retrouve nos tableaux contenant un nombre variable dlments. En effet, je peux passer un
seul appel, vingt, trois cents Chaque lment du champ t correspond un appel. Je mmorise
la tranche horaire (t[i].TrancheHoraire) correspondante et la dure de lappel (t[i].Dure).
Remarque importante, on considre que les appels du tableau t contenu dans la structure
TabAppels sont tris sur la tranche horaire. Cela signifie que lon aura dabord tous les appels passs entre minuit et une heure (tranche horaire 1), puis tous les appels dans la tranche horaire 2
Assurez-vous de bien avoir compris le contenu des diffrents tableaux et structures,
sinon vous ne pourrez pas crire lalgorithme demand. Je ne vous cache pas que
lessentiel de la difcult rside l. Cest dailleurs pourquoi je ne vous donne pas
dexemple de contenu de tableau.
Travail faire
crivez un sous-programme prenant en paramtre une structure de type TabAppels et un
tableau de tarifs et calculant le total payer.
98
8 3987 TG PA 00

Cours - Matière 3987 - 83987TGPA0007

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Cours - Matière 3987 - 83987TGPA0007

Загружено:

Авторское право:

Доступные форматы

BTS Informatique de gestion 2e anne

Option administrateur de rseaux locaux dentreprise

Directrice de publication : Valrie Brard-Trigo

Voici lordre dans lequel il faut exploiter tout cela :

Prsentation du support de cours

Squence 2 : Procdures et fonctions

Squence 3 : Tableaux, structures et types

Devoir autocorrectif ne pas envoyer la correction

Les variables et les types .................................................................. 11

Les boucles (rptitives) .................................................................... 23

Tant que faire .......................................................................................... 23

un commentaire permet de signaler que, mme si ce nest pas vident au premier

2B2. criture du commentaire

Les variables et les types

La syntaxe (lcriture) de la dclaration dpendra du langage utilis mais vous aurez

Pourquoi le type est-il obligatoire ?

3B3. Allons plus loin

Voil ltat de la mmoire au commencement. Jinsiste : le contenu des cases A1 J4 ne

Tableau des variables

3D2. Dclaration des variables

Tableau des variables

3D3. Valeur avant initialisation

3D4. Initialisation des variables

Tableau des variables

3D5. Modifications des variables

Tableau des variables

Tableau des variables

Les deux instructions prcdentes ont sur la mmoire limpact suivant :

Tableau des variables

3D7. Fin du programme

Tableau des variables

Observez bien le contenu des cases :

Pourquoi tant de dtails ?

Manipulation des variables

// AgePersonne est lue

On peut afficher lcran ( destination de lutilisateur) la valeur dune variable avec

Cela appelle deux remarques.

Les boucles (rptitives)

Tant que faire

En paraphrasant linstruction, on peut dire que :

5B1. Comparons Tant que et rpter

la 1re excution de la boucle

REPETER ... JUSQU'A

Conclusion sur les boucles

Syntaxe gnrale dun algorithme

Le fonctionnement de cette instruction est le suivant :

la 1re excution de la boucle

REPETER ... JUSQU'A

2.2 [si entier1 > entier2 et donc entier3 < 0]

Les procdures et les fonctions ...................................................... 36

Les paramtres ...................................................................................... 40

Les procdures et les fonctions

Mais, ds prsent, nous retiendrons :

01 fonction Nom3 (paramtres) : type

01 fonction Nom4 (paramtres) : type

Les deux fonctions sont incorrectes :

2B4. Smantique des sous-programmes

fonction Maximum (n1 : rel, n2 : rel) : rel

Je voudrais attirer votre attention sur un point trs important.

Tableau des variables

Jinsiste : du point de vue du programme qui sexcute, la mmoire est vide.

Tableau des variables

3C1. Premier cas : passage par valeur