Centre Informatique pour les Lettres

et les Sciences Humaines

Apprendre C++ avec Qt : Leon 1
Principes fondamentaux






1 - Du langage machine aux langages de haut niveau .............................................................. 2
2 - Programmer ........................................................................................................................ 3
3 - Codage de l'information en mmoire.................................................................................... 4
La case mmoire vue comme un nombre entier sans signe ..............................................5
La case mmoire vue comme un nombre entier relatif .....................................................6
Autres faons de voir dans la mmoire une quantit numrique......................................6
Et pour reprsenter autre chose que des nombres ? ........................................................7
Rcration.......................................................................................................................8
4 - Traiter l'information............................................................................................................ 9
Accder l'information....................................................................................................9
Modifier l'information ....................................................................................................11
5 - Bon, c'est gentil tout a, mais a fait dj 10 pages. Qu'est-ce que je dois vraiment en
retenir ?............................................................................................................................. 12
6 - J'ai rien compris, est-ce que quelqu'un d'autre pourrait m'expliquer a un peu plus
clairement ?....................................................................................................................... 12
Pour aller moins vite......................................................................................................12
Pour aller plus loin........................................................................................................12

Document du 08/01/07 - Retrouvez la version la plus rcente sur http://www.up.univ-mrs.fr/wcpp
C++ - Leon 1 Principes fondamentaux 2/12
1 - Du langage machine aux langages de haut niveau
Le fonctionnement d'un ordinateur repose sur l'excution de programmes. Au sens propre, un
programme est une liste d'instructions dont l'excution produit un rsultat utile ou agrable
l'utilisateur de la machine
1
.

Pour qu'une liste d'instructions soit excutable, il faut qu'elle ne se compose que d'instructions
faisant partie du "vocabulaire" de base du processeur
2
. Rdiger de telles listes prsente deux
inconvnients majeurs :

- Le vocabulaire de base d'un processeur ne comporte que des instructions correspondant
des oprations trs lmentaires. Exprimer la dcomposition d'une tche humainement
significative dans ce "langage machine" est trs long et trs difficile.

- Les diffrents processeurs disponibles sur le march ont chacun leur vocabulaire de base. Ce
qui constitue un programme pour l'un d'entre eux n'est qu'un charabia inutilisable pour les
autres. Etant donn la difficult d'criture des programmes et la rapidit de l'volution
technologique des processeurs, la complexit maximale d'un programme pouvant tre crit
pour un processeur donn avant que celui-ci ne cesse d'tre fabriqu est svrement limite.

Ces deux inconvnients ont, depuis longtemps, conduit une consquence trs simple : on
n'crit plus que trs exceptionnellement des programmes.

Comme, par ailleurs, le besoin de faire sans cesse effectuer de nouvelles tches par les
ordinateurs semble peu prs universellement rpandu, il a fallu trouver un artifice rendant
possible la production de programmes dans des conditions conomiquement acceptables : les
programmes ne sont plus crits (par des humains) mais gnrs automatiquement (par les
ordinateurs eux-mmes).

Cette stratgie repose sur la mise au point de deux lments essentiels : un langage
informatique permettant de dcrire facilement la tche effectuer, et un dispositif de
traduction automatique permettant de produire un programme dont l'excution effectue la
tche dcrite. Ce double objectif (facilit de description des tches / possibilit d'une
traduction automatique) donne videmment naissance des contraintes contradictoires : le
langage de programmation idal devrait tre aussi proche que possible du langage naturel, ce
qui le rendrait facile apprendre et permettrait de dcrire aisment les traitements souhaits
3
,
tout en vitant de trop s'loigner du langage de la machine, parce que cela augmente la
difficult de la traduction automatique (ou la rend mme irralisable) et diminue gnralement
l'efficacit des programmes gnrs. La ncessit de trouver un compromis entre ces deux
ples, jointe la diversit des tches envisages, a donn naissance une pliade de langages
qui ont connu des fortunes diverses : Fortran, Cobol, Basic, Algol, Pascal, Lisp ou Ada ne sont
que quelques-uns des plus connus.

Selon les estimations disponibles, plus de 1000 langages de programmation ont t mis au
point (c'est dire qu'on ne les a pas simplement conus, mais qu'on a effectivement produit
les outils de traduction automatique correspondants) au cours de la seconde moiti du XX
sicle.

A l'heure actuelle, la technique de traduction automatique la plus souvent employe est la
compilation : le programmeur crit un texte source dans le langage de programmation de son
choix, puis fait appel un programme capable de traduire ce texte en une suite d'instructions
excutables par le processeur vis (ce qu'on appelle le code objet). Pour rellement donner
naissance un programme excutable, ce code objet doit encore tre adapt son contexte
d'utilisation (et, en particulier, aux us et coutumes imposs par le systme d'exploitation en
vigueur) et, ventuellement, combin avec d'autres fragments de code objet prexistants,
auxquels il peut sous-traiter certains aspects de sa tche. Cette opration, connue sous le nom
d'dition de liens, est excute par un programme qu'on appelle un linker. L'ensemble du
processus de cration d'un programme comporte donc trois phases, et peut tre rsum par le
tableau suivant :


1
Par "utilisateur de la machine", il faut entendre "celui qui est l'origine de l'excution du programme". Dans le cas
d'un virus, par exemple, le rsultat est rarement utile ou agrable celui qui est assis en face de l'cran
2
Le processeur est le composant (ou le groupe de composants) lectronique(s) qui, au sein d'un ordinateur, assure
l'excution des programmes.
3
Ce point mriterait sans doute d'tre dbattu, mais cela nous entranerait un peu loin de notre sujet.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 3/12
Nom de l'opration Produit Responsable Objectif
Rdaction Texte source
Programmeur
(tre humain)
Dcrire la procdure suivre pour parvenir
au rsultat souhait
Compilation Code objet
Compilateur
(programme)
Traduire le texte source en une suite
d'instructions excutables par le
processeur vis.
Edition de liens
Programme
excutable
Linker
(programme)
Greffer sur le code objet tout ce qui lui
manque pour devenir un programme
excutable dans le contexte vis.

Il est vident que, mme si de nouveaux compilateurs et linkers peuvent souvent tre crits
en faisant appel des versions antrieures de ces programmes, il faut bien que, un moment
donn, quelqu'un se donne le mal d'crire directement un programme (en langage machine).
En fait, la cration d'un compilateur n'est pas entreprise a posteriori, une fois le processeur
fabriqu. C'est au contraire une opration troitement lie la conception mme d'un
nouveau processeur, car l'avenir commercial de celui-ci dpend de faon cruciale de la
possibilit de raliser des compilateurs efficaces.

Ces dfinitions tant poses, il faut bien reconnatre que le langage courant emploie presque
systmatiquement le mot programme pour dsigner un texte source. Bien que ce terme soit
clairement impropre (puisque aucun processeur n'est capable d'excuter directement un texte
source), ce raccourci verbal est justifi par le fait qu'il est possible de traduire, de faon
entirement automatique, le texte source en un programme. La nuance n'a donc d'importance
que pour les programmeurs (notamment parce qu'ils doivent mettre en uvre le processus de
traduction), et, sauf s'ils sont vraiment extrmement dbutants, il n'y a aucun risque de
confusion dans leur esprit ! On considre habituellement que, ds la deuxime page d'un cours
de programmation, le lecteur a atteint un niveau de comptence tel qu'il n'y a plus de risque
d'erreur, et on s'autorise donc lui parler normalement : le mot programme dsigne alors,
selon le contexte, soit du texte source, soit du code excutable, et c'est seulement lorsque
l'ambigut est relle que la terminologie exacte est mobilise.
2 - Programmer
Mme si le recours un langage de haut niveau nous isole de faon assez efficace du dtail des
instructions composant le "vocabulaire" d'un processeur, il n'est pas rellement possible
d'crire des programmes sans avoir conscience de certaines ralits bassement matrielles.

La premire de ces ralits incontournables est que la seule chose sur laquelle le processeur
peut agir directement est la mmoire de l'ordinateur. Fondamentalement, toutes les
instructions excutables ne font que modifier le contenu de certaines parties de la mmoire, en
fonction du contenu d'autres parties de cette mme mmoire. L'criture d'un programme
traitant un problme quelconque exige donc de surmonter trois difficults. Il faut :
- reprsenter l'tat initial de la situation sous forme de donnes contenues dans la mmoire.
- numrer les oprations qui transforment les donnes reprsentant l'tat initial en donnes
reprsentant l'tat souhait (ce qu'on appelle les rsultats).
- permettre l'utilisateur du programme d'interprter les rsultats obtenus comme une
reprsentation de la solution qu'il attend.

Dans un exemple trs simple, ces difficults sont surmontes si facilement qu'on risque d'avoir
du mal les percevoir. Ainsi, si le problme rsoudre est le calcul de la surface d'un rectangle
partir de sa largeur et de sa longueur, reprsenter l'tat initial se rsume stocker ces deux
valeurs en mmoire, et le traitement qui conduit au rsultat dsir est une simple
multiplication dont il suffit, pour satisfaire l'utilisateur, d'afficher le rsultat.

Notons tout de mme, au passage, que cette simplicit provient en grande partie du fait que
la plupart des langages de programmation permettent de manipuler directement les quantits
numriques (que ce soit pour les stocker en mmoire, les multiplier entre elles ou les
reprsenter sur un cran en respectant les conventions habituelles). Les trois difficults sont
donc invisibles (car prises en charge par le langage lui-mme) plutt qu'absentes.

Si le problme est plus complexe, et en particulier si l'utilisateur ne l'envisage pas comme un
problme numrique, les exigences de l'entreprise deviennent plus apparentes. Un tre humain
qui joue aux checs contre un ordinateur, par exemple, n'a aucune ide du type de
reprsentation utilis par la machine. Il serait notamment assez surpris d'apprendre que
l'chiquier imaginaire sur lequel l'ordinateur effectue ses calculs comporte plus de 64 cases.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 4/12
Dans le cas de jeux se droulant sur un plateau, il est en effet parfois plus simple pour le
programmeur d'envisager un plateau plus grand que les rgles normales ne le prvoient, et
d'ajouter des rgles rendant impossible l'accs cette surface supplmentaire.

Lorsque le programmeur est conduit, pour reprsenter la situation initiale et dcrire les
traitements lui appliquer, s'carter ce point de la reprsentation sur laquelle s'appuie
l'utilisateur, la troisime difficult devient plus manifeste : il est clair qu'il faut retraduire le
rsultat du calcul (qui risque fort, dans notre exemple, de n'tre pour le programmeur qu'une
matrice de nombres) dans une forme plus intelligible (l'nonc d'un coup jouer, voire mme
une reprsentation graphique de l'chiquier).

Un autre point dont il est essentiel d'avoir conscience est l'interdpendance troite qui lie la
reprsentation de la situation sous forme de donnes et la logique des oprations susceptibles
de conduire la solution recherche. L'explicitation de cette logique (ce qu'on appelle un
algorithme du problme) dpend videmment des instructions disponibles dans le langage
utilis
4
, mais, mme dans un langage donn, un mme problme peut donner lieu plusieurs
analyses, conduisant chacune des reprsentations de l'tat initial extrmement diffrentes et
des traitements ayant fort peu de points communs.

Il est difficile de proposer un exemple de cette situation sans entrer dans des dtails
techniques un peu prmaturs. A titre anecdotique, je me souviens avoir consacr un week-
end pluvieux l'criture d'un programme rsolvant le problme du solitaire (un plateau en
forme de croix o sont places des billes : elles peuvent se "prendre" les unes les autres un
peu comme les pions du jeu de dames, et il faut faire en sorte qu'il n'en reste qu'une). Ce
programme reposait sur une reprsentation du plateau et des billes restantes, et le texte
source occupait une douzaine de pages. J'ai crit, par la suite, un second programme, bas
celui-ci sur l'inventaire des mouvements possibles, sans reprsentation explicite du plateau et
des billes. Le texte source n'occupait plus qu'une page et demi, mais son criture m'avait
galement cot un week-end. Anecdote l'intrieur de l'anecdote : la dcouverte d'une
solution prenait presque deux fois plus longtemps ce second programme qu'au premier.

Les dbutants ont souvent spontanment tendance ne voir dans un langage de
programmation qu'une collection d'instructions qu'il s'agirait de mmoriser pour ensuite jouer
les combiner de faon astucieuse. Cette illusion est souvent renforce par la pratique
d'exercices dont les noncs contiennent dj, de faon plus ou moins explicite, le choix d'une
certaine faon de reprsenter le problme sous forme de donnes. Ce choix dtermine
largement l'approche algorithmique qui va pouvoir tre mise en uvre, et l'ensemble rduit trs
efficacement l'activit de programmation une simple dmonstration de dextrit syntaxique. Il
s'agit l d'une catastrophe didactique majeure, d'o l'tudiant ne peut ressortir qu'avec une
illusion de comptence qui ne manquera pas de s'crouler ds sa premire confrontation avec
un problme rel (c'est dire un problme ne se prsentant pas sous la forme d'un exercice
dont l'nonc fournit plus de 90% de l'une des solutions possibles).

Un langage de programmation est, en fait, une faon de comprendre les problmes et d'essayer
de les rsoudre. Son utilisation commence, bien avant l'criture de la moindre ligne de texte
source, lorsque se pose la question : "Ce problme pourrait-il tre rsolu par un ordinateur ?"
La rflexion porte alors tout autant sur la description du problme en termes informatiques
que sur la dcouverte des voies conduisant sa solution, car les deux choses sont
indissociables. On comprend donc bien qu'il ne saurait tre question d'apprendre un langage
de programmation sans se pencher trs srieusement sur les moyens qu'il emploie pour
reprsenter l'information.
3 - Codage de l'information en mmoire
Du point de vue qui nous intresse (celui d'un programmeur utilisant le langage C++), la
mmoire d'un ordinateur peut tre dcrite comme une collection de dispositifs lectroniques
dont chacun se trouve, tout moment, dans l'un de deux tats possibles. Ces dispositifs ne
sont jamais manipuls individuellement : ils sont regroups huit par huit pour former ce qu'on
peut appeler une case mmoire.

- L'usage du mot "mmoire" est justifi par le fait que ces cases prsentent trois
caractristiques fondamentales : elles sont stables (l'tat d'une case mmoire ne change pas

4
Si les Djinns habitaient nos ordinateurs au lieu de prfrer les lampes huile, le seul langage de programmation dont
nous aurions besoin ne comporterait qu'une seule instruction, qui serait aussi un algorithme de tous les problmes
envisageables : "Rsous !" Mais il faudrait quand mme, d'une faon ou d'une autre, exposer les donnes du problme.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 5/12
spontanment, mais reste immuable tant que le programme en cours d'excution ne le
modifie pas), modifiables (l'excution de certaines instructions d'un programme peut avoir
pour effet de changer l'tat d'une case mmoire) et consultables (un programme peut accder
l'tat d'une case mmoire pour, par exemple, entreprendre des traitements diffrents en
fonction de cet tat).

Par dfinition, un dispositif binaire (c'est--dire pouvant adopter l'un de deux tats stables)
contient une quantit d'information gale un bit. Lorsqu'un systme comporte plusieurs de
ces dispositifs, la quantit d'information qui peut y tre stocke est d'autant de bits, et elle
peut tre apprhende en dnombrant les diffrents tats que ce systme peut adopter.

Pour pouvoir reprsenter les choses sur le papier, on peut dcider de figurer les dispositifs
binaires en question sous la forme de petits carrs dont les deux tats sont "non coch" et
"coch". Un systme limit 1 bit n'a que 2 tats possibles, qui sont alors reprsents par

et , alors qu'un systme disposant de 2 bits a 4 tats possibles : , , et .
D'une faon gnrale, l'ajout un systme d'un dispositif binaire supplmentaire double le
nombre d'tats possibles. En effet, tous les tats antrieurement possibles existent ensuite en
deux versions : l'une avec le nouveau dispositif dans l'un des tats, l'autre avec le nouveau
dispositif dans l'autre tat. Un ensemble de n bits peut donc adopter 2
n
tats diffrents.

Les cases mmoires tant, nous l'avons vu, des groupes de 8 dispositifs binaires, elles peuvent
contenir une quantit d'information gale 8 bits (ce qu'on appelle un octet) et le nombre
d'tats diffrents possibles pour chacune d'entre elles est 2
8
, soit 256. Si l'on choisit de
"remplir" les cases en commenant par la droite et en progressant systmatiquement de faon
n'oublier aucune combinaison, on peut facilement retrouver ces 256 tats diffrents :







et ainsi de suite (je n'ai ni le courage ni la place de les reprsenter tous !), jusqu'





En dpit de sa simplicit extrme, la mmoire de l'ordinateur pose un srieux problme de
comprhension aux tres humains normaux qui y sont confronts pour la premire fois. Ce
problme tient au fait que cette mmoire contient de l'information pure, c'est dire dnue de
toute signification. Pour que les choses prennent un sens (et donc un intrt), il va nous falloir
attribuer un sens cette information. Cette attribution est parfaitement arbitraire
(conventionnelle) et l'ordinateur lui-mme y reste totalement tranger (rappel : l'ordinateur en
question n'est jamais qu'un tas de ferraille dans lequel circule du courant lectrique, il n'est
donc pas question que l'information ait un sens pour lui).

Avant d'en venir au processus par lequel un programmeur attribue du sens l'information
stocke dans la mmoire de l'ordinateur, examinons quelques-unes des interprtations les plus
simples et les plus classiques. Nous allons commencer par envisager diffrentes faons
d'attribuer une signification numrique au contenu de la mmoire. Bien qu'elle ne soit pas plus
lgitime qu'une autre, cette interprtation est tellement courante que beaucoup de gens
oublient qu'il ne s'agit que d'une interprtation, et finissent par s'imaginer que les ordinateurs
manipulent des nombres.
La case mmoire vue comme un nombre entier sans signe
Il s'agit certainement de l'interprtation qui exige le moins d'effort d'imagination, puisqu'elle
repose simplement sur la reprsentation des deux tats binaires l'aide des chiffres 0 et 1.
Dans ces conditions, une case mmoire se trouvant dans l'tat


sera reprsente par
1 1 0 0 0 0 0 1
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 6/12
ce qui ressemble trangement un nombre. Comme les seuls chiffres qui peuvent y figurer
sont 0 et 1, il est trs tentant de poursuivre la mtaphore en imaginant que le nombre en
question n'est pas en base 10, mais en base 2, et c'est ce qu'on fait habituellement. La
transcription dcimale de ce nombre tant 193, on s'autorise dire dans ce contexte que la
case mmoire "contient la valeur 193".

Si vous en prouvez le besoin, vous pouvez vous reporter l'Annexe 0, "Combien avez-vous
de doigts ?", qui propose un petit rappel sur diffrentes faons de reprsenter les nombres
entiers et, notamment, sur la faon de passer d'une reprsentation binaire la reprsentation
dcimale habituelle.

Lorsqu'une case mmoire est interprte de cette faon, ses 256 tats possibles reprsentent
donc les nombres entiers compris entre 0 et 255 (nombres dont les reprsentations binaires
sont respectivement 0000 0000 et 1111 1111).
La case mmoire vue comme un nombre entier relatif
Etant donn que la case mmoire n'a que 256 tats possibles, la reprsentation d'un certain
nombre de valeurs ngatives ne peut se faire qu'en sacrifiant la possibilit de reprsenter
certaines des valeurs positives qui taient autorises dans l'hypothse prcdente. On peut
imaginer toutes sortes de conventions, mais celle qui est habituellement adopte
5
est de
reprsenter l'intervalle [-128, 127] de la faon suivante :

- Zro et les nombres positifs sont reprsents comme s'ils taient sans signe. Ils utilisent donc
les 128 patterns allant de 0000 0000 0111 1111

- Pour reprsenter un nombre ngatif, on lui ajoute 256 et on reprsente le rsultat comme si
la case mmoire contenait un entier sans signe. Cette addition a simplement pour effet de
"projeter" les valeurs de l'intervalle [-128, -1] sur les valeurs positives "interdites", c'est--dire
l'intervalle [128, 255].

valeur reprsenter valeur + 256 reprsentation binaire
- 128 128 1000 0000
- 127 129 1000 0001
- 126 130 1000 0010

- 3 253 1111 1101
- 2 254 1111 1110
- 1 255 1111 1111

Notons ds prsent que la case mmoire se trouvant dans l'tat


peut toujours tre reprsente par
1 1 0 0 0 0 0 1
mais qu'il n'est maintenant plus question de prtendre qu'elle "contient la valeur 193". Dans
l'hypothse o il s'agit de la reprsentation d'un entier relatif, nous sommes conduit dire
qu'elle "contient la valeur -63" (c'est -63 qui est reprsent ainsi, car -63 + 256 = 193).
Autres faons de voir dans la mmoire une quantit numrique
Le fait qu'une case mmoire ne puisse adopter que 256 tats diffrents limite svrement, nous
venons de le constater, les valeurs numriques qu'on peut convenir d'y voir. Que se passe-t-il
lorsqu'on a besoin de manipuler des nombres beaucoup plus grands ?

La rponse est trs simple : il suffit d'utiliser plusieurs cases de mmoire. Si on mobilise une
seconde case pour reprsenter un nombre entier positif, la reprsentation binaire de celui-ci
s'tend sur 16 bits, et ses valeurs possibles vont de 0 65 535. Si cet intervalle ne suffit
toujours pas, on peut bien entendu utiliser davantage de mmoire. Avec quatre cases mmoire
(et donc 32 bits), la plage des valeurs possibles pour un entier non sign
6
s'tend de 0
4 294 967 295, ce qui devrait normalement vous suffire pour compter vos conomies (mme si
vous les exprimez encore en centimes de Franc).

5
Ce choix prsente en effet l'avantage dterminant de permettre d'additionner de la mme faon les entiers, qu'ils
soient positifs ou ngatifs.
6
Le principe de reprsentation des nombres ngatifs dcrit plus haut sur un seul octet peut, sans difficults
particulires, tre gnralis aux reprsentations faisant intervenir plusieurs cases de mmoire.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 7/12
Il est galement possible d'tablir des conventions permettant de reprsenter des quantits non
entires sous forme binaire, et donc de les stocker en mmoire. Le systme le plus usit est la
reprsentation dite "flottante", qui consiste ramener la valeur du nombre reprsenter entre
1 et 2 (par multiplication par une puissance de 2) et stocker d'une part ce rsultat, et d'autre
part la puissance de 2 qui a t utilise dans la multiplication. Les seules choses vraiment
importantes retenir propos de ce systme sont d'une part qu'il est pratiquement inutilisable
pour des tres humains
7
et, d'autre part, qu'il offre une prcision dpendant non seulement du
nombre de cases mmoire utilises, mais aussi de l'ordre de grandeur des nombres. En
d'autres termes, si la reprsentation de 0. 0000000001 et celle de
0. 0000000002 sont bien diffrentes,
il n'est pas certain que celles de 123456789123456789. 0000000001 et
123456789123456789. 0000000002 le soient aussi.

Lorsqu'on utilise plusieurs cases de mmoire pour reprsenter une seule quantit, l'ide mme
que l'une de ces cases pourrait avoir un "contenu" (c'est dire un sens) pose problme.
Chacune des cases n'a qu'un "tat", et ce n'est que collectivement qu'elles peuvent tre
interprtes, c'est dire se voir attribuer un sens.
Et pour reprsenter autre chose que des nombres ?
Un certain nombre de choses a priori non numriques se laissent aisment reprsenter par des
tats de la mmoire. C'est notamment le cas pour tous les systmes bass sur un ensemble de
symboles distincts (les lettres de l'alphabet ou les notes de musique, par exemple). Il suffit
d'attribuer chacun de ces symboles un tat diffrent de la mmoire, qui servira le
reprsenter. Chacun des tats de la mmoire ainsi utiliss possde donc une interprtation
unique, si l'on sait qu'il reprsente un de ces symboles.

Dans le cas des caractres alphabtiques et des autres symboles habituellement utiliss pour
crire (chiffres, signes de ponctuation, etc.), une des conventions les plus utilises est celle
connue sous le nom de "code ASCII". Il s'agit simplement d'une mise en correspondance
arbitraire de ces symboles avec des patterns de bits. Le caractre 'A', par exemple, se trouve
ainsi associ au pattern . Comme ce pattern peut galement tre interprt
comme la reprsentation du nombre 65, on dit habituellement que le code ASCII de 'A' est 65,
ce qui est clairement un abus de langage. Il vaudrait mieux dire que le caractre 'A' et le
nombre 65 sont reprsents selon des conventions diffrentes, qui conduisent l'une et l'autre
au mme pattern de bits. Le rapport entre la lettre 'A' et la quantit 65 est assez semblable
celui qui lie la quantit 4 l'appareil qui sert faire cuire les gteaux : dans un certain
systme de codage, cet appareil est reprsent par "four", et une pure concidence fait que,
dans un autre systme de codage (la langue anglaise) la quantit 4 se trouve, elle aussi,
reprsente par "four". Bien entendu, les langues "naturelles" telles que l'anglais ou le
franais disposent d'un grand nombre de squences de lettres susceptibles de reprsenter
des mots, et la plupart d'entre elles restent inutilises, ce qui rend ce genre de concidences
assez rares. Tous les tats de la mmoire sont, en revanche, susceptibles d'tre lus comme
des nombres entiers, et la concidence devient ici systmatique. Comme nous le verrons au
cours de la Leon 2, ce phnomne permet au langage C++ de rduire les caractres
typographiques une simple faon un peu particulire d'afficher les valeurs entires.

Il n'y a gure plus de difficults dans le cas des phnomnes mesurables : s'il semble, par
exemple, difficilement envisageable de reprsenter une temprature, il n'y a en revanche aucun
problme pour en reprsenter une mesure (puisque celle-ci s'exprime sous forme numrique),
et ceci suffit pour traiter un grand nombre de questions faisant intervenir la temprature.

Un cas voisin, quoique lgrement plus complexe, est celui des phnomnes qui peuvent tre
dcrits par plusieurs mesures. Une couleur, par exemple, peut tre reprsente de faon
satisfaisante sous la forme des quantits relatives de rouge, vert et bleu qui la composent.

Cette faon de reprsenter les couleurs a une pertinence particulire en micro-informatique
car elle correspond directement la technologie de l'cran cathodique. D'une certaine faon,
le rouge, le vert et le bleu sont des ralits concrtes accessibles l'ordinateur (dans le
contexte de l'affichage l'cran).

Certains phnomnes posent un autre type de problme : une image, par exemple, peut tre
reprsente sous la forme d'un (vraiment) trs grand nombre de points. La rptition de la
mesure donne ici la cl de la reprsentation, et cette technique n'est envisageable que parce

7
Les oprations ncessaires pour passer de la reprsentation dcimale une reprsentation flottante (et inversement)
sont assez lourdes, et les calculs usuels (addition, multiplication) ne sont pas particulirement faciles effectuer sur
des quantits reprsentes en notation flottante.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 8/12
que la quantit d'information stockable en mmoire est considrable. Il est, par ailleurs,
possible que la mesure qui se trouve rpte soit elle-mme compose : si chacun des points
est dcrit en termes de rouge, de vert et de bleu, l'image reprsente est en couleurs.

Tout tat de la mmoire peut tre interprt comme reprsentant une quantit numrique
(nous avons mme vu qu'il existait plusieurs faons de faire une telle interprtation). Il est
donc clair que, si un tat d'un phnomne est reprsent dans une section de la mmoire d'un
ordinateur, cet tat du phnomne se trouve, par-l mme, associ une reprsentation
numrique, c'est dire mesur. Cette mesure peut tre multidimensionnelle (comme dans
l'exemple de la couleur) ou, l'autre extrmit de l'chelle du raffinement, n'tre que purement
nominale (comme dans le cas des lettres de l'alphabet), mais il s'agit bien, dans tous les cas,
d'une mesure. Nous sommes donc implacablement conduits conclure qu'un phnomne n'est
reprsentable en mmoire que pour autant qu'il est mesurable.

Mme si ce type de reprsentation ne permet de capturer que fragmentairement la ralit, ses
limitations sont moins drastiques qu'on pourrait le croire a priori. Il y a quelques annes, la
conclusion laquelle nous venons d'aboutir sonnait, dans les oreilles du public, comme une
sentence relguant les ordinateurs dans les laboratoires scientifiques et autres services de la
comptabilit. Maintenant que le tlphone, la hi-fi, la vido et les bibliothques sont
"numriques", l'illusion inverse devient plus frquente, selon laquelle tout serait parfaitement
mesurable (ou, pour employer l'euphmisme la mode, "numrisable").

La reprsentation d'tats du monde un peu complexes fait le plus souvent appel la
description d'objets dont une seule mesure ne peut rendre compte d'une faon suffisant la
rsolution du problme envisag. Le programmeur est donc conduit mettre en place des
conventions assez labores, qui lient certains tats de la mmoire certaines proprits
mesurables des objets manipuls. L'exemple de la couleur, reprsente par une mesure sur
chacune de ses composantes rouge, verte et bleue, illustre de faon simple cette faon de
procder. Faire en sorte que toutes les oprations effectues sur les cases mmoire dcrivant
les objets restent compatibles avec les conventions de reprsentation adoptes est une des
tches du programmeur (et ce n'est pas la plus facile). Dans l'exemple des couleurs, il semble
vident qu'une opration telle que le mlange de deux couleurs pour en produire une troisime
ne pourra tre dfinie qu'en respectant le sens attribu chacun des trois nombres
reprsentant chaque couleur. Un traitement qui multiplierait, par exemple, la mesure du rouge
dans l'une des couleurs par la mesure du vert dans l'autre aurait peu de chances de
correspondre une opration interprtable dans le cadre du systme adopt pour reprsenter
les couleurs. Une des caractristiques majeures du langage C++ est l'ensemble de moyens qu'il
propose au programmeur pour l'aider assurer cette compatibilit entre conventions de
reprsentation et traitements, mais l'tude de ces moyens ncessite un examen pralable de la
faon dont un processeur opre des traitements.
Rcration
Avant que nous ne nous engagions dans cet examen, il serait peut tre utile d'essayer de
concrtiser un peu les notions que nous venons d'introduire. Le programme Visuram va nous
permettre de jouer directement avec la mmoire, et de voir comment ses diffrents tats
peuvent tre interprts. L'affichage propos par Visuram prsente trois zones :
- une barre d'outils (initialement prsente verticalement, gauche de la fentre)
- une reprsentation d'une zone de mmoire sous la forme de petits carrs
- une zone de texte o s'affichent certaines interprtations possibles de l'tat de la zone de
mmoire considre.

La zone de mmoire est reprsente l'aide
du symbolisme que nous avons utilis dans
les paragraphes prcdents : les deux tats
des dispositifs binaires sont figurs par et
. Pour changer l'tat d'un de ces
dispositifs, il suffit de cliquer sur le carr qui
le reprsente.

La barre d'outils comporte quatre boutons
qui permettent de fixer la taille de la zone de
mmoire considre (1, 2, 3 ou 4 cases). Elle

La fentre principale de Visuram
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 9/12
comporte aussi un bouton qui permet de mettre toute la zone de mmoire dans l'tat , un
bouton ( ) qui met la zone de mmoire dans un tat fix au hasard et un bouton qui permet
de mettre toute la zone de mmoire dans l'tat .

Visuram est galement un exemple du genre de programmes que vous serez, d'ici quelques
semaines, en mesure de crer (mme si on peut supposer que vos propres crations ne
s'intresseront gure la reprsentation en mmoire des quantits numriques !).

Quelques suggestions d'exercices :

Commencez avec une zone de mmoire rduite une seule case :
- Essayez de retrouver les reprsentations des quatre premiers entiers positifs.
- Essayez de faire de mme pour les quatre premiers entiers ngatifs.
- Trouvez la reprsentation du nombre 128.
- Trouvez la reprsentation du caractre 'C' (vous connaissez la reprsentation de 'A', et vous
pouvez tirer parti du fait que les lettres sont reprsentes dans l'ordre alphabtique).
- Vrifiez que vous comprenez comment sont obtenues les transcriptions binaires et
hexadcimales des diffrents tats.

Passez ensuite une zone de mmoire comportant deux cases :
- Essayez de retrouver les reprsentations des quatre premiers entiers positifs.
- Trouvez la reprsentation du nombre 256.
- Trouvez la reprsentation du nombre 32 768.
- Vrifiez que vous comprenez comment sont obtenues les transcriptions binaires et
hexadcimales des diffrents tats (en particulier, comprenez vous ce que veut dire "little
endian" ?).

Avec une zone comportant trois cases :
- Trouvez un rouge, un vert et un bleu vifs.
- Essayez de trouver un jaune vif.

Avec une zone comportant quatre cases :
- Jouez un peu avec l'tat de la mmoire en observant l'effet de vos manipulations sur
l'interprtation dcimale, mais
- N'essayez surtout pas de retrouver la reprsentation du nombre 3.14
4 - Traiter l'information
Si la mmoire contient des reprsentations de l'tat actuel de certains objets, un des premiers
problmes qui se posent est de pouvoir, lorsqu'on crit un programme, spcifier sur lequel de
ces objets les oprations dcrites doivent tre effectues.
Accder l'information
Fondamentalement, le processeur ne dispose que d'un seul moyen pour distinguer les cases
mmoires les unes des autres : elles sont numrotes et chacune d'entre elles peut donc tre
dsigne sans ambigut par le numro qu'elle porte. On a l'habitude d'appeler ces numros
des adresses, et il est commode de se reprsenter les cases mmoires comme autant
d'immeubles aligns le long d'une unique et trs longue avenue. Dans ces conditions, une
adresse (au sens que donne un chauffeur de taxi ce mot) se rduit effectivement un numro
qui permet de retrouver l'immeuble dsign, tout comme l'adresse informatique permet de
retrouver la case mmoire dsigne.

Cette faon de procder conduit le processeur accepter d'excuter des ordres du genre :

Pl ace l a case mmoi r e d' adr esse 9692 dans l ' t at r epr sent en bi nai r e par 0000 0001

Le problme pos par cette faon de s'exprimer est qu'elle reste totalement trangre la
signification attribue l'tat de la case mmoire 9692. Si le programmeur a dcid d'utiliser
cette case mmoire pour y stocker le nombre de pions blancs restant sur un damier, par
exemple, l'instruction prcdente signifie qu'il ne reste qu'un seul pion blanc. Ecrire les
programmes de cette faon entrane de graves difficults.

La premire de ces difficults est d'ordre purement mnmonique : si notre programme
manipule de trs nombreuses quantits, il va tre trs difficile de se souvenir des adresses
correspondant chacune d'entre elles, et le risque d'erreur atteint trs rapidement la certitude.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 10/12
Un premier confort qui va nous tre offert par l'usage d'un langage de programmation est la
possibilit d'attribuer aux zones de mmoire qui nous intressent des noms qui vont nous
aider nous souvenir de la signification de ce que nous y avons stock. Dans notre exemple,
cela nous permettrait de dsigner la case 9692 en utilisant des sobriquets plus ou moins
imags, tels que "nbBl ancs" ou "ef f ect i f DesFor cesDuMal ".

La seconde difficult est un peu plus technique, car elle concerne la faon dont est code la
valeur qui est stocke en mmoire. Supposons que le nombre de pions blancs puisse, par
moment, excder 255. Le programmeur sera alors immanquablement conduit ne pas stocker
ce nombre dans une, mais dans plusieurs cases mmoire. S'il choisit d'en utiliser deux, y
stocker la valeur 1 ncessite de donner au processeur deux ordres successifs :

Pl ace l a case mmoi r e d' adr esse 9692 dans l ' t at r epr sent en bi nai r e par 0000 0001
Pl ace l a case mmoi r e d' adr esse 9693 dans l ' t at r epr sent en bi nai r e par 0000 0000

Le problme devient encore plus complexe si un systme de reprsentation moins lmentaire
(comme par exemple celui permettant de reprsenter des nombres dcimaux) est utilis pour
reprsenter la valeur. L'usage d'un langage de programmation permet de dcharger le
programmeur qui utilise une zone de mmoire (celle reprsentant le nombre de pions blancs,
dans notre exemple) de la corve consistant se rappeler combien de cases mmoires sont
effectivement impliques et comment l'information y est code. Le procd qui offre ce confort
est l'attribution d'un type la zone mmoire utilise. Ds lors qu'une zone mmoire s'est vue
attribuer un type, le langage prend en charge les dtails techniques relatifs au codage de
l'information. Ainsi, dans notre exemple, le simple fait que le programmeur dcide que la zone
mmoire nomme ef f ect i f DesFor cesDuMal est du type "entier sur deux octets" permet au
compilateur de savoir qu'un ordre comme :

met t r e 1 l ' ef f ect i f DesFor cesDuMal

se traduit, pour le processeur, par les deux instructions successives voques prcdemment.
Si, en revanche, le programmeur dcide que la zone mmoire nomme
ef f ect i f DesFor cesDuMal est du type "entier sur un seul octet", le mme ordre

met t r e 1 l ' ef f ect i f DesFor cesDuMal

sera traduit par le compilateur au moyen d'une seule instruction
8
. De mme, si la zone
mmoire nomme ef f ect i f DesFor cesDuMal est dclare comme tant du type "nombre
dcimal", c'est le compilateur qui se chargera de placer les cases mmoires concernes dans
l'tat qui signifie 1 dans ce contexte.

C'est donc grce la notion de type que nous pouvons nous offrir le luxe d'ignorer le dtail de
la reprsentation en mmoire des nombres dcimaux. Remerciez-la au passage, car elle vous
a dj pargn plusieurs pages d'explications encore plus ennuyeuses que celles que vous
subissez en ce moment.

Donner un nom qui voque la signification de l'information stocke et choisir un type
convenant aux valeurs susceptibles d'tre utilises ne devrait pas s'avrer trop difficile. Mais
comment le programmeur dcide-t-il d'utiliser telles cases mmoire plutt que telles autres ?
Dans la plupart des cas, il ne s'en occupe en fait pas du tout, et c'est le compilateur lui-mme
qui se charge de choisir la zone de mmoire o sera stocke l'information. La responsabilit du
programmeur se limite donc au choix d'un type et d'un nom, et nous pouvons nous contenter
de retenir que :

Lorsqu'une zone de mmoire se voit attribuer un type et un nom, elle devient une variable.

Le fait qu'une zone de mmoire soit considre comme ayant type et un nom (et soit donc une
variable) ne change videmment rien au fait qu'il s'agit toujours d'une zone de mmoire. En
particulier, les cases mmoires concernes ont toujours chacune une adresse, qui permet au
processeur de les retrouver (les noms et les types n'existent que dans le langage de
programmation que vous utilisez, le processeur en ignore tout). Lorsqu'une variable correspond
plusieurs cases de mmoire, l'adresse de la premire de ces cases est aussi considre
comme tant l'adresse de la variable. L'adoption de cette rgle permet aux variables de n'avoir
qu'une seule adresse, mme lorsqu'elles s'tendent sur plusieurs cases de mmoire.

8
Cette explication n'est pas prendre au pied de la lettre, car les processeurs actuels n'exigent pas deux instructions
pour modifier deux cases de mmoire d'adresses conscutives. Du point de vue de notre expos, la prise en compte de
ce genre de dtails technologiques ne ferait toutefois qu'obscurcir le raisonnement, sans rien y apporter d'intressant.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 11/12
Modifier l'information
Nous venons de voir comment la notion de type permet au langage de prendre en charge les
choix de conventions de reprsentation qui sont effectus par le programmeur. Cette prise en
charge ne concerne pas simplement le codage et le dcodage de l'information lorsqu'on veut
"lire" ou remplacer le contenu d'une variable, elle s'tend galement au contrle des
traitements qui sont effectus sur les variables.

Un premier contrle concerne la lgitimit des traitements envisags. Prenons un exemple
simple : l'action qui consiste ajouter 1.

Du point de vue d'un processeur, il y a fort parier que cette action correspond l'un des mots
de son vocabulaire de base
9
et, partir de l, aucun obstacle ne s'oppose son excution sur
n'importe laquelle des cases mmoires accessibles. Il semble clair que le sens de cette action,
pour sa part, dpend de ce que la case mmoire est sense reprsenter et que, donc, le
processeur ne peut pas en tenir compte. L'absence d'erreur dans le programme
10
n'est donc
garantie que par l'infaillibilit du programmeur (ce qui revient dire que la prsence d'erreurs,
elle, est absolument garantie).

Du point de vue du langage de programmation, en revanche, la notion de type permet de
mettre en place certains garde-fous. Ainsi, si une variable est de type "couleur", il est clair que
tenter de lui "ajouter 1" n'a aucun sens, et le compilateur peut signaler l'erreur bien avant que
qui que ce soit n'essaie d'excuter le programme.

Mme lorsqu'une action peut tre considre comme lgitime, il reste que la faon dont elle doit
modifier l'tat de la mmoire est troitement lie aux conventions tablies pour donner un sens
la mmoire en question. Si l'on considre les modifications qui doivent tre effectues sur
l'tat de la mmoire, ajouter 1 un entier est trs diffrent d'ajouter 1 un nombre dcimal.
L'existence des types permet au programmeur de ne pas se soucier de ce genre de problmes. Il
peut se contenter d'exprimer l'ide qu'il faut "ajouter 1 au contenu de la variable", et le
compilateur se chargera de faire ce qu'il faut
11
, tant donn le type de la variable implique.

Lors de la description des traitements devant tre effectus, la notion de type n'est pas le seul
confort apport par l'utilisation d'un langage de haut niveau. L'criture d'un programme
correct est grandement simplifie par la possibilit de segmenter le texte source en petites
parties pouvant tre mises au point et testes relativement indpendamment les unes des
autres. En C++, le plus petit fragment de code ayant une relle autonomie est la fonction. Tout
comme les variables, les fonctions portent des noms, et le choix de ces noms incombe
gnralement au programmeur.

Qu'il s'agisse d'une variable ou d'une fonction, le choix d'un nom doit tre fait avec soin, car
la prcision avec laquelle il voque la nature de l'information reprsente (dans le cas d'une
variable) ou du traitement effectu (dans le cas d'une fonction) exerce une grande influence
sur la difficult de mise au point du programme.

9
En toute rigueur, dire que l'addition fait partie du rpertoire d'actions du processeur est dj un abus. Ce qui fait
partie du rpertoire d'actions du processeur, c'est une certaine faon de modifier l'tat d'une case mmoire. Le fait que
cette modification produit un tat qui peut, si la case mmoire reprsente un nombre entier, tre interprt comme le
rsultat d'une addition n'est certainement pas un hasard. Il n'en reste pas moins qu'il ne s'agit l que d'une
interprtation : rien ne garantit que la case mmoire reprsentait effectivement un entier et, si ce n'est pas le cas, de
quelle addition pourrait-il bien s'agir ?
10
Il ne s'agit pas ici d'erreurs d'excution qui seraient dues un mauvais fonctionnement du processeur, mais
d'erreurs logiques prsentes dans le programme lui-mme, comme, par exemple, ajouter 1 une case mmoire dont la
signification ne serait pas numrique.
11
C'est dire qu'il se chargera d'insrer, dans le code excutable qu'il va gnrer, les instructions qui produiront
effectivement l'effet spcifi par le programmeur.
J-L Pris - 08/01/07
C++ - Leon 1 Principes fondamentaux 12/12
5 - Bon, c'est gentil tout a, mais a fait dj 10 pages. Qu'est-ce
que je dois vraiment en retenir ?
1) Les ordinateurs excutent des programmes.

2) Les programmes modifient l'tat de la mmoire.

3) Le processeur distingue les cases de mmoire les unes des autres grce leurs adresses.

4) Les programmeurs s'imaginent que l'tat de la mmoire a une signification.

5) Il y a un tas de faons cohrentes et honorables de projeter une signification sur un tat de
la mmoire.

6) Lorsqu'ils sont dous, les programmeurs crivent des programmes qui ne modifient l'tat de
la mmoire que d'une faon qui respecte la signification qu'ils ont attribue celle-ci.

7) Le langage C++ aide les programmeurs donner l'impression qu'ils sont dous en leur
proposant d'organiser la mmoire en variables ayant chacune un nom et un type.

8) En C++, les programmes sont diviss en units appeles des fonctions.
6 - J'ai rien compris, est-ce que quelqu'un d'autre pourrait
m'expliquer a un peu plus clairement ?
La littrature recommandable sur ce sujet est malheureusement assez rare. La plupart des
ouvrages d'initiation la programmation s'en tiennent, au mieux, une prsentation trs
allusive des thmes abords dans cette premire Leon. Un certain nombre d'entre eux
contiennent mme des erreurs grossires, de nature perturber durablement la
comprhension d'un lecteur innocent (il est, hlas, plus facile de se faire des ides fausses que
de s'en dbarrasser ensuite).
Pour aller moins vite
Steve Heller : Who's Afraid of C++?, Academic Press, 1996 (ISBN 0-12-339097-4)

Plus de 150 pages de discussion sur la vraie nature des ordinateurs et de la programmation
avant d'en venir au langage C++ proprement dit ! Le tout expliqu trs lentement, en prenant
en compte les protestations de Susan, qui a un peu de mal suivre. Deux problmes,
toutefois : c'est en anglais, et le style n'est, somme toute, pas trs diffrent du mien (si vos
difficults proviennent d'un manque d'atomes crochus avec l'auteur, le simple fait que la
prsentation faite par Steve Heller aille moins vite que celle propose ici pourrait bien ne pas
suffire vous rconcilier avec le sujet).
Pour aller plus loin
Paolo Zanella & Yves Ligier : Architecture et technologie des ordinateurs. Dunod, 1998
(ISBN 2-10-003801-X)

Des circuits logiques aux systmes d'exploitation, en 450 pages tonnamment abordables
tant donn leur niveau de technicit. Vous ne comprendrez peut tre pas tout ds la
premire lecture, mais si ce sujet vous intresse, il y a peu de risques que vous perdiez votre
temps avec cet ouvrage.

Charles Petzold : Code. Microsoft Press, 1999 (ISBN 0-7356-0505-X)

Par rapport au Zanella & Ligier, le Petzold prsente l'inconvnient vident de ne pas (encore ?)
avoir t traduit en franais. Il couvre quasiment le mme sujet, mais dans un style
franchement "grand public" plutt que "universitaire", sans jamais pour autant sombrer dans
l'approximation vulgarisatrice outrancire. Apprenez l'anglais et faites-le-vous offrir.
J-L Pris - 08/01/07