2015 10 14 IN1gh01-allslides-2012-2013

Algorithmique et programmation
ENSTA - TC 1re anne

Franois Pessaux
francois.pessaux@ensta-paristech.fr
UIIS - Sret
2012-2013
Avec certaines planches / ides de

Matthieu Finiasz
Franoise Lvy
Michel Mauny
Introduction
Franois Pessaux , francois.pessaux@ensta-paristech.fr, ENSTA
IN101
2/1
But de ce cours
Systmes informatiques omniprsents.
Ncessit pour tout ingnieur dy tre sensibilis.

Ncessit de savoir juger lefficacit et les limites de linformatique.
Apprendre un premier langage, vous vous adapterez ensuite aux autres.

Apprendre automatiser des tches quelque soit le domaine mtier.
Acqurir un bagage scientifique supplmentaire.
Comprendre que informatique = science = mathmatiques.
Entrevoir quelques problmes scientifiques / de recherche intressants.
IN101
3/1
Rgles dor
Ne pas hsiter poser des questions. Mme en amphi !
Se rappeler que si vous avez une question bte, au moins 1/4 de la
promo se pose la mme.
Le ridicule ne tue pas. Sinon ne je serais plus devant vous.
Ne savouer ni perdu ni vaincu. Venez demander des prcisions, mme
en mode entretien particulier.
Ne pas hsiter venir me voir dans mon bureau pour me parler de
quelque problme que ce soit.
Ne pas hsiter dire Mais Msieur, vous ne vous tes pas tromp sur
xxx ?
Ne pas hsiter me faire part de vos facilits / difficults.
IN101
4/1
Architecture
IN101
5/1
Vous avez dit ordinateur ?

Mais pour quoi faire ? Pour traiter de linformation.
Information ?
Cest un message.
criture avec des symboles : code.
Monde numrique : code binaire.
Architecture dun ordinateur:
Mmoire(s) : pour stocker de linformation.

Micro-processeur (CPU) : pour travailler linformation.
Priphriques : pour changer avec lextrieur.
Traitement description de comment: programme.

Architecture de Von Neumann :
Le programme est stock dans la mmoire...

... dans la mme mmoire que les donnes (informations).
IN101
6/1
La mmoire
Pourquoi en avoir besoin ?
Certains traitements peuvent se faire directement: x x + 1.

Intervention de la notion de temps: exemple, un compteur.
Besoin de se rappeler de (dun) ltat prcdent.
Diffrents fonctionnements de mmoire:
RAM (Random Access Memory) : lecture / criture Volatile.

ROM (Read Only Memory) : lecture Persistente.
EPROM (Erasable Programmable Read Only Memory) : lecture (/
criture mais en mode de fonctionnement particulier) Persistente.
Diffrents types de mmoire:
Mmoire de masse (disques) : 10 ms

Mmoire vive (RAM) externe au CPU : 40 50 s
Mmoire cache interne au CPU : 5 10 s
Registres : 1 s
IN101
7/1
Le micro-processeur
Cest lunit qui travaille.

Idalement segmente en 2 parties:
Lunit arithmtique et logique (UAL / ALU) : effectue les calculs.

Lunit de contrle : dcodage et squencement des instructions.
Contient de la mmoire trs rapide ( 1 s): les registres.

Instruction : opration lmentaire effectue par le CPU (addition de
2 registres, copie registre mmoire, registre registre, dcalages,
sauts . . .
Chaque CPU (x86, ARM, amd64 . . . ) est diffrent, a son propre jeu
dinstructions.
IN101
8/1
Programmation
IN101
9/1
Quest-ce que programmer ?
noncer une manire deffectuer un calcul.

Il existe toujours plusieurs manires deffectuer un calcul.
Une machine ne sait que calculer (pas de raisonnement).
Un calcul seffectue sur des donnes, des valeurs.
Programmer cest donner une suite dordre au CPU.
Cette suite est un algorithme.
Mais cest surtout concevoir des objets mathmatiques.
En suivant la smantique des instructions / constructions.

Avec des proprits bien dfinies.
... sinon . . . bug.
IN101
10/1
Quest-ce quun programme ?
Un programme cest:
Lexpression () formelle dun problme rsoudre,

puis lexpression de ce que lon attend en sortie,
puis ltablissement de ce que lon a disposition en entre,
et enfin lalgorithme.
Il faut une spcification avant le code !
Y: Parfois, entres revoir en cours dlaboration de lalgorithme.
IN101
11/1
Un langage de programmation
Pourquoi utiliser un langage de programmation ?
Instructions CPU trs simples travail dmesur.

Instructions diffrentes entre CPU pas de portabilit / compatibilit.
Un langage de programmation permet:
De fournir des constructions de haut niveau.

Dautomatiser la gnration de nombreuses instructions lmentaires
pour ces constructions.
Dcrire un calcul de manire standard, (relativement) indpendante de
larchitecture cible.
Il suffit de traduire le programme pour lexcuter.
Soit avec un interprteur : JavaScript, shell, Matlab, Perl . . .

Soit un compilateur : C, OCaml, Fortran . . .
Soit un peu des deux : Java, Python . . .
IN101
12/1
Le langage C
Des tonnes de langages de programmation !

Choix dun langage. . . C.
Cr B. Kernighan, D. Ritchie et K. Thompson aux Bell Labs en 1972.

Pourquoi C ?
Trs utilis dans lindustrie malgr certains dfauts/difficults.

Souple (programmation haut et bas niveau).
Vous en ferez en IN102 et IN104.
Algorithmique, programmation / langage.

Langage = support, mots pour le dire.
Une mine dinfos: http://www.lysator.liu.se/c/
IN101
13/1
Un premier programme en C
aloha.c
#i n c l u d e < s t d i o . h> / Pour a c c d e r p r i n t f . /
i n t main ( )
{
p r i n t f ( " A l o h a c o u s i n s ! \ n" ) ;
return (0) ;
}
La plus simple manire dafficher en C Aloha cousins !

quivalent la commande shell
> echo "Aloha cousins !"
IN101
14/1
aloha.c
i n t main ( )
{
return (0) ;
}
#include <> : Demander accs aux fonctions entre/sortie (printf).

/* ... */ : Commentaires.
Ignors par le langage.

Mais pas les lecteurs !
Servent la documentation du code.
Documentez vos programmes !
Espaces non-significatifs mais indentez votre code !
IN101
14/1
aloha.c
i n t main ( )
{
return (0) ;
}
Fonction main : point dentre du programme.

Toujours automatiquement appele en premier.
Un programme en C doit toujours contenir une fonction main.
Type int (entier) au dbut : type renvoy par main.
Pour le main : toujours un entier.
IN101
14/1
aloha.c
i n t main ( )
{
return (0) ;
}
Fonction printf : affiche un message dans le terminal.

"Aloha cousins !\n" : chane de caractres ( afficher).
\n : reprsente le caractre retour la ligne.
; Point-virgule : fin dinstruction, marque la squence.
IN101
14/1
aloha.c
i n t main ( )
{
return (0) ;
}
return : sortir dune fonction en retournant la valeur qui suit.

return nest pas une fonction mais une instruction.
Ici, la valeur de retour est 0, cest bien un (type int).
Retour de la fonction main :
Code de sortie du programme.

Existe pour toutes les commandes Unix
Permet de tester si le programme sest excut normalement.
Convention: 0 OK.
IN101
14/1
Compilation et excution dun programme

dition du source:
> emacs aloha.c &

emacs : diteur de texte, permet de taper le source.
Human-readable.
Vous pouvez utiliser nimporte quel diteur (vi, vim, joe. . . )
Compilation:
gcc aloha.c ou gcc aloha.c -o first.x

gcc (compilateur) transforme le source en excutable.
Computer-readable: compilateur traducteur.
Par dfaut, nom de lexcutable = a.out.
Option -o : permet de spcifier un nom dexcutable.
Excution:
./a.out ou ./first.x
... en fonction du nom de votre excutable.
Excute votre programme dans le rpertoire courant.
./ devant car le rpertoire courant nest pas dans le PATH.
IN101
15/1
Le compilateur gcc
Compilateur : programme transformant un source en excutable.
Dispose de nombreuses options dont:
-w :
-g :
-I :
-c :
-L :
-O0
-l :
Activer tous les warnings (all plus que recommand).

Activer les infos de dbug.
Ajouter des rpertoires o trouver les enttes (#include).
Compile sans linker (lorsque plusieurs fichiers sources).
Transfre des options au linker
-O1 -02 -03 : Optimise pas, peu, plus, beaucoup, (trop).
Lier une bibliothque (Ex: -lm pour la bibliothque maths).
Si tout sest bien pass, le compilateur naffiche rien.

Sil affiche une erreur, lexcutable nest pas cr.
Sil affiche un/des warning/s, lexcutable est cr, mais risque de ne
pas fonctionner correctement.
IN101
16/1
Quelques constructions lmentaires
IN101
17/1
Diffrentes formes de donnes
En maths: entiers naturels, rels, rationnels, complexes . . .

En logique: boolens {vrai , faux}
En linguistique: caractres, mots (chanes de caractres)

Besoin de types de donnes de base diffrents.
De base primitifs, ( pour les chanes) inscables.

Ces types de donnes sont intrinsquement diffrents:
en terme de smantique (sens),

en terme de reprsentation dans la machine.
3 (4) types de donnes de base: entiers, rels, (boolens), caractres.

. . . et les fonctions . . . un peu part.
IN101
18/1
Les scalaires de base
Les entiers: type int.

Les rels: type float ou double.
Vue simplifie: on y reviendra plus tard.
IN101
19/1
La mmoire
Avant dtre excut, le programme est charg en mmoire.

Un pointeur indique o en est lexcution.
chaque instruction il avance dune case.
Il y a parfois des sauts (appels de fonctions, tests, boucles. . . ).
Pendant lexcution, le programme peut aussi rserver de la mmoire:
Dclaration (cration) de variables, rceptacles dinformation.

chaque variable correspond une case mmoire.
2 zones mmoire diffrentes:
La pile: variables locales (temporairement accessibles).

Le tas: variables globales (dure de vie arbitraire).
IN101
20/1
Ncessit de typage
Mmoire: contient de linformation code en binaire.
Nous avons vu quelques formes de donnes.
un octet en mmoire peut avoir diffrentes significations.

Loctet 01010111 peut reprsenter:
lentier 87 (= 64 + 16 + 4 + 2 + 1),
le flottant 4.85 10270 ,
(le caractre W),
une instruction en langage machine,
une adresse mmoire, etc . . .
Il faut associer un type chaque case mmoire, chaque variable !

Cest son type (lors de la dclaration) qui va dfinir sa signification
relle.
IN101
21/1
Dclaration et initialisation de variable (1)
On dclare une variable en donnant son type suivi

de son nom.
i n t main ( )
{
float c ;
i n t i , j = 42 ;
double b ;
b = 0.00345 ;
c = 3.14159 ;
}
Cela rserve une case mmoire contenant a priori

une valeur alatoire.
Linitialisation fixe sa valeur.
Cela peut se faire ds la dclaration, ou aprs.
Le tout cest de ne pas lire dans une variable avant son initialisation !
Sa valeur est ce quil y avait dans la mmoire.
a na aucun sens de lutiliser, cest un oubli, une erreur.
IN101
22/1
Dclaration et initialisation de variable (2)
i n t main ( )
{
float c ;
i n t i , j = 42 ;
double b ;
b = 0.00345 ;
c = 3.14159 ;
}
Avec ce code, la mmoire ressemble :
IN101
23/1
Expressions (de base) du langage
Une expression est quelque chose qui a une valeur.

Opposition une instruction (slides suivants) qui fait.
partir dexpressions de base, on combine les expressions.
Expressions de base: les variables et les littraux.
Variables: toute variable dclare et de porte accessible.

Entiers: 4 5
Boolens: true false (. . . et les entiers !)
Caractres: U n
Flottants: 4.6 5e-12
Chanes: "plop" "\tGlop\n"
IN101
24/1
Composition dexpressions
Arithmtique: entre entiers et/ou flottants.
+, , /, avec leur sens habituel, % (modulo)

Ex: 4 (5 7)
Relationnel (tests): entre expressions de mme type.
Rem: conversions implicite entre scalaires (entiers, flottants, caractres

et boolens).
== (galit), < (infrieur ), >, <= (infrieur ou gal ), >=.
Ex: y <= 5 (6 4) < x
Logique: entre boolens (donc implicitement, entiers).
&& (et), || (ou), ! (ngation).

Ex: (y <= 5)&& ((6 4) < x)
&& et || sont paresseux.
Binaire (bit--bit): entre entiers / caractres.
Fonction logique oprant sur chacun des bits de la reprsentation.

~ (ngation), ^ (ou exclusif), & (et), | (ou).
Ex: (~x ^ y) ^ 0xFE
IN101
25/1
Instructions du langage
Une instruction est quelque chose qui fait une action, sans valoir
quelque chose.
Opposition une expression qui vaut une valeur.
Plusieurs (nombreuses) formes dinstructions.
IN101
26/1
Laffectation
Dnote par le signe = ( ne pas confondre avec ==).
Donne une valeur une variable.
Attention matheux !
Variable mathmatique variable informatique.

En maths, variable inconnue.
En info, variable rceptacle dinformation.
En info, une variable a toujours une valeur . . . mme incohrente.
v = 15 ; stocke 15 dans la variable v.

15 = v ; na aucun sens.
gauche du =: case mmoire (variable, case de tableau. . . ).
droite du =: expression dont la valeur va tre stocke.
IN101
27/1
Laffectation
Besoin de compatibilit entre type de la case mmoire et type de la

valeur stocker !
Si les types sont les mmes, aucun problme.
Si les types sont compatibles, transformation implicite:
Entier entier avec signe et/ou taille diffrents,

Flottant entier,
Entier caractre.
. . . mais attention aux problmes de prcision et dbordement !

Et sinon, les types nont rien voir (ex: tableau la place dun
entier): erreur de typage par le compilateur.
IN101
28/1
Instructions daffectation-arithmtique abrge
Il existe des versions courtes des oprations courantes:

int i = 0 ;
i++ ;
i ;
i += 3
i = 3
i = 3
i /= 3 ;
i %= 3
i |= 3
i &= 3
i ^= 3
;
;
;
;
;
;
;
//
//
//
//
//
//
//
//
//
//
i
i
i
i
i
i
i
i
i
i
=
=
=
=
=
=
=
=
=
=
i
i
i
i
i
i
i
i
i
i
/
%
|
&
^
1
1
3
3
3
3
3
3
3
3
;
;
;
;
;
;
;
;
;
;
IN101
29/1
Excution conditionnelle
Besoin deffectuer un traitement . . . ou pas . . . ou un autre.
Notion de condition (expression boolenne).
Condition toujours entre parenthses !
if (expression) { instruction(s) ; }:
instruction(s) excute(s) si expression renvoie 0
instruction(s) excute(s) si expression renvoie 0.

if (expression) { instruction1 (s) ; } else { instruction2 (s) ; }:
instruction1 (s) excute(s) si expression renvoie 0

sinon, instruction2 (s) excute(s).
Remarquez la construction { ... }: groupement de plusieurs

instructions: bloc.
IN101
30/1
Excution conditionnelle: petit exemple

int x ;
...
i f ( x == 0 ) p r i n t f ( " x e s t n u l . \ n" ) ;
i f ( x > 0 ) { p r i n t f ( " x e s t p o s i t i f . \ n" ) ; }
else {
i f ( ( x <= 3) && ( x > 5) )
p r i n t f ( " x e s t n g a t i f e n t r e ] 5 ; 3 ] ou n u l . \ n" ) ;
e l s e p r i n t f ( " x e s t n g a t i f h o r s ] 5 ; 3 ] ou n u l . \ n" ) ;
}
x = 90
"x est ngatif hors ]-5;-3] ou nul."
x =0
"x est nul."
"x est ngatif hors ]-5;-3] ou nul."
x = 4
"x est ngatif entre ]-5;-3] ou nul."
IN101
31/1
Approfondissement des types de base de C
IN101
32/1
Les entiers (naturels et relatifs)

Plusieurs tailles.
Signs ou non.
Par dfaut: un entier est sign.
Ex: 0 -3 +0 15657
short
unsigned short
int
unsigned int
long
unsigned long
long long
unsigned long long
Taille
(bits)
16
16
32
32
32 ou 64
32 ou 64
64
64
Valeur
Min
Max
-32768
32767
0
65535
231
231 1
0
232 1
dpend de larchitecture
dpend de larchitecture
263
263 1
0
264 1
IN101
33/1
Codage des entiers

Entiers cods en binaire: base 2.
421 0000000110100101 (sur 16 bits)

= 28 + 27 + 25 + 22 + 20
Base 2 :
Pratique au niveau lectronique mais encombrant !

On prfre la base 16 (hexadcimal).
0000 0001 1010 0101
0x 0
1
A
5
Pour avoir des entiers signs: complment 2.
Inverser les bits de lcriture binaire de sa valeur absolue,

puis ajouter 1 au rsultat.
Calcule 2l x o l est la longueur de reprsentation dun entier.
1 seule reprsentation de 0.
+ et identiques sur signs / non-signs, positifs / ngatifs.
IN101
34/1
Dbordement dentiers
Arithmtique modulo la taille des mots machine.
Pour les exemples suivants, taille = 4 bits.
Perte de plein de bonnes proprits mathmatiques /
Dbordement de non sign: 9 + 7 = 16 ?

1001 + 0111 = 10000 = sur 4 bits . . . 0000 = 0
Dbordement de sign: -9 - 8 = -17 ?
0111 1000 = 11111 = sur 4 bits . . . 1111 = -1
Conversion de sign non sign: -4 ?
1100 = 12
Conversion de non sign sign: 15 ?
1111 = -1
Associativit de et /: (1 / 4) * 4 = (1 * 4) / 4 ?
1 / 4 = 0.25 En entiers . . . 0. Donc, * 4 0
1 * 4 = 4 En entiers . . . 4. Donc, / 4, 1
IN101
35/1
Les rels
Couramment appels flottants (floating point numbers).
Toujours signs.
2 tailles 2 prcisions.
Ex: 1.0 3.14159 -6.14 +1.6e-15
float
double
Taille
(bits)
24 + 8
53 + 11
Valeur
Min
1.1 1038
2.2 10308
Max
3.4 1038
1.8 10308
Prcision
106
1015
IN101
36/1
La ralit des rels : des problmes bien rels

Nombres flottants pratiques pour approximer les rels mathmatiques.
Pourtant bien diffrents de la beaut mathmatique:
Notion de prcision:
Comme pour les entiers: notion de rels min et max reprsentables.

Mauvais conditionnement:
Oprations entre grand et petit flottants parfois incohrentes.

Ex: 100.0 + 4e+15 = . . . 4e+15
Arrondis lors des calculs.
Tous les rels ne sont pas reprsentables entre 2 rels.

Il existe des trous entre 2 rels.
Ex: 48431.1231 = 48431.1250 (c.f. slide suivant).
Test dgalit proscrit.

Test modulo un .
Attention, nest pas absolu et dpend du problme !
Conversion rel entier: 0 ou dbordement.
IN101
37/1
Des rels diffrents gaux. . .

thiskillsme.c
#i n c l u d e < s t d i o . h>
i n t main
{
float
float
float
()
f l 1 = 48431.1231
f l 2 = 48431.1239
f l 3 = 48431.1250
printf (" fl1

printf (" fl1
printf (" fl2
printf (" fl1
fl1 = fl1 +
printf (" fl1
return (0) ;
;
;
;
: %f
f l 2 : %f
fl3
== f l 2 ? %d \ n " , (
== f l 3 ? %d \ n " , (
== f l 3 ? %d \ n " , (
0.0001 ;
+ 0 . 0 0 0 1 : %f \ n " ,
: %f \ n " , f l 1 , f l 2 ,
f l 1 == f l 2 ) ) ;
f l 2 == f l 3 ) ) ;
f l 1 == f l 3 ) ) ;
fl1 )
fl3 )
> ./thiskillsme
fl1: 48431.125000 fl2: 48431.125000
fl1 == fl2 ? 1
fl2 == fl3 ? 1
fl1 == fl3 ? 1
fl1 + 0.0001: 48431.125000
fl3: 48431.125000
IN101
38/1
. . . et des rels gaux diffrents

thiskillsmeagain.c
#i n c l u d e <math . h>
#d e f i n e EPSILON ( 1 e 6)
i n t main ( )
{
double f l 1 = 0.1 ;
double f l 4 = f l 1 + f l 2
printf
printf
printf
return
// Tout p e t i t
epsilon . . .
( " f l 1 : %f
f l 2 : %f
f l 3 : %f
f l 4 : %f \ n " , f l 1 , f l 2 ,
( " f l 3 = f l 4 ? %d \ n " , ( f l 3 == f l 4 ) ) ;
( " f l 3 ~ f l 4 ? %d \ n " , ( f a b s ( f l 3 f l 4 ) < EPSILON ) )
(0) ;
fl3 ,
fl4 )
> ./thiskillsmeagain
fl1: 0.100000 fl2: 0.200000
fl3 = fl4 ? 0
fl3 ~ fl4 ? 1
fl3: 0.300000
fl4: 0.300000
IN101
39/1
Les boolens
Valeurs dans lensemble { vrai ; faux }

Valeurs logiques boolennes.
En fait, comme une valeur entire avec:
0 false
Tout sauf 0 true
On peut donc tester une valeur entire comme un boolen.

Tirage alatoire dans cet ensemble boolen non quiprobable !
Fichier dentte #include <stdbool.h> pseudo-dfinit les boolens:
Type bool (alias de int)

Constante true (=1) et false (= 0).
IN101
40/1
Les chanes de caractres
Ce sont en fait des tableaux de caractres.

Intuition : suite contigue de caractres termine par le caractre \0.
Caractre: type prdfini char.
Par ex: a.
Chane: moyen facile dcrire des morceaux de texte.
Ex: "Eat at Joes .
Fichier dentte requis: #include <string.h>
Peuvent tre copies: fonction strcpy (dest , source).

Longueur dune chane: fonction strlen (chaine).
ATTENTION: ne compte pas le \0 final !
IN101
41/1
Quelques formes particulires de caractres

Utilisables en tant que caractres individuels ou dans des chanes.
\n : Retour la ligne.
\\ : Le caractre \.
\ : Le caractre .
\" : Le caractre ".
\t : La tabulation.
\x : Le caractre dont le code en hexadcimal suit.
\ : Le caractre dont le code en octal suit.
. . . et quelques autres que lon passe sous silence.
Ex: printf ("foo\n\"\bar\\\x65\046");

foo
"bar\e&
IN101
42/1
Plus de constructions
IN101
43/1
Rpter, toujours rpter. . .

Informellement, certains traitements parfois spcifis par:
Faire un traitement T ,
Puis si une condition C est vrifie sarrter,
Sinon recommencer le traitement T .
Notion de rptition.
2
Exemple: cos(x) = 1 x2! + x4! x6! + . . .

Et dailleurs . . . n! = 1 2 . . . n
Ncessit de prciser comment mener la rptition:
Nombre de fois connu lavance ?

Condition C doit tre teste avant le 1er traitement T ?
Condition C doit tre teste aprs le 1er traitement T ?
Plusieurs schmas ditration.
Plusieurs constructions de boucles.

IN101
44/1
Faire n fois: la boucle for

for (instruction1 ; expression ; instruction2 ) { instruction3 (s) }
Smantique:
1 Initialisation: excuter instruction1 .
2 Si expression svalue en true
2.1 Excuter instruction3 (s).
2.2 Excuter instruction2 (post-traitement).
2.3 Retourner en 2.
enumerate.c
i n t main ( )
{
int i ;
f o r ( i = 0 ; i < 1 0 ; i ++) {
p r i n t f ( "%d " , i ) ;
}
p r i n t f ( " \n" ) ;
return (0) ;
}
mymac:/tmp$ gcc enumerate.c -o enumerate

mymac:/tmp$ ./enumerate
0 1 2 3 4 5 6 7 8 9
IN101
45/1
La boucle for dgnre

Possibilit domettre des parties de la construction.
Initialisation, condition, post-traitement, voire corps !
Pouss lextrme: formes tranges voire illisibles M. viter !
i = 0 ; j = 0 ;
f o r ( / / ; i < 1 0 ; i ++) {
j += i ;
}
j = 0 ;
f o r ( i = 0 ; i < 1 0 ; / / ) {
j += i ;
i++ ;
}
i = 0 ; j = 0 ;
f o r ( / / ; i < 1 0 ; / / ) {
j += i ;
i++ ;
}
i = 0 ; j = 0 ;
f o r ( / / ; / / ; / / ) {
j += i ;
i f ( i == 9 ) b r e a k ;
i++ ;
}
IN101
46/1
Tant que . . . faire: la boucle while

while (expression) { instruction(s) }
Smantique:
1 Si expression svalue en true
1.1 Excuter instruction(s).
1.2 Retourner en 1.
Ex: Un+1 = {
Un
2
Si Un est pair
3 Un + 1 Sinon
syracuse.c
i n t main ( )
{
i n t x = 134560 ;
w h i l e ( x != 1 ) {
i f ( x % 2 == 0 )
x = x / 2 ;
else x = 3 x +
}
return (0) ;
}
// R p t e r t a n t que x e s t
// S i x e s t p a i r .
// On l e d i v i s e p a r 2 .
1 ;
d i f f r e n t de 1 .
IN101
47/1
quivalence entre boucles for et while
Remplacement de for en while:

for ( i n i t ; test ; postlude ) {
instruction (s) ;
}
init ;
while ( t e s t ) {
instruction (s) ;
postlude ;
}
Remplacement de while en for:

while ( t e s t ) {
instruction (s) ;
}
for ( ; test ; ) {
instruction (s) ;
}
IN101
48/1
Faire tant que: la boucle do-while

Boucle while avec test la fin du traitement.
Traitement toujours excut au moins 1 fois.

do { instruction(s) } while (expression) ;
Syntaxe: noubliez pas le ; final !
i n t main ( )
{
char c ;
do {
p r i n t f ( " E n t e z un c h i f f e : " ) ;
// L e c t u r e . . .
s c a n f ( "%c " , &c ) ;
} while (( c < 0 ) | |
( c > 9 ) ) ; // J u s q u s u c c s .
return (0) ;
}
IN101
49/1
En rsum des boucles
IN101
50/1
Construction conditionnelle gnralise (1)

Besoin de tester une valeur contre plusieurs cas mutuellement exclusifs.
Ex: x =?0 ou x =?1 ou x =?4 ou . . . ou sinon.
On peut cascader des if else
i f ( x == 0 ) p r i n t f ( " x : 0\ n" ) ;
else {
i f ( x == 1 ) p r i n t f ( " x : 1\ n" ) ;
else {
i f ( x == 4 ) p r i n t f ( " x : 4\ n" ) ;
else {
i f . . . else . . . i f . . . else . . .
...
} } ... }
}
}
}
p r i n t f ( " A u t r e c a s \n" ) ;
Pas franchement pratique ni lisible M

IN101
51/1
Construction conditionnelle gnralise (2)

Discrimination par cas.
Cas doivent tre mutuellement exclusifs.
Construction switch (expression) { ... }
Suite de case constante : instructions
instructions correspondant au cas dont constante est gal la valeur
de expression alors excutes.
Fin de chaque cas par break ;
Cas autre, par dfaut: default.
...
switch ( x )
case 0 :
case 1 :
case 4 :
default :
}
{
printf
printf
printf
printf
( " x : 0\ n" ) ; b r e a k
( " x : 1\ n" ) ; b r e a k
( " x : 4\ n" ) ; b r e a k
( " A u t r e c a s \n" ) ;
;
;
;
break ;
IN101
52/1
Quelques utilitaires de C
IN101
53/1
Les entres/sorties (I/Os) lmentaires
Communication avec lextrieur: clavier, cran, fichiers. . .

Lecture (Input), criture (Output).
criture lcran: printf.
Lecture au clavier: scanf.
IN101
54/1
Sortie lcran printf (1)

Ncessite: #include <stdio.h>
printf ("Aloha cousins\n") ;
printf ("%d = %d + %d\n", x + y, x, y);
Format= chane de caractres contenant (ou pas) des squences %.
%d
%ld
%u
%x
%f
%lf
%e
%.7lf
%07d
% 7d
%c
un
un
un
un
un
un
un
un
un
un
un
int
long int en dcimal
unsigned int en dcimal
int en hexadcimal
float
double
double en notation scientifique
double avec 7 chiffres aprs la virgule
int en dcimal sur 7 digits (padding frontal avec des 0)
int en dcimal sur 7 digits (padding frontal avec des )
char (comme caractre ASCII, pas comme entier)
IN101
55/1
Sortie lcran avec printf (2)
i n t main
{
printf
printf
printf
printf
printf
printf
printf
printf
printf
printf
return
}
()
( "%d\n" , 4 2 ) ;
( "%l d \n" , 4 2 ) ;
( "%u\n" , 4 2 ) ;
( "%x \n" , 4 2 ) ;
( "%f \n" , 4 2 . 0 ) ;
( "%e \n" , 4 2 . 0 ) ;
( " %.7 f \n" , 4 2 . 0 ) ;
( "%07d\n" , 4 2 ) ;
( "% 7d\n" , 4 2 ) ;
( "%c \n" , 4 2 ) ;
(0) ;
42
42
42
2a
42.000000
4.200000e+01
42.0000000
0000042
42
*
IN101
56/1
Entre au clavier avec scanf (1)

Ncessite: #include <stdio.h>
Lecture au clavier selon le format spcifi (squences %).
Saisie pas en accord avec ce quattend le format: imprvisible.
Format avec uniquement des % (pas de message).
input.c
i n t main ( )
{
int i , j ;
s c a n f ( "%d %d" , &i , &j ) ;
p r i n t f ( " i = %d , j = %d\n" , i , j ) ;
return (0) ;
}
mymac:/tmp$ gcc input.c -o input

mymac:/tmp$ ./input
45 67
i = 45, j = 67
mymac:/tmp$ ./input
5
FHG
i = 5, j = 0
mymac:/tmp$ ./input
DFG 6
i = 0, j = 0
IN101
57/1
Entre au clavier avec scanf (2)
scanf ("%d", & i ) ;
Pour le moment, & reste un peu magique.

Sera approfondi ultrieurement.
Ide: mettre devant une variable pour permettre sa modification par
scanf.
Rem: lecture de chanes de caractres (%s) ncessite quelques
explications ultrieures. On vivra sans pour le moment.
IN101
58/1
Constantes, macros et prprocesseur

Dfinir des constantes littrales dans le source: pas maintenable !
Ncessit de changer partout la valeur.
Utilisation de macros.
#d e f i n e SIZE ( 4 2 )
...
i n t i = SIZE ;
i f ( j < SIZE ) . . .
Remplacement textuel avant compilation par le prprocesseur C (cpp).

Mieux vaut parenthser:
#d e f i n e SIZE 42 + 1
...
i n t i = SIZE 10 ;
i = 52 et non 430 !
Possibilit de macros paramtres: #define TWICE(x)((x) (x))
IN101
59/1
Alias de types
Vous en avez assez de taper unsigned long int ?

Dfinissez un alias.
typedef unsigned long int uli_t ;
uli_t: nom, abrviation de unsigned long int.
Utilisable ensuite comme nom de type: uli_t i = 42 ;
Ne dfinit pas un nouveau type !
De manire gnrale: typedef <type existant> <nom>
Fonctionnera avec les types que nous verrons plus tard.
IN101
60/1
Les fonctions (1)
Vus jusqu prsent: expressions (arithmtiques, logiques), affectation,

squence et boucles.
Permet dj deffectuer des calculs.
Parfois, besoin:
Deffectuer le mme calcul plusieurs endroits

Pas envie de rpter les instructions.
Deffectuer un calcul en instanciant des inconnues de diffrentes
manires.
Par exemple: calcul de cosinus en invoquant 2 fois lexponentielle:

ix
ix
mycos(x) e +e
2
IN101
61/1
Les fonctions (2)

Cest typiquement la notion de fonction mathmatique:
Soit A et B 2 ensembles.
Fonction f dfinie sur A valeur dans B : correspondance qui x A
associe au plus (fonction partielle) 1 lment de B.
A: domaine.
B: codomaine.
Autrement dit:
Prend 1 (ou des) argument(s).

Retourne 1 valeur.
Do, une fonction est dfinie par:
le type de la valeur quelle retourne,

son nom,
les types des paramtres quelle attend,
et son corps: la description du calcul quelle effectue, spcification
excutable.
IN101
62/1
Les fonctions (3): exemples
int twice ( int i )

{
return ( i 2) ;
}
// C o r p s : r e t o u r n e b i e n un i n t .
f l o a t square_minus ( f l o a t x , f l o a t y )
{
float t = (x y) ;
/ V a r i a b l e l o c a l e . /
return ( t t ) ;
}
IN101
63/1
Les fonctions (4): quelques remarques importantes

crire une fonction ne lexcute pas ! Il faut lappeler !
Appeler une fonction: nom + arguments entre parenthses:
...
v = twice (2) ;
v = s q u a r e _ m i n u s ( v , v ) + 42 ;
...
Corps de la fonction uniquement excut lors de lappel la fonction.

Paramtre formel: nom donn dans la dfinition de la fonction: i pour
twice, x et y pour square_minus.
Paramtre effectif: expression donne un paramtre formel pour
lappel.
Appel:
1
2
3
4
valuation (calcul) des expressions arguments effectifs valeur.

Association de chaque paramtre formel avec sa valeur.
Calcul du corps de la fonction sous ces hypothses dassociation.
Transmission lappelant de la valeur retourne par ce corps.
IN101
64/1
Les fonctions (5): remarques pour puristes
Fonctions en C lgrement diffrentes du modle thorique du calcul

(-calcul).
-calcul:
Fonction n arguments = fonction 1 argument retournant une

fonction n 1 argument(s).
Les fonctions sont de valeurs.
Pas de fonction 0 argument: paramtre de type trivial (void, unit)
habit par 1 seule valeur.
Supprime la diffrence artificielle entre fonction, procdure et arit
(nb darguments).
Cas des langages fonctionnels (OCaml, Haskell, LISP. . . )
IN101
65/1
Les fonctions (6): retour C

Mais en C...
Si pas dargument: absence dans la dfinition, absence dans lappel.
Fonction retournant rien:
Retourne le type void.

Aucune expression aprs linstruction return.
Dernire instruction return optionnelle.
return peut tre ncessaire si plusieurs points de terminaison de la
fonction.
i n t const_fun ( )
{
return (42) ;
}
void j u s t _ p r i n t ( in t i )
{
p r i n t f ( " J i m p r i m e %d e t %d\n" , i , c o n s t _ f u n ( ) ) ;
return ;
}
IN101
66/1
Les fonctions (7): variables locales, variables globales

On peut dclarer des variables locales dans une fonction.
Plus gnralement: dclaration de variable locales dans des blocs ({ ...
}).
Corps de la fonction bloc.
Vivantes seulement jusqu la fin de la fonction / du bloc.
Variables globales (dfinies hors de fonctions) restent accessibles dans
la fonction.
int glob = 5 ;
int f ( int x)
{
int i = x
{
int j = i
i = i + j
}
return ( i +
}
/ V a r i a b l e g l o b a l e . /
2 ;
/ V a r i a b l e l o c a l e l a f o n c t i o n f . /
+ 5 ;
;
/ V a r i a b l e l o c a l e au b l o c i n t e r n e f . /
/ F i n du b l o c : j n e s t p l u s a c c e s s i b l e . /
3 + glob ) ;
IN101
67/1
Dclaration / prototype (1)
Utilisation dune fonction en dehors de son fichier hte son type

doit tre connu.
Donner juste le type: dclaration (et non dfinition).
Rend visible par toute personne ayant accs cette dclaration.
Rgle valable pour les autres types de variables, dailleurs.
Prototype dune entit: son nom + son type.
Dclaration:
Faite au toplevel dun fichier dentte (.h).

Utilise via les directives #include.
IN101
68/1
Dclaration / prototype (2)

Pour une fonction:
son type de retour,

son nom,
les types (et les noms optionnellement) de ses arguments.
Pour une variable autre:
le mot clef extern (sinon a serait une dfinition de variable !),

son type,
son nom.
/ D c l a r a t i o n d une v a r i a b l e ( g l o b a l e ) e n t i r e . /
extern i n t errno ;
/ D c l a r a t i o n de l a f o n c t i o n a r c t a n g e n t e ( de y / x ) . /
f l o a t atan2 ( f l o a t y , f l o a t x ) ;
Indique comment utiliser la fonction.

. . . Mais pas ce quelle fait.
IN101
69/1
Quelques fonctions dj vues

printf: affichage lcran
Prototype un peu bizarre car nombre et types des arguments variables.

void printf (const char restrict format, ...) ; M
main : LA fonction point dentre de tout programme
int main () ;
Retourne un entier: le code de retour du programme.

Ne prend pas dargument.
int main (int argc , char argv []) ;
Forme alternative: arguments en provenance de la ligne de commande.

argc : nombre dentres dans argv.
argv: tableau (plus de dtails plus tard) de chanes de caractres.
1er lment: nom du programme.
lments suivants: arguments effectifs.
Ex: > ./myprog 1 hop 4
0
1
2
3
argv =
myprog 1 hop 4
IN101
70/1
La rcursivit
IN101
71/1
La rcursivit: une autre faon ditrer

Soit la fonction factorielle.
Spcification par abstraction: n! = ni=1 i

1
Spcification par rcurrence: Factn = {
n Factn1
Si n = 0
Sinon
Ide: problme P de la forme
Traitement T sur P:
Traiter la partie orange.

Traiter ce qui reste. . . qui est un problme de la mme forme que P.
IN101
72/1
La rcursivit (2)
Une fonction qui sappelle elle-mme est dite rcursive.
Ex: recherche dun fichier sur un disque.
boolen existe_fichier (nom, rpertoire)
{
liste fs = noms_de_fichier (rpertoire) ;
si (name est dans fs) retourner (vrai) ;
sinon {
liste srs = sous_rpertoires (rpertoire) ;
pour chaque r dans srs {
si (existe_fichier (nom, r)) retourner (vrai) ;
// Sinon, implicitement continuer le pour-chaque.
}
}
retourner (faux) ;
}
IN101
73/1
Rcursion bien fonde

Fonction rcursive: dfinie grce elle-mme.
Mon calcul seffectue grce mon calcul M
Foon = n + Foon
0
Si n = 0
Barn = {
n + Barn+1 Sinon
...?
...?
Certaines dfinitions peuvent clairement ne pas converger (terminer).

Mise en place dune fonction rcursive:
Cas de base (condition darrt).

Cas dinduction.
Ncessit de dcroissance stricte vers le cas de base
Rcurser (se rappeler) sur un problme strictement plus petit.
Pour une suite rcurrente, condition darrt conditions initiales.
IN101
74/1
Exemple: factorielle
1
2
3
4
5
int fact ( int n)

{
i f ( n <= 0 ) r e t u r n ( 1 ) ;
e l s e return ( n f a c t ( n 1) ) ;
}
Ligne 3 : Cas de base fin de la rcursion.

Ligne 4 : Cas rcursif
On traite la partie locale de notre problme: n

Puis on traite de manire similaire le problme restant.
n 1 : problme restant plus petit !
IN101
75/1
Exemple: factorielle - Droulement du calcul (1)

fact (4)
4 * fact (3)
3 * fact (2)
2 * fact (1)
1 * fact (0)
1
IN101
76/1
Exemple: factorielle - Droulement du calcul (2)

24
fact (4)
4 * (3 * (2 * (1 * 1)))
4 * fact (3)
3 * (2 * (1 * 1))
3 * fact (2)
2 * (1 * 1)
2 * fact (1)
1*1
1 * fact (0)
1
1
IN101
77/1
Pour rsoudre notre problme de factorielle. . .
On a trouv au moins un cas o la solution est connue: 0!

On a tent de ramener le problme pos pour n quelconque au mme
problme. . .
. . . Mais pos sur une valeur plus simple (plus proche du cas connu).
On a raisonn par rcurrence pour obtenir une dfinition rcursive.
Principe de rcurrence. Soit P une proprit sur N:
Si P(0) est vrifie,

si de lhypothse P(n) est vrifi on peut dduire que P(n + 1) est
vrifie,
alors m N, P(m) est vrifie.
IN101
78/1
Exemple: lvation la puissance
Spcification rcursive:
{
x n = x x n1
x0 = 1
chaque appel rcursif, lexposant n dcroit

il converge vers 0 et la fonction power termine bien.
d o u b l e power ( d o u b l e x , u n s i g n e d i n t n )
{
i f ( n == 0 ) r e t u r n ( 1 . 0 ) ;
e l s e r e t u r n ( x power ( x , n 1 ) ) ;
}
IN101
79/1
Exemple: puissance - Droulement du calcul (1)
power (a, 4)
a * power (a, 3)
a * power (a, 2)
a * power (a, 1)
a * power (a, 0)
1
IN101
80/1
Exemple: puissance - Droulement du calcul (2)

a* a * a* a
power (a, 4)
a* a * a* a
a * power (a, 3)
a*a*a
a * power (a, 2)
a*a
a * power (a, 1)
a * power (a, 0)
1
IN101
81/1
Exemple: lvation la puissance - square & multiply

Spcification rcursive:
x 2n = x n x n
2n+1
= x x 2n
x
x = x.
d o u b l e power_sm ( d o u b l e x , u n s i g n e d i n t n )
{
d o u b l e tmp ;
i f ( n == 1 ) r e t u r n ( x ) ;
i f ( e % 2 == 0 ) {
tmp = power_sm ( x , n / 2 ) ;
r e t u r n ( tmp tmp ) ;
}
r e t u r n ( x power_sm ( x , n 1 ) ) ;
}
IN101
82/1
Ex: square & multiply - Droulement du calcul (1)
power (a, 13)

a * power (a, 12)
power (a, 6) ^ 2
power (a, 3) ^ 2
power (a, 2) ^ 2
power (a, 1) ^ 2
a
IN101
83/1
Ex: square & multiply - Droulement du calcul (2)

2 2
a * ((a * a 2 ) )
power (a, 13)
2 2
a * ((a * a 2 ) )
a * power (a, 12)
2 2
((a * a 2 ) )
power (a, 6) ^ 2
(a * a 2 )
power (a, 3) ^ 2
a*a2
power (a, 2) ^ 2
a2
power (a, 1) ^ 2
a
a
IN101
84/1
Appels rcursifs multiples
Suite de Fibonacci: Fn = Fn1 + Fn2 et F0 = 0, F1 = 1

Une fonction rcursive peut faire plusieurs appels rcursifs.
Exemple: suite rcurrente double, algorithmes de tri (c.f. plus tard).
Droulement comme des appels de fonction normaux:
Entrer dans le premier appel rcursif.

Ce dernier va lui-mme effectuer ses appels internes.
Quand premier appel termin, on passe au second.
Attention: pas de notion de paralllisme !

Les appels ne sont pas excuts en mme temps.
IN101
85/1
Appels rcursifs multiples: droulement

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
fib(3) ;
IN101
86/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
fib(3) ;
fib(1) ;
fib(2) ;
IN101
87/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
fib(3) ;
fib(1) ;
fib(2) ;
fib(0) ;
fib(1) ;
IN101
88/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
fib(3) ;
fib(1) ;
fib(2) ;
fib(0) ;
1
fib(1) ;
IN101
89/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
fib(3) ;
fib(1) ;
1
fib(2) ;
0
fib(0) ;
1
fib(1) ;
IN101
90/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
2
fib(3) ;
1
fib(1) ;
1
fib(2) ;
0
fib(0) ;
1
fib(1) ;
IN101
91/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
fib(4) ;
fib(2) ;
2
fib(3) ;
1
fib(1) ;
1
fib(2) ;
0
fib(0) ;
1
fib(1) ;
0
fib(0) ;
1
fib(1) ;
IN101
92/1

Fn = Fn1 + Fn2 et F0 = 0, F1 = 1
1
fib(4) ;
fib(2) ;
2
fib(3) ;
1
fib(1) ;
1
fib(2) ;
0
fib(0) ;
1
fib(1) ;
0
fib(0) ;
1
fib(1) ;
IN101
93/1
Formes de rcursivit
Fonction rcursive primitive: cette fonction ne figure pas dans les

arguments dun appel rcursif.
Fonction rcursive terminale: cette fonction ne figure pas dans les
arguments dune autre fonction:
Ne laisse aucun calcul en suspend.

Peut tre d-rcursive: transformation en simple boucle.
IN101
94/1
Fonctions mutuellement rcursives

Plusieurs fonctions sappelant mutuellement.
Pas dordre (ni partiel, ni total) de prcdence de dfinition.
Sont en fait dfinies en mme temps.
En C, (comme dans beaucoup de langages): toutes les fonctions sont
implicitement mutuellement rcursives (si besoin).
#i n c l u d e <s t d b o o l . h>
bool natural_even ( unsigned i n t n )
{
i f ( n == 0 ) r e t u r n ( t r u e ) ;
e l s e return ( natural_odd ( n 1) ) ;
}
bool natural_odd ( unsigned i n t n )
{
i f ( n == 0 ) r e t u r n ( f a l s e ) ;
e l s e return ( natural_even ( n 1) ) ;
}
IN101
95/1
Rcursion, boucles, a se termine quand ?
Pour obtenir un rsultat, un calcul doit terminer.

Boucle avec condition darrt toujours fausse boucle infinie.
Rcursion avec cas de base ( condition darrt) jamais atteint
rcursion infinie.
Dans ces cas . . . on peut attendre longtemps.
La terminaison est une proprit trs importante.
IN101
96/1
Le problme de larrt
Un programme pour dterminer larrt de programmes ?

Vrai Si prog avec les donnes data sarrte
Halt(prog , data) = {
Faux Sinon
Un programme:
Boucler si Halt (prog, prog) = Vrai
Hic(prog ) = {
Terminer sinon
Hic(Hic)
Termine si Hic ne termine pas et ne termine pas si Hic termine M

Dans les 2 cas: contradiction hypothse initiale fausse.
Impossibilit de programmer un prdicat de test darrt: problme
indcidable.
IN101
97/1
Comment sassurer de la terminaison ?

Pas de mthode automatique.
Ncessite une preuve de terminaison.
Problme de raisonnement, pas de calcul.
Intuition: dmontrer que chaque appel rcursif seffectue sur un
argument plus petit
Ncessit dun ordre < sur le domaine des arguments.

Ordre bien fond: / suite dcroissante infinie.
fact (n) : si n == 0 alors 1 sinon n * fact (n -1)
Facile: appel rcursif sur n 1 qui est bien < n.
n+1
Si m=0
Ack(m
1
,
1)
Si
m > 0 et n = 0
Ack(m, n) =
Ack(m 1, Ack(m, n 1)) Si m > 0 et n > 0

Nettement moins vident ! Mais elle termine (ordre lexicographique).
IN101
98/1
Appel(s) de fonction(s)
IN101
99/1
Droulement dun appel de fonction
Illustration sur le calcul de la racine carre dun rel a.

Mthode itrative de Newton.
a donne par xn+1 = 12 (xn + xan )
n: Nombre ditrations ( fixer arbitrairement).

x0 > 0 : Point de dpart ( fixer arbitrairement).
IN101
100/1
Protocole dappel
Appeler une fonction cest:
stocker la valeur de ses paramtres,

aller excuter son code,
et en revenir avec le rsultat.
Diffrentes conventions dappel selon les langages, les architectures.

Principe restant majoritairement le mme: utilisation de la pile.
Diffrences dans qui (appelant/appel) fait quoi.
Diffrences dans lagencement mmoire dinformations (registres vs
pile).
IN101
101/1
Protocole dappel de manire gnrique

Ct appelant:
valuation des arguments passer mis sur la

pile.
Adresse de retour mise sur la pile.
Ct appelant:
Rcuprer la valeur retourne par lappel.

Supprimer de la pile les arguments passs lors de
lappel.
var locale 2
var locale 1
@ retour
arg n
...
arg 2
arg
Appelant
Rservation des variables locales sur la pile.

Excution du code.
Stockage de la valeur retourner (en registre ou
pile).
Aller . . . ladresse de retour.
Croissance de la pile
Appel
var locale m
...
Ct appel:
IN101
102/1

1
#d e f i n e X0 ( 3 . 0 ) // Germe : q u e l c o n q u e > 0
2
3
4
Pile
5
6
7
8
9
double s q u r ( double a , i n t max_iter ) {

int i ;
d o u b l e xn = X0 ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
r e t u r n ( xn ) ;
}
10
11
2.0
res
???
nb_iters
15
main
12
13
14
15
16
17
i n t main ( ) {
int nb_iters = 15 ;
double res, v = 2.0 ;
res = squr (v , nb_iters ) ;
p r i n t f ( " s q r t (% f ) = %f \n" , v , r e s ) ;
return (0) ;
}
Dfinition et initialisation des variables locales de main

IN101
103/1

1
2
3
4
Pile
5
6
7
8
ligne 14
15
squr
max_iter

int i ;
d o u b l e xn = X0 ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
}
10
2.0
11
2.0
12
res
???
nb_iters
15
main
a
v
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
double res , v = 2 . 0 ;
r e s = squr (v, nb_iters) ;
return (0) ;
}
Appel de la fonction squr

IN101
104/1

1
2
3
4
Pile
xn
3.0
???
ligne 14
15
squr
max_iter

int i ;
double xn = x0 ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
}
10
2.0
11
2.0
12
res
???
nb_iters
15
main
a
v
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
return (0) ;
}
Dfinition et initialisation des variables locales de squr

IN101
105/1

1
2
3
4
Pile
xn
1.414998
ligne 14
15
squr
max_iter

int i ;
d o u b l e xn = x0 ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0.5 * (xn + (a / xn)) ;
}
10
2.0
11
2.0
12
res
???
nb_iters
15
main
a
v
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
return (0) ;
}
Itrations de la boucle (ici i = 2, xn = 1.41499)

IN101
106/1

1
2
3
4
Pile
xn
1.414214
15
ligne 14
15
squr
max_iter

int i ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
return (xn) ;
}
10
2.0
11
2.0
12
res
???
nb_iters
15
main
a
v
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
return (0) ;
}
Sortie de la boucle, prt retourner de la fonction squr

IN101
107/1

1
2
3
4
Pile
5
6
7
8
ligne 14
15
squr
max_iter

int i ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
}
10
2.0
11
2.0
12
res
???
nb_iters
15
main
a
v
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
return (0) ;
}
Retour de la fonction: suppression des variables locales, retourner

ladresse spcifie sur la pile
IN101
108/1

1
2
3
4
Pile
5
6
7
8
9

int i ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
}
10
11
2.0
res
1.414214
nb_iters
15
main
12
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
res = s q u r ( v , n b _ i t e r s ) ;
return (0) ;
}
Affectation de la valeur de retour de la fonction squr

IN101
109/1

1
2
3
4
Pile
5
6
7
arg[2]
1.414214
arg[1]
2.0
printf
ligne 15
9
10
format "sqrt (%f)..."

2.0
res
1.414214
nb_iters
15
11
12
main

int i ;
f o r ( i = 0 ; i < m a x _ i t e r ; i ++)
xn = 0 . 5 ( xn + ( a / xn ) ) ;
}
13
14
15
16
17
i n t main ( ) {
i n t n b _ i t e r s = 15 ;
printf ("sqrt (%f) = %f\n", v, res) ;
return (0) ;
}
Appel la fonction printf . . . etc . . .

IN101
110/1
Appels de fonctions rcursives

Rappel: une fonction rcursive se rappelle elle-mme.
Principe dappel identique ce que lon vient de voir.
chaque appel on empile les informations ncessaires.

Lorsque lon sort dun appel, on dpile.
La pile augmente avec la profondeur de rcursion.

En cas de rcursion trop profonde, possibilit de dpassement de pile
(stack overflow).
Pour autant la rcursivit nest pas banir !
Permet dexprimer simplement et lgamment certains algorithmes.

Incontournable pour certains problmes (sinon, obligation de se grer
manuellement une pile en fait).
Les compilateurs savent d-rcursiver la rcursion terminale !
IN101
111/1
Droulement dappels de fonction rcursive
Pile
2
3
1
2
3
4
fact main
ligne 10
n
9
10
11
fact
ligne 4
7
8
fact
ligne 4
n
5
6
fact
ligne 4
fact
ligne 4
unsigned int fact (unsigned int n)

{
i f ( n == 0 ) r e t u r n ( 1 ) ;
e l s e return ( n f a c t ( n 1) ) ;
}
12
i n t main ( )
{
unsigned i n t i = 5 ;
p r i n t f ( " F a c t (%d )=%d\n" , i , f a c t ( i ) ) ;
return (0) ;
}
tat de la pile lentre de lappel fact

avec largument 0.
IN101
112/1
Droulement dappels de fonction rcursive
Pile
2
3
4
5
1
2
3
4
fact main
ligne 10
n
9
10
11
fact
ligne 4
7
8
fact
ligne 4
n
fact
ligne 4
unsigned i n t f a c t ( unsigned i n t n )
{
i f ( n == 0 ) r e t u r n ( 1 ) ;
e l s e r e t u r n ( n * fact (n - 1) ) ;
}
12
i n t main ( )
{
unsigned i n t i = 5 ;
p r i n t f ( " F a c t (%d )=%d\n" , i , f a c t ( i ) ) ;
return (0) ;
}
tat de la pile au retour de lappel fact avec

largument 0.
IN101
113/1
Les tableaux
IN101
114/1
Limite des types de base
1 variable 1 case mmoire.

Par exemple 1 point dimage ARBG (alpha-rouge-vert-bleu):
T
transparence
R R R R G G G G B B B B 32 bits
rouge
vert
bleu
1 image 1024 768 = 786432 cases mmoires 32 bits.

Dclaration de 786432 variable ? M
Types de base insuffisants pour manipuler de grandes quantits de
donnes.
Besoin de structures de donnes.
IN101
115/1
Dessine-moi un tableau. . .
Tableau =
ensemble de cases mmoire conscutives,

du mme type,
dnot par un seul nom de variable.
Accs 1 case particulire (lment) par indexation: t[3].

Le type dun lment dtermine la taille dune case.
Si on connait o se trouve la 1re case, (base) on trouve
facilement lendroit o se trouve la ime case en mmoire.
Numrotation des cases (indices) commence 0 !
lmenti loctet: base + i taille dun lment.
IN101
116/1
Quand utiliser un tableau ?
Besoin de grouper plusieurs donnes de mme type.

Besoin daccder rapidement (tps constant) nimporte quel lment.
Chaque lment est identifi par son indice (place) dans le tableau.
Pas (peu) de trous entre les lments effectifs.
Un tableau est une structure:
Homogne.
Dense.
accs direct par indexation entire.
IN101
117/1
Tableaux et mmoire
Deux sortes de tableaux:
Statiques : taille connue la compilation.

grs la compilation comme des variables standard.
Dynamiques: taille dtermine lexcution.
Ncessite une primitive ou un fonction dallocation de mmoire.
Cours ultrieur: uniquement des tableaux statiques pour commencer.
Mmoire
Pile
Tas
sta
sta[2]
sta[1]
dyn[0] dyn[1] dyn[2] dyn[3]
sta[0]
int i ;
/ B l a b l a . . . i 4 /
/ Dynamique . /
i n t dyn [ ] = a l l o u e r i c a s e s
/ S t a t i q u e . /
int sta [3] ;
dyn
i
IN101
118/1
Dclaration de tableaux statiques en C

type nom [ taille ] ;
La taille doit tre connue la compilation:
Constante entire littrale.

(Certaines extensions de C autorisent des expressions non constantes).
int t [5] ;
t est un tableau de 5 entiers.
On prfre nommer la taille mettre un littral: plus facile pour

changer la taille et les traitement qui en dpendent.
Utilisation dun #define.
On change juste la valeur dinitialisation du define.
#d e f i n e SIZE ( 4 2 )
i n t t a b [ SIZE ] ;
f o r ( i = 0 ; i < SIZE ;
i ++) b l a b l a ( t a b [ i ] ) ;
IN101
119/1
Initialisation de tableaux
Lorsquon dclare un tableau, il nest pas initialis.
Il contient ce quil y avait dans la mmoire.
Comme pour les autres variables, il faut linitialiser:
donner une valeur chaque case.
Initialisation case par case:
float t [3]
t [ 0 ] = 1.0
t [ 1 ] = 1.5
t [ 2 ] = 2.0
;
;
;
;
Tableaux statiques: on peut initialiser dun coup la dfinition:

float t [ 3 ] = { 1.0 , 1.5 , 2.0 } ;
t = { 2.0, 4.7 } ; ne marche pas !

IN101
120/1
Parcours de tableaux
Un tableau tant une zone contigue indexe, il est naturel dutiliser
une boucle pour le parcourir.
Boucle sur les indices de 0 taille du tableau 1.
i n t t [ SIZE ] ;
int i = 0 ;
w h i l e ( i < SIZE ; i ++) {
do_something ( t [ i ] ) ;
i++ ;
}
Exemple: initialisation
i n t t [ SIZE ] ;
int i ;
f o r ( i = 0 ; i < SIZE ;
i ++) t [ i ] = i i
; / t [ i ] = i 2 . /
Boucle for trs pratique !

IN101
121/1
Petit retour sur les chanes de caractres string

En C: chane = un tableau de caractres. . .
. . . termin par le caractre \0.
str.c
i n t main ( )
{
int i ;
char foo [ ] = " s t u p e f i x " ;
f o r ( i = 0 ; f o o [ i ] != \0 ;
p r i n t f ( "%c " , f o o [ i ] ) ;
p r i n t f ( " \n" ) ;
i ++)
mymac:/tmp$ gcc str.c -o str

mymac:/tmp$ ./str
s t u p e f i x
return (0) ;
}
IN101
122/1
Tableaux plusieurs dimensions
Une image est une partie de plan: coordonnes x et y .

Espace 2 dimensions structure 2 D tableau 2 dimensions.
type nom [ taille1 ][ taille2 ] ;
Accs par indexation sur les 2 dimensions: t [x ][ y] = ... ;
Gnralisable n dimensions: int t [3][2][6][7][4]
Tailles de tableaus statiques: connues la compilation.

Tableaux dynamiques: subtilits dinitialisation, on verra plus tard.
IN101
123/1
Tableaux statiques plusieurs dimensions

st_array.c
#define X (4)
#define Y (3)
i n t main ( )
{
int x , y ;
i n t c[X][Y] ; / S t a t i q u e / /
f o r ( x = 0 ; x < X ; x++) {
f o r ( y = 0 ; y < Y ; y++)
c[x ][ y] = x + y ;
}
for (x = 0; x <
for (y = 0; y
p r i n t f ( "%d
p r i n t f ( " \n" )
}
return (0) ;
mymac:/tmp$ gcc st_array.c -o st_array

mymac:/tmp$ ./st_array
c:
0 1 2
1 2 3
2 3 4
3 4 5
X ; x++) {
< Y ; y++)
" , c [x ][ y ]) ;
;
}
IN101
124/1
Un tableau bien utile: argv du main

Rappel du prototype: int main (int argc , char argv [])
argv: Tableau contenant les chanes de caractres passes sur la ligne
de commande lors du lancement du programme.
Permet de dialoguer avec lentre du programme ds son lancement.
Contient toujours au moins 1 chane: argv[0] = nom du programme.
args.c
i n t main ( i n t a r g c , c h a r a r g v [ ] )
{
int i ;
f o r ( i = 0 ; i < a r g c ; i ++)
p r i n t f ( " i=%d %s \n" , i , a r g v [ i ] ) ;
return (0) ;
}
mymac:/tmp$ dmd args.d

mymac:/tmp$ ./args bar gee 42
i=0 ./args
i=1 bar
i=2 gee
i=3 42
IN101
125/1
Quelques remarques sur argv (1)

Dterminer le nombre dlments pour savoir jusquo aller dans argv.
Utilisation de la valeur de argc.
mymac:/tmp$ ./args bar gee 42
Mmoire
Pile
Tas
4 2
argv[2]
argv[1]
argv[0]
g e e
b a r
IN101
126/1
argv contient uniquement des chanes de caractres.

On peut parfois recevoir des nombres en arguments.
Ncessit de conversion chane nombre.
Ncessite une transformation algorithmique, et non un changement
simple de regarder la zone mmoire !
Fonctions disposition (requirent #include <stdlib.h>):
atoi : string int

atol : string long int
atoll : string long long int
atof : string float
IN101
127/1

string-to-nums.c
#i n c l u d e < s t d l i b . h> /* Pour accder a atoXXX */
i n t main ( i n t a r g c , c h a r a r g v [ ] )
{
int i = a t o i ( argv [ 1 ] ) ;
long l = a t o l ( argv [ 2 ] ) ;
long long l l = a t o l l ( argv [ 3 ] ) ;
f l o a t f = atof ( argv [ 4 ] ) ;
p r i n t f ( " i : %d , l : %l d , l l : %l l d , f : %f \n" , i , l ,
return (0) ;
}
ll , f ) ;
mymac:/tmp$ gcc -Wall string-to-nums.c

mymac:/tmp$ ./a.out 1 2 4559924234322424 4.5
i: 1, l: 2, ll: 4559924234322424, f: 4.500000
IN101
128/1
Phases de construction dun excutable
IN101
129/1
Au dbut tait le source. . .
Tout programme provient dun code source crit dans un langage.

Transformations successives obtention dun excutable.
Code source = description statique.
Excutable = comportement dynamique.
Le langage inclut une smantique dynamique.
Excution dun programme = calcul effectif par une machine.
Donner vie lalgorithme.
Lui donner des donnes traiter.
IN101
130/1
Lanalyse lexicale (lexical analysis, lexing)

Dcouper le texte source en mots du langage.
Mots de C: if , int , else , break, switch . . .
Mots (lexmes) = suite de caractres.
plusieurs catgories de lexmes: littraux, mots-clefs, ponctuation,
identificateurs, blancs . . .
Mots dcrits par des expressions rgulires (c.f. sance future).
i n t
m a i n
( )
{
i n t
i
=
42
+ 3
;
p r i n t f
( " B l a b l a b l a " )
r e t u r n
( 0 )
;
}
IN101
131/1
Lanalyse syntaxique (syntactic analysis, parsing)

Combiner les mots en phrases grammaticalement bien formes.
Grammaire franaise: sujet verbe complment.
Langages de programmation ont aussi leurs grammaires.
Ex: switch ( expression ) { . . . }
Permet de rejeter les phrases mal structures.
syntaxerr.c
void f ()
{
int i = 6 ;
switch i ) {
case 0 : break ;
}
}
mymac:/tmp$ gcc syntaxerr.c

syntaxerr.c: In function f:
syntaxerr.c:4: error: expected ( before i
syntaxerr.c:4: error: expected statement before ) token
syntaxerr.c:5: error: case label not within a switch state
syntaxerr.c:5: error: break statement not within loop or s
IN101
132/1
Typage (typechecking)
Analyses lexicale et syntaxique insuffisantes pour garantir quun
programme a un sens.
Pareil en Franais: Lilo est Stitch dessiner M
Besoin danalyse smantique : sur le sens des phrases.
Typage: vite de mlanger torchons et serviettes.
Force manipuler les objets de manire cohrente.
Avec les constructions qui leur sont ddies:
"Foo" + "Bar"
3+5
printf + 15
cos (3.14159)
cos (3.14159, 1.41421)
IN101
133/1
Production de code / Optimisation

Fin des vrifications de correction.
Optimisations:
Partage dexpressions communes.

Droulement de boucles.
Propagation de constantes, etc . . .
Transformation instructions du langage instructions machine

(assembleur).
Dpendant de larchitecture cible.

Allocation de registres.
Optimisations machine-dpendantes.
Nombre dinstructions machine >> nombre dinstructions du source.
.cstring
LC0:
.ascii "%*d\12\0"
.text
.globl _main
_main:
LFB3:
pushq
%rbp
LCFI0:
LCFI1:
LCFI2:
movq
subq
movl
movq
movl
movl
movl
%rsp, %rbp
$32, %rsp
%edi, -20(%rbp)
%rsi, -32(%rbp)
$123, -4(%rbp)
$10, -8(%rbp)
-4(%rbp), %edx
...
IN101
134/1
Assemblage
Transformation fichier par fichier.
Instructions machine encodage binaire.
fichiers objet (.o).
Laisse des trous pour les variables / fonctions des autres fichiers.
0x0000000100000efb
0x0000000100000f02
0x0000000100000f09
0x0000000100000f0c
0x0000000100000f0f
...
<main+15>:
<main+22>:
<main+29>:
<main+32>:
<main+35>:
movl
movl
mov
mov
lea
$0x7b,-0x4(%rbp)
$0xa,-0x8(%rbp)
-0x4(%rbp),%edx
-0x8(%rbp),%esi
0x1e(%rip),%rdi
0x100000eec
0x100000ef4
0x100000efc
0x100000f04
...
<main>: 0x55 0x48 0x89 0xe5 0x48 0x83 0xec 0x20

<main+8>: 0x89 0x7d 0xec 0x48 0x89 0x75 0xe0 0xc7
<main+16>: 0x45 0xfc 0x7b 0x00 0x00 0x00 0xc7 0x45
<main+24>: 0xf8 0x0a 0x00 0x00 0x00 0x8b 0x55 0xfc
IN101
135/1
dition de liens (link)
Fusion de tous les fichiers objets.

Rsolution des trous.
Ajout dinformations dpendantes de la cible (machine / OS).
1 seul fichier binaire au format excutable.
IN101
136/1
Chargement / Excution
But: amener le code excuter en mmoire/

ROM, RAM, EPROM . . . dpend du matriel.
Mthode de chargement dpend du matriel:
Par le loader de lOS sur ordinateur habituel.

Par un matriel de transfert externe (cartouches de jeux . . . ).
Parfois, chargement de resources (bibliothques partages).

Une fois le code accessible en mmoire: droutement du CPU vers le
dbut du code.
IN101
137/1
Organisation mmoire et pointeurs
IN101
138/1
Organisation de la mmoire
Pour le processeur: mmoire = grand tableau fini doctets:
de taille 232 sur machine 32 bits,

de taille 264 sur machine 64 bits.
Tout le tableau nest pas utilisable:
Une partie de la mmoire est utilise par les autres processus.

Certaines zones sont rserves au systme.
Certaines zones peuvent tre restreintes en accs
(lecture/criture/excution).
Certaines zones peuvent tre non connectes (pas de mmoire
physique prsente).
IN101
139/1
cologie et politesse en mmoire
Ressource en quantit finie gestion de ressource:
En demander au besoin: allocation.

La restituer: libration (dsallocation).
Arbitrage et autorisation daccs grs par le systme dexploitation

(OS).
Allocation et libration via des appels systmes.
Accs une zone non attribue au processus segmentation fault.
Toujours avoir demand la mmoire que lon veut utiliser.
IN101
140/1
Adresse mmoire
Les informations, octets, ints, chanes sont stockes en mmoire.

Sont loges un certain endroit de la mmoire: adresse.
Adresse index de linfo dans le grand tableau de la mmoire.
Mmoire
0 1 2 3 4 5 ...
42
1 octet
1 int (= 4 octets)
son adresse
IN101
141/1
Adresses et pointeurs (1)

Une adresse est une information comme une autre.
Besoin de la mmoriser, manipuler et daccder son contenu.
Une valeur adresse est un pointeur.
Une variable contenant une adresse est de type pointeur.
Mmoire
0
char c = A
Adresse c = 21
21
A
26
0 0 0 0 2 1
Pointeur sur c
contient la valeur 21
Adresse du pointeur =
26
une adresse se trouve une donne dun certain type.

Un pointeur est une adresse avec un type associ: le type des
donnes stockes cette adresse.
IN101
142/1

Un pointeur dsigne un point dans la mmoire:
location dune donne,

ou location du dbut dune zone contigue de donnes.
Dclaration de pointeurs en C:
i n t a ;
s h o r t b ;
s h o r t c ;
// a e s t un p o i n t e u r v e r s un / d e s i n t .
// b e s t un p o i n t e u r v e r s un / d e s s h o r t ( i n t ) .
// c e s t un p o i n t e u r v e r s un / d e s s h o r t .
Mmoire
0
...
0 0 0 0 4 2
0 0 0 0 0 7
Un int valant 42
Pointeur sur int: int*
28
4 6 5
Un short valant 465
38
0 0 0 0 3 8
0 0 0 0 2 8
Pointeur sur short: short*

Pointeur sur pointeur sur short: short**
IN101
143/1

Chaque variable possde une adresse.
Obtenir ladresse dune variable: oprateur prfixe &.
Accder au contenu dune adresse: oprateur prfixe*.
int a ;
i n t b ;
b = &a ;
b = 5 ;
a = 1 + b ;
//
//
//
//
//
//
a e s t un i n t .
b e s t un p o i n t e u r v e r s un i n t .
b c o n t i e n t l a d r e s s e de a > P o i n t e u r v e r s a .
On s t o c k e 5 d a n s b . > Dans a .
On s t o c k e d a n s a 1 + l a v a l e u r c o n t e n u e
l a d r e s s e b . > a = a + 1 .
& et * ont des rles symtriques: *(&a) est la mme chose que a.
ATTENTION: avoir un pointeur sous la main ne signifie pas avoir le droit
de manipuler la mmoire ladresse contenue par ce pointeur !
IN101
144/1
Pourquoi un pointeur doit avoir un type (1)
Une adresse est juste un entier positif.

En mmoire on stocke des infos dun certain type:
donc dune certaine forme.
Laccs une info dpend de la forme de cette info.
Laccs une info par un pointeur dpend de la forme de linfo
contenue cette adresse.
Un pointeur doit spcifier ladresse de quoi il est.
Les pointeurs sont donc typs
char : pointeur sur char.

int : pointeur sur int.
IN101
145/1
Pourquoi un pointeur doit avoir un type (2)
Quand on lit la valeur de *v:
Si a est un char, on ne lit quun octet,

Si a est un int, on lit 4 octets,
Si a est un double, on lit 8 octets.
Les tableaux sont dsigns par ladresse de leur 1re case.
t[i] nest pas le i me octet, mais le i me lment.

Il faut savoir de combien doctets avancer (i 4, i 8 . . . )
Ncessaire de connaitre la taille dun lment donc son type.
IN101
146/1
Exemple de manipulations de pointeurs (1)

Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
???
e
d
c
b
a
???
???
???
???
i n t main ( )
{
i n t a , b , c ,
a = 3 ;
b =
c = &b ; d =
c = 4 ;
d = ( c ) + 3
e = &c ;
e = d ;
e = &a ;
...
}
d , e ;
5 ;
&a ;
;
Chaque case mmoire a une adresse.

Par habitude et simplicit, adresses crites en hexadcimal.
IN101
147/1
Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
???
e
d
c
b
a
???
5
3
???
i n t main ( )
{
i n t a , b , c , d , e ;
a = 3 ; b = 5 ;
c = &b ; d = &a ;
c = 4 ;
d = ( c ) + 3 ;
e = &c ;
e = d ;
e = &a ;
...
}
IN101
148/1

Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
???
e
d
c
b
a
0x1200
0x1204
5
3
i n t main ( )
{
i n t a , b , c , d , e ;
a = 3 ;
b = 5 ;
c = &b ; d = &a ;
c = 4 ;
d = ( c ) + 3 ;
e = &c ;
e = d ;
e = &a ;
...
}
c et d contiennent les adresses de b et a.

Ils pointent vers b et a.
IN101
149/1

Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
???
e
d
c
b
a
0x1200
0x1204
4
3
i n t main ( )
{
i n t a , b , c ,
a = 3 ;
b =
c = &b ; d =
c = 4 ;
d = ( c ) + 3
e = &c ;
e = d ;
e = &a ;
...
}
d , e ;
5 ;
&a ;
;
On suit le pointeur dans c et on stocke 4 dans la case mmoire

correspondante dans b.
IN101
150/1

Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
???
e
d
c
b
a
0x1200
0x1204
4
7
i n t main ( )
{
int a , b ,
a = 3 ;
c = &b ;
c = 4 ;
d = ( c )
e = &c ;
e = d
e = &a ;
...
}
c , d , e ;
b = 5 ;
d = &a ;
+ 3 ;
;
gauche du = : case mmoire o ira le rsultat.

droite du = : on value, i.e. on suit le pointeur c et on regarde ce
qui est dans la case.
IN101
151/1
Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
e
d
c
b
a
0x1208
0x1200
0x1204
4
7
i n t main ( )
{
i n t a , b , c ,
a = 3 ;
b =
c = &b ; d =
c = 4 ;
d = ( c ) + 3
e = &c ;
e = d ;
e = &a ;
...
}
d , e ;
5 ;
&a ;
;
e pointe vers c.
IN101
152/1

Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
e
d
c
b
a
0x1208
0x1200
0x1204
7
7
i n t main ( )
{
int a , b ,
a = 3 ;
c = &b ;
c = 4 ;
d = ( c )
e = &c ;
e = d ;
e = &a ;
...
}
c , d , e ;
b = 5 ;
d = &a ;
+ 3 ;
Double toile: on suit deux pointeurs la suite

I.e. pointeur sur un pointeur.
I.e. variable qui contient (ladresse dune variable qui contient
(ladresse dune variable)).
IN101
153/1

Pile
0x1224
0x1220
0x121c
0x1218
0x1214
0x1210
0x120c
0x1208
0x1204
0x1200
e
d
c
b
a
0x1208
0x1200
0x1200
7
7
i n t main ( )
{
i n t a , b , c ,
a = 3 ;
b =
c = &b ; d =
c = 4 ;
d = ( c ) + 3
e = &c ;
e = d ;
e = &a ;
...
}
d , e ;
5 ;
&a ;
;
Deux pointeurs peuvent contenir la mme adresse (alias).
On peut faire un test dgalit dessus (c == d).

On peut aussi comparer les contenus (c == d).
IN101
154/1
Allocation et libration de mmoire
IN101
155/1
Statique versus dynamique (1)
Allocation statique: effectue la compilation.

Ex: variables entires dclares, tableaux de taille fixe:
int v = 42 ;
char s [10] ;
Dans la pile (variable locale) ou dans le tas/section-data (variable
globale).
Allocation statique locale: automatiquement libre en fin de fonction.

Comment faire si on veut faire durer la donne plus longtemps ?
IN101
156/1
Statique versus dynamique (2)
Parfois, mmoire ncessaire connue seulement lors de lexcution:
Lecture du contenu dun fichier: taille des fichiers variable.

Rsolution dun systme dquations: nombre dinconnues la
demande de lutilisateur.
Changer le programme manuellement re-compiler ?

Inefficace, non-maintenable, inacceptable.
On demande de la mmoire selon les besoins lexcution.
Zone alloue retourne dsigne par son adresse de dbut.
IN101
157/1
Allocation dynamique
Allocation de nimporte quoi: entier, entiers (tableau), struct, etc.

Tableau dynamique C pointeur dont la valeur est ladresse de dbut
du tableau.
t[0] *t.
&(t[0]) t.
On dclare un tableau comme un pointeur.
Le pointeur est alors non initialis (pointe nimporte o).

On alloue de la mmoire (fonction malloc) une adresse . . .
. . . et on enregistre cette adresse dans le pointeur.
IN101
158/1
Allocation dynamique : malloc
malloc: int void*

Argument: nombre doctets demands.
Rsultat: adresse du dbut de la zone octroye.
void : pointeur sans type
Implicitement compatible avec autres types de pointeurs.

On ne le cast pas !
Si mmoire non disponible: rsultat = pointeur NULL.

Toujours tester la russite de lallocation !
if (ptr == NULL) grer lerreur
Sinon criture dans une zone non alloue et segmentation fault
la clef.
IN101
159/1
Pas pas (1)
#i n c l u d e < s t d i o . h> // p r i n t f
#i n c l u d e < s t d l i b . h> // m a l l o c , f r e e
i n t main ( )
{
float t ;
int n ;
t = malloc (5 s i z e o f ( f l o a t ) ) ;
i f ( t == NULL ) e x i t ( 1 ) ;
t [ 2 ] = 3.14159 ;
p r i n t f ( "%f \ n " , t [ 2 ] ) ;
free ( t ) ;
return (0) ;
}
Pile
Tas
?
?
n
t
???
???
Variables locales t et n alloues sur la pile. . .

. . . mais pas initialises.
Pointeur t dsigne une adresse quelconque. . .
. . . et vraisemblablement invalide.
IN101
160/1
Pas pas (2)

i n t main ( )
{
float t ;
int n ;
i f ( t == NULL ) e x i t ( 1 ) ;
t [ 2 ] = 3.14159 ;
p r i n t f ( "%f \ n " , t [ 2 ] ) ;
free ( t ) ;
return (0) ;
}
Pile
Tas
t[0] t[1] t[2] t[3] t[4]
?
n
t
???
sizeof: construction du compilateur, taille dune donne en octets.

Nest pas une fonction.
Taille lmentaire: dpend de plein de choses (architecture, modle
de compilation, etc.).
Appel la fonction dallocation de mmoire malloc.
Assignation du rsultat au pointeur t.
t dsormais initialis. . .
. . . Mais quoi ?
IN101
161/1
Pas pas (3)

i n t main ( )
{
float t ;
int n ;
i f ( t == NULL ) e x i t ( 1 ) ;
t [ 2 ] = 3.14159 ;
p r i n t f ( "%f \ n " , t [ 2 ] ) ;
free ( t ) ;
return (0) ;
}
Pile
Tas
t[0] t[1] t[2] t[3] t[4]
?
n
t
???
Si pas de mmoire octroye, pointeur retourn alors NULL.

Alors pas possible de continuer (ou grer lerreur comme il se doit).
NULL dsigne une adresse interdite en lecture/criture
Segmentation Fault.
IN101
162/1
Pas pas (4)
i n t main ( )
{
float t ;
int n ;
i f ( t == NULL ) e x i t ( 1 ) ;
t [ 2 ] = 3.14159 ;
p r i n t f ( "%f \ n " , t [ 2 ] ) ;
free ( t ) ;
return (0) ;
}
Pile
Tas
t[0] t[1] t[2] t[3] t[4]
?
n
t
? 3.14 ?
???
criture dans une partie de la mmoire alloue.

Autoris puisque la mmoire nous appartient.
IN101
163/1
Pas pas (5)

i n t main ( )
{
float t ;
int n ;
i f ( t == NULL ) e x i t ( 1 ) ;
t [ 2 ] = 3.14159 ;
p r i n t f ( "%f \ n " , t [ 2 ] ) ;
free ( t ) ;
return (0) ;
}
Pile
Tas
?
n
t
? 3.14 ?
???
Rendre la mmoire plus utile au systme viter la pnurie.

Nefface pas la mmoire.
Nefface pas le pointeur.
Rvoque simplement lautorisation daccs.
On a encore les moyens technique dy accder. . .
. . . mais Segmentation Fault gute.
IN101
164/1
Pas pas (5 2 )
i n t main ( )
{
float t ;
int n ;
i f ( t == NULL ) e x i t ( 1 ) ;
t [ 5 ] = 3.14159 ;
p r i n t f ( "%f \ n " , t [ 2 ] ) ;
free ( t ) ;
return (0) ;
}
Pile
Tas
t[0] t[1] t[2] t[3] t[4]
?
n
t
???
Tentative daccs la case 5 (6me case). . .

Accs en dehors de la zone alloue.
Peut appartenir un autre (systme, processus . . . )
Segmentation Fault la clef !
Mais . . . cest pas forcment immdiat ! M
Bugs difficiles trouver et rendre reproductibles.
IN101
165/1
Libration de mmoire
Fonction free: void* void
Argument: adresse de dbut de la zone librer.

Rsultat: nant.
chaque malloc doit correspondre 1 et 1 seul free.

La libration de mmoire est explicite.
Taille de la zone connue par le systme: pas besoin de la spcifier.
Librer au plus tt: inutile de consommer de la mmoire inutilement.
Pourra tre r-attribue quelquun dautre.
Ne pas librer trop tt.
Tant quune zone mmoire accessible y fait rfrence, la zone
alloue ne doit pas tre libre.
IN101
166/1
Allocation dynamique et erreurs courantes

Ne pas initialiser un pointeur (i.e. ne pas allouer via malloc).
Accder en dehors dune zone alloue (dbordement).
Faire free dans une boucle (dsallocations multiples de la zone).
Faire free avec une adresse non alloue dynamiquement.
Faire free avec une adresse qui nest pas le dbut de la zone.
Perdre ladresse dune zone alloue:
i n t p = m a l l o c ( . . . ) ;
...
// On ne m m o r i s e p a s l a v a l e u r de p a i l l e u r s .
return ( . . ) ;
Impossible de dsallouer.
Fuites mmoire et dgradation de performances avec le temps.
IN101
167/1
Les tableaux dynamiques plusieurs dimensions (1)

Vus prcdemment: char t [5][3] ;
Comment faire si dimensions non fixes ? Allocation dynamique.
Solution 1:
Un grand tableau de taille DIM1 DIM2 = 5 3.
Linarisation de ladressage: t[x][y ] z t[y DIM1 + x].
char t[5][3]
0
char t[15]
2
0
1
Mmoire
0
12
13
14
10
11
2
t[3][1]
t[(1 * 5) + 3] = t[8]
Exactement le cas de la mmoire graphique.
IN101
168/1

Comment faire si le tableau nest pas rectangulaire ?
Tableau de pointeurs.
Chaque pointeur pointe vers un tableau de taille propre.
Exemple largument char *argv[] du main.
Chaque chane peut avoir une longueur diffrente.
Pile
Tas
't' 'r' 'o' 'i' 's' '\0'
[4
1]
[3
1]
b[
ta
[2
1]
b[
b[
ta
[1
ta
1]
1]
b[
b[
ta
ta
[2
0]
[1
b[
0]
ta
0]
b[
ta
ta
tab
b[
[0
[0
tab[0] tab[1] tab[2]
'd' 'e' 'u' 'x' '\0'
'U' 'n''\0'
IN101
169/1

Tableau dints 2 dimensions, n, m: tableau de pointeurs sur int.
int t ;
On alloue n pointeurs ( 1 allocation) . . .
On alloue n fois m ints ( n allocations).
Mme schma de libration de mmoire.
int i ;
i n t t ;
t = malloc (n
for ( i = 0; i <
t [ i ] = malloc
...
for ( i = 0; i <
free ( t [ i ]) ;
free ( t ) ;
s i z e o f ( i n t ) ) ;
n ; i ++)
(m s i z e o f ( i n t ) ) ;
n;
i ++)
(PS: Cest mal: on na pas test le succs des allocations !)

IN101
170/1
Passage par adresse
IN101
171/1
Retourner plusieurs valeurs ?
Parfois une fonction fournit plusieurs rsultats en sortie.

Ou un rsultats composite.
Ex: vu en TD, filtrage dun point par convolution.
Retourne 3 composantes: rouge, vert, bleu.
Utiliser des variables globales est peu satisfaisant.
IN101
172/1
Passage par valeur

En C, paramtres passs par valeur:
1
2
Ils sont valus

Ils sont copis sur la pile avant lappel.
Impossible de modifier une variable de lappelant depuis lappel.

Pile
void g ( in t v )
{
v++ ;
}
void f ()
{
int x = 5 ;
g (x) ;
}
Fct g
5 6
@retour
Fct f
IN101
173/1
Passage par adresse

Et si la place on passait ladresse de la variable x ?
Cest ladresse qui serait copie.
Dans g on a donc un pointeur vers x de lappelant.
Il suffit de modifier la valeur pointe: (v)++
Pile
v o i d g ( i n t v )
{
( v )++ ;
}
void f ()
{
int x = 5 ;
g ( &x ) ;
}
*x cest l
Fct g
@x
@retour
Fct f
6 5
IN101
174/1
Exploitation du passage par adresse

Pour retourner plusieurs rsultats, une fonction n qu prendre
ladresse de variables o stocker ses rsultats.
Mode de passage de paramtres appel out (c.f. scanf).
i n t random_array ( i n t s i z e ) {
s i z e = 1 + random ( ) ;
return ( malloc ( s i z e s i z e o f ( i n t ) ) ) ;
}
La fonction peut aussi utiliser les valeurs initiales ce ces arguments

avant de les craser.
Mode de passage de paramtres appel in/out.
void s c a l e _ p o i n t ( i n t x , i n t y , i n t s c a l e ) {
x = x s c a l e ;
y = y s c a l e ;
}
Rem: un tableau tant un pointeur sur la 1re case, il est forcment

pass par adresse !
IN101
175/1
Structures de donnes lmentaires
IN101
176/1
Le besoin
Vus jusqu prsent:
Scalaires (entiers, flottants, caractres),

Chanes de caractres,
Tableaux.
Comment modliser un employ avec les informations:
nom,
prnom,
date de naissance,
sexe,
status (vacataire, contractuel ou fonctionnaire),
etc. ?
Besoin de structures de donnes.
IN101
177/1
Types numrs (1)

Un feu tricolore: vert ou orange ou rouge . . .
. . . et cest tout !
Besoin de valeurs atomiques disjointes (somme disjointe).
Encoder par des entiers ?
int vert = 0, orange = 1, rouge = 2 ;
La valeur entire importe peu pourquoi devoir la spcifier ?
Spcifier les valeurs: source derreur si on r-attribue la mme valeur:
int vert = 0, orange = 2, rouge = 2 ;
En plus, ce nest pas typ: a ne reste que des entiers.
Compatible avec
int vacataire = 0, contractuel = 1, fonctionnaire = 2 ;
IN101
178/1
Types numrs (2)

Dclaration dun type numr: enum nomtype = { valeur, ... };
Dclaration dune variable: enum nomtypeenum nomvariable ;
Utilisation des valeurs: valeur
enum c o u l e u r _ t { Rouge , Orange , V e r t } ;
enum s t a t u t _ t { V a c a t a i r e , C o n t r a c t u e l , F o n c t i o n n a i r e } ;
v o i d f ( enum c o u l e u r _ t c )
{
enum s t a t u t _ t s = V a c a t a i r e ;
switch ( c ) {
c a s e Rouge : s = V a c a t a i r e ; b r e a k ;
c a s e Orange : s = C o n t r a c t u e l ; b r e a k ;
case Vert : s = F o n c t i o n n a i r e ; break ;
d e f a u l t : break ;
// Ne d e v r a i t j a m a i s s e p r o d u i r e .
}
}
IN101
179/1
Les structures (1)

Besoin dagrger des donnes de types diffrents.
Tableaux ? NON car agrgent uniquement des donnes de mme
type.
Besoin de runir plusieurs formes de donnes ayant trait un mme
concept.
Structure: groupement de donnes par champs nomms.
enum s e x e _ t { Femme , Homme } ;
s t r u c t employe_t {
c h a r nom [ 4 ] , prenom [ 4 ] ;
enum s e x e _ t s e x e ;
u n s i g n e d i n t j _ n a i s s , m_naiss , a _ n a i s s ;
};
IN101
180/1
Les structures (2)

Dclaration de variable: struct nomtypestruct nomvariable ;
struct employe_t e1 ;
Initialisation la dclaration: numration dans lordre entre accolades
et spares par des virgules:
struct employe_t e1 =
{ "D.", "Duck", 9, 6, 1934, Homme } ;
Accs une donne par nom de champ:
Notation pointe si struct employe_t s:
printf ("%s, %s\n", e1.nom, e1.prenom);
Notation flche si struct employe_t s:
printf ("%s, %s\n", e1>nom, e1>prenom);
Nommage des champs:
Facilit daccs aux diffrentes parties.

Indpendance par rapport lorganisation en mmoire.
IN101
181/1
Les structures (3)

Champs stocks de manire contigue en mmoire.
Attention: il peut y avoir des trous entre les champs
Contraintes darchitecture matrielle, de performance, etc.
Ne pas sappuyer sur lagencement effectif mmoire.
e1
nom
prenom
sexe
j_naiss
m_naiss
a_naiss
4 chars
4 chars
Mmoire
Les structures sont gres comme les autres types:
Peuvent tre des variables locales (dtruites en fin de porte).

Recopies lorsque passes en argument de fonction.
Pour de grosses structures, cot de recopie et cot de pile !
Les passer comme argument par adresse (passer le pointeur).
IN101
182/1
Les unions (1)
Besoin de valeurs NON-atomiques disjointes (somme disjointe

encore).
Mme besoin que pour les enum mais NON-atomiques
Ajout de structure.
Systme de calcul formel: comment modliser une formule qui est:
soit
soit
soit
soit
une
une
une
une
constante,
variable,
opration (+ - * /) entre formules,
fonction (cos, tan) prenant une formule en argument.
IN101
183/1
Les unions (2)

Premire solution: faire une structure avec tous les champs possibles:
enum op_t { P l u s , Moins , F o i s , D i v } ;
enum fun_t { Cos , S i n , Tan } ;
s t r u c t expr_t {
double c s t ;
enum op_t o p e r ;
s t r u c t expr_t arg1 ;
s t r u c t expr_t arg2 ;
enum fun_t fname ;
};
/* Pointeur sur une struct expr_t. */
Aucune garantie par le typage que lon initialise/manipule
tous les bons champs

(ex: + prend 2 arguments, ne pas en oublier un)
et uniquement les bons champs
(ex: une constante na pas lieu davoir une info de fonction)
IN101
184/1
Les unions (3)

struct binexpr_t {
enum op_t o p e r ;
union expr_t arg1 ;
union expr_t arg2 ;
};
struct funexpr_t {
enum fun_t f t y p e ;
union expr_t arg ;
};
union expr_t {
double as_cst ;
struct binexpr_t as_binexpr ;
struct funexpr_t as_funexpr ;
};
Variable de type union: peut

contenir une valeur de nimporte
quel type nonc dans lunion.
Attention: ce nest pas de
lagrgation !
Contrairement aux struct: les
diffrentes formes de valeurs sont
stockes au mme endroit.
un instant t, il ny a toujours
quune seule valeur stocke.
IN101
185/1
Les unions (4)

Union = diffrentes faons de voir une mme zone mmoire.
La mmoire rserve est la taille du type le plus grand.
Mmoire
oper_t
expr_t
expr_t
binexpr_t
fun_t
expr_t
funexpr_t
double
double
Laccs une forme de linfo contenue implique la considrer de ce

type.
Accs par nommage du champ reprsentant ce type:
union expr_t e ;
e.as_cst = 6.0 ;
e.as_binexpr.oper = Plus ;
IN101
186/1
Utilisation des unions

Union diffrentes vues dune mme zone mmoire.
Comment savoir quelle est la vue correcte un instant t ?
Exemple: initialisation comme une expression de constante, relecture
comme une expression de fonction:
union expr_t e ;
e . as_cst = 6.0 ;
p r i n t f ( e . as_binexpr . oper ) ;
mymac:/tmp$ gcc -Wall test.c

mymac:/tmp$ ./a.out
0
Cest juste incohrent !

Principalement, 2 schmas dutilisation selon la connaissance de la
forme de la valeur traiter.
Connaissance dynamique (varie au cours du temps).

Connaissance statique (fige en fonction de lendroit dans le
programme).
IN101
187/1
Utilisation dynamique des unions

La forme de la valeur nest pas connue a priori.
Exemple: un valuateur dexpressions arithmtiques.
Ncessit de tester lexcution.
Crer une struct avec un marqueur disant comment regarder la
valeur dans lunion qui suit.
...
union allexpr_t {
double as_cst ;
s t r u c t binexpr_t as_binexpr
s t r u c t funexpr_t as_funexpr
};
{
s t r u c t expr_t e
...
switch ( e . kind )
c a s e E_cst : . . .
c a s e E_bin : . . .
c a s e E_fun : . . . .
}
...
;
;
enum e k i n d _ t { E_cst , E_bin , E_fun } ;

s t r u c t expr_t {
enum e k i n d _ t k i n d ;
union a l l e x p r _ t data
};
;
{
break ;
break ;
break ;
}
;
IN101
188/1
Utilisation statique des unions

La forme de la valeur est connue la compilation aux points de
manipulation dans le programme.
Exemple: srialisation (codage de donnes mmoire pour partage).
Exemple: transfert de mots mmoire octets par octets.
union byte_int_t {
i n t as_int ;
char as_bytes [ 4 ] ;
};
i n t main ( )
{
union byte_int_t b i ;
b i . as_int = 0 x01234567 ;
p r i n t f ( " 0 x%x \ n " , b i . a s _ i n t ) ;
p r i n t f ( " 0 x%02x 0 x%02x 0 x%02x 0 x%02x \ n " ,
b i . as_bytes [ 0 ] , b i . as_bytes [ 1 ] ,
b i . as_bytes [ 2 ] , b i . as_bytes [ 3 ] )
;
return (0) ;
}
mymac:/tmp$ gcc endian_union.c

mymac:/tmp$ ./a.out
0x1234567
0x67 0x45 0x23 0x01
Attention: dpendance de lorganisation mmoire !

IN101
189/1
Structuration, modularit et abstraction

Besoin de rendre le logiciel robuste
Aux changements de structure / implmentation interne.

Aux modifications sauvages mettant en pril des invariants.
Diffrentes formes de structures de donnes vues. . .

Utiliser la plus adapte au modle implmenter !
Ex: struct 4 champs nord, sud, est, ouest versus tableau de
taille fixe = 4.
Modularit: rpartir dans des fichiers diffrents les traitements sur des
concepts diffrents.
Projet raliste = plusieurs 10aines de milliers de lignes
Tout nest pas dans le mme fichier.
Rpartition en fonction des sous-problmes.
IN101
190/1
Structuration, modularit et abstraction (2)

Abstraction: ne montrer lextrieur que le minimum.
Grce des fichiers dentte (headers) qui exportent des interfaces.
Fichiers .h en C.
Interface: ensemble des informations visible propos dun module
logiciel.
Empche les intrusions irrespectueuses dans les structures de
donnes.
Permet de changer lalgorithmique interne non visible sans changer le
reste du systme.
Plusieurs manires dabstraire:
Cacher totalement Plus aucune information dexistence.

Rendre opaque: existence prserve mais structure intime cache.
IN101
191/1
Bonnes pratiques
IN101
192/1
Le besoin
Dans un dveloppement logiciel, plusieurs choses primordiales:
a doit marcher.
Le code doit tre comprhensible et maintenable.
Premier point: parat vident (mais pas toujours respect).

Second point: rarement pris en compte (donc encore plus rarement
respect).
Ncessit de discipline de dveloppement.
Discipline dans le code source et dans la documentation.
IN101
193/1
La documentation
Un programme nest pas write-only.
Programmes actuels:
Plusieurs centaines de Kloc.

quipes de 10aines ou 100aines de personnes.
Code reprendre pas toujours crit par soi-mme.
Sans documentation, cest mort ! (Dj avec cest dur M).

Deux formes de documentation:
Documents externes au code source:
Cahier des charges (donneur dordre).

Spcification (concepteur systme).
Document darchitecture logicielle (implmentation).
Dossiers de tests (validation).
Etc.
Documentation dans le code source: commentaires.
IN101
194/1
Les commentaires (1)
Texte ignor par le compilateur: ne cote rien en performances.

En C, / / ou // jusqu la fin de la ligne.
Les commentaires ne paraphrasent pas le code:
i ++ ; / On incrmente i . / Bof M
On sen sert:
Comme entte de fonction (description du traitement, des paramtres,

de la valeur retourne, des effets de bord. . . )
Entte de fichier source (expliquer ce que fait ce module).
Pour schmatiser, rsumer, expliquer haut niveau des sections de
code.
IN101
195/1
Les commentaires (2)

Outils de gnration automatique de doc partir des commentaires
(XCode, Doxygen, Javadoc . . . )
Commentaires formats avec des balises.
Vous en choisissez un, si vous voulez . . . ou pas . . .
Mais a ne vous pargne pas de commenter !
/ ! \ b r i e f D e t e r m i n e s t h e o r d e r o f a p p a r i t i o n o f t h e names i n s i d e
c o m p i l a t i o n u n i t from i t s dependency graph .
the
inside a
\ param cu C o m p i l a t i o n u n i t t o p r o c e s s .
\ param dg U n i t s d e p e n d e n c y g r a p h .
\ r e t u r n : The l i s t o f names , f i r s t one i n h e a d o f t h e l i s t .
\ warning Because o f w e l l f o r m a t i o n p r o p e r t i e s , t h i s p r o c e s s s h o u l d n e v e r
f i n d a c y c l i c graph .
\ n o t e E x p o r t e d : No . /
s t r u c t n l i s t c o m p u t e _ r e o r d e r i n g ( s t r u c t c o m p u n i t cu , s t r u c t depg dg )
{
...
i f ( queue_elem == NULL ) {
/ I f t h e r e r e m a i n s n o d e s i n t h e [ o u t _ d e g r e e ] t a b l e , t h i s means t h a t t h e r e
e x i s t s n o d e s one c o u l d n o t c l a s s i f y b e c a u s e . . . /
...
}
}
IN101
196/1
Quelques conseils dans le code source (1)

Disclaimer: pas toujours respect dans mes slides; jai peu de place !
Indenter le code, sans utiliser de caractre tabulation.
Un bloc imbriqu doit tre dcal droite.
i f ( blz )
i++ ;
else
{ i ;
i f ( blz ) {
i++ ;
}
else {
i ;
}
Ne pas faire des lignes trs longues (> 80 c): retour-chariot existe !
Encadrer les blocs (mme de 1 instruction) par des { }.
...
i f ( b l a ) { i ++ ; }
i ;
...
IN101
197/1

Dfinir les prototypes des fonctions dans un .h.
Par dfaut C considre quune fonction retourne int.
viter les switch sans cas default.
viter les sorties multiples de boucles (break, continue).
viter les sorties multiples de fonctions (tant que possible).
Banir le goto (que lon na pas vu dailleurs).
Pas de fallthrough sans commentaire.
switch ( bla ) {
case 0 :
i++ ;
case 1 :
i++ ;
break ;
switch ( bla ) {
case 0 :
i++ ;
/ Yes I r e a l l y want t o c h a i n c a s e s
0 and 1 ! /
case 1 :
i++ ;
break ;
IN101
198/1

Pas retourner dune fonction ladresse dune variable locale.
La variable nexiste plus la fin de la fonction.
Faire attention aux dbordements:
Entiers vs flottants.
Signs vs non signs.
Tailles diffrentes.
Pas deffets de bord dans les arguments dun appel de fonction.

Rsultat dpendant de lordre dvaluation.
int i = 86 ; print ( i ++, i++, i++);
88 87 86 ? 86 87 88 ? 88 86 87 ?
Pas deffets de bord dans les initialisation de donnes.
Rsultat dpendant de lordre dvaluation.
int i = 0 ; int t [ i ++, i++, i++] ;
Toujours compiler en activant les warnings: option -Wall.
IN101
199/1
Et quand a plante quand mme ?
Outil pour suivre pas pas le droulement: debugger.

gdb, ddd, Eclipse . . .
En cours dexcution:
Permettent de poser des breakpoints.

Permettent dinspecter les variables, les registres.
Permettent de modifier les variables.
En post-mortem, permettent parfois de rcuprer ltat au moment du

plantage.
Souvent un peu technique pour la prise en main.
Et sinon, mettre des printf marche souvent trs bien et reste simple.
IN101
200/1
Complexit
IN101
201/1
Motivation
Se rappeler du premier cours, programmer :
noncer une manire deffectuer un calcul.
Il existe toujours plusieurs manires deffectuer un calcul.
Exemple, la multiplication:
i n t heavy_mult ( i n t a , i n t b )
{
int res = 0 ;
f o r ( i n t i = 0 ; i < b ; i ++)
res = res + a ;
return ( res ) ;
}
i n t mult ( i n t a , i n t b )
{
return (a b) ;
}
Entre plusieurs, on va choisir la plus efficace.
IN101
202/1
Quest-ce que la complexit ?

Complexit dun algorithme: mesure de son efficacit intrinsque:
en fonction de la taille des donnes traiter,

asymptotiquement,
dans le pire cas ou en moyenne.
Notion defficacit indpendante de la vitesse de la machine.

Deux formes de complexit:
Temporelle: sintresse au temps pass dans dans lexcution.

Spatiale: sintresse lespace mmoire ncessaire lors de lexcution.
On sintresse le plus souvent la complexit temporelle.

Pratiquement, pour une entre de taille n:
On compte le nombre doprations de base ncessaires.

On regarde comment ce nombre volue asymptotiquement.
IN101
203/1
Un premier exemple (1)

u n s i g n e d i n t ints_sum ( u n s i g n e d i n t n )
{
u n s i g n e d i n t i , sum = 0 ;
f o r ( i = 0 ; i <= n ; i ++) {
sum += i ;
}
r e t u r n ( sum ) ;
}
Simple boucle for
Taille de lentre: n.
La boucle va tourner n fois.
La fonction va faire n additions . . . + n pour lincrmentation de la
boucle, + n tests.
En gnral, on ne sintresse quaux oprations calculant le rsultat.
Bref, la complexit est linaire en la taille de lentre.
IN101
204/1
Un premier exemple (2)
Un peu de rflexion:
0 1
+ +
n=5 4
2
+
3
3
+
2
4 n=5
+ +
1 0
n+n+n+n+n+n
n+1
ni=0 i =
n(n+1)
2
= 2 * (1 + 2 + ... + 5)
= n (n / 1)
1 addition +
1 multiplication +
1 division.
Et mme pas de tests ou autres incrmentations autour !
Calcul en temps constant.
IN101
205/1
Notations de complexit
valuation de la complexit, de lefficacit dun algorithme:
Encadrer le nombre doprations quil fait.

Borne suprieure et borne infrieure.
Lorsque la taille de lentre tend vers +.
O(g ) : ensemble des fonctions f telles que 0 f (x) k g (x)
Avec k N
Et x0 N , x x0 ( comportement asymptotique).
(g ): ensemble des fonctions f telles que k1 g (x) f (x) k2 g (x)

Avec k , k N
1 2
Et x N , x x ( comportement asymptotique).
0
0
Notation malheureuse: on crit f = O(g ) au lieu de f O(g ).
IN101
206/1
Exemple:
(g ): ensemble des fonctions f telles que k1 g (x) f (x) k2 g (x)
x 2 + x + 1 = (n2 )
IN101
207/1
Exemple: O
O(g ) : ensemble des fonctions f telles que 0 f (x) k g (x)
log (x) = O(x)
IN101
208/1
Classement de complexits
log(n)
n
n n n log(n) n2 n3 2n exp(n) n! nn 22
Dfinitions : complexit
linaire : f (x) = O(x) ralisable

quadratique : f (x) = O(x 2 ) ralisable
polynomiale : k > 0, f (x) = O(x k ) souvent ralisable
exponentielle : b > 1, f (x) = O(b x ) en gnral irralisable
x
doublement exponentielle, par exemple : f (x)= O(22 ).
sous-exponentielle, par exemple : f (x) = O(2 x ).
Quelques exemples:
Algorithme de tri par tas: O(n log n).

Calcul de la matrice daccessibilit dun graphe: O(n3 ).
IN101
209/1
Quelques ordres de grandeur

(2010) - AMD FX-8150 (8-core) @ 3.6 GHz: 1011 instr/s.
(2011) - Intel Core i7 2600K @ 3.4 GHz: 1.3 1011 instr/s.
(2011) - ARM Cortex A7 @ 1.5 GHz: 2.8 109 instr/s.
(2011) - Qualcomm Krait @ 1.5 GHz : 9.9 109 instr/s.
Largement au-dessus de 231 instr/s !
Pour le PC de tout le monde, 240 (1012 ) instructions nest pas un
problme.
Records actuels un peu au-del de 260 (1018 ) oprations binaires
(ralisable par des gens motivs NSA, Folding@home . . . )
En cryptographie, actuellement 280 (1024 ) oprations binaires sont
considres comme inateignables . . . aujourdhui . . .
Clefs de 128 bits sres pour quelques dizaines dannes.
IN101
210/1
Fibonnaci
On cherche calculer le nime nombre de la suite de Fibonacci

Fib0 = 0 et Fib1 = 1
Fibn = Fibn1 + Fibn2 pour n > 1
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 . . .
IN101
211/1
Calcul direct
Fib0 = 0, Fib1 = 1, Fibn = Fibn1 + Fibn2
Rcurrence linaire coefficients constants.

Utilisation de rsultats dalgbre linaire.
Polynme caractristique: x 2 x 1
On recherche ses racines:
Racine 1: = 21 (1 + 5)
Racine 2: = 21 (1 5)
Fibn = 1 (n n )
0.62
n Pour n > 1 asymptotiquement, Fibn = entier le plus proche de
.
5
IN101
212/1
Version rcursive nave
unsigned i n t f i b ( unsigned i n t n )
{
i f ( n < 2) return ( n ) ;
e l s e return ( f i b ( n 1) + f i b ( n 2) ) ;
}
Calcul de la complexit en nombre dappels fib.

Se rduit une somme de Fib0 et de Fib1 .
Fib4 = Fib3 + Fib2
= (Fib2 + Fib1 ) + (Fib1 + Fib0 )
= (Fib1 + Fib0 ) + Fib1 + Fib1 + Fib0
Nombre dappels rcursifs: 2 Fibn 1 (c.f. dmo dans le poly).
Fibn =
complexit = (Fibn ) = (n ) : exponentielle.
n
IN101
213/1
Version itrative simple
Calcul de plusieurs fois la mme valeur Fibi : viter.

Utilisation dun tableau pour mmoriser les Fibi (mmozation).
{
unsigned i n t i ;
/ A l l o c a t i o n dynamique . /
unsigned i n t f i b s = malloc ( s i z e o f ( unsigned i n t ) ( n + 1) ) ;
fibs [0] = 0 ;
fibs [1] = 1 ;
f o r ( i = 2 ; i < n + 1 ; i ++) {
f i b s [ i ] = f i b s [ i 1] + f i b s [ i 2] ;
}
return ( f i b s [ n ] ) ;
}
Complexit temporelle en (n).
Mais complexit spatiale aussi en (n).

IN101
214/1
Version itrative plus ruse
Seules 2 valeurs sont lues dans le tableau chaque itration.

fibs[i - 1] et fibs[i - 2].
Utiliser seulement 2 variables.
{
unsigned i n t i ;
unsigned i n t f i b 0 = 0 ;
unsigned i n t f i b 1 = 1 ;
f o r ( i = 2 ; i < n + 1 ; i ++) {
fib1 = fib0 + fib1 ;
fib0 = fib1 fib0 ;
}
return ( f i b 1 ) ;
}
Complexit temporelle toujours en (n).

Mais complexit spatiale maintenant en (1).
IN101
215/1
Version itrative optimale
Calcul direct mais sans nombres flottants (pas de

On crit Fib sous la forme:
5).
Fibn = 1 Fibn1 + 1 Fibn2

Fibn1 = 1 Fibn1 + 0 Fibn2
Donc on a:
1 1
Fibn
)
) = (
(
1 0
Fibn1
n1
1 1
)
= (
1 0
Fib
( n1 )
Fibn2
Fib
( 1)
Fib0
Simple problme dexponentiation matricielle.

Complexit temporelle: (log(n)).
Complexit spatiale: (1).
IN101
216/1
Comparaison des temps de calcul
fibo1
fibo2
fibo3
fibo4
(n )
(n)
(n)
(log (n))
40
31s
0s
0s
0s
225
228
231
Calcul irralisable
18s Segmentation fault
4s 25s
195s
0s
0s
0s
IN101
217/1
Thorie de la complexit
But: classifier des problmes en fonction de la complexit du meilleur

algorithme pour les rsoudre.
Meilleur algorithme, pas meilleur connu !
Pour Fibonnaci: algorithme en temps (log (n)).
On ne sait pas toujours prvoir la complexit optimale.

Pour Fibonnaci, solution logarithmique, cest un problme facile.
Pour certains problmes, on peut prouver la complexit optimale.
Exemple: tri par comparaison au minimum en (n log (n)).
IN101
218/1
Dfinitions
Problme: Question comportant un ou plusieurs paramtres.
Quel est le plus court chemin entre deux sommets donns dun graphe
?
Instance: Donne du problme sur une valeur de ses paramtres.
G = (S , A), x , y G : quel est le plus court chemin entre x et y dans G
?
Problme de dcision: Solution du problme {oui, non}.

Existe-t-il un chemin de longueur k donne entre deux sommets dun
graphe ?
Problme de calcul: Calculer la solution dun problme.
Calculer le plus court chemin entre deux sommets donns dun graphe.
IN101
219/1
Classes de complexit
Les deux classes de problmes dont on parle le plus sont:
Classe P: Ensemble des problmes de dcision rsolubles en temps

polynomial.
Classe NP: Ensemble des problmes de dcision dont la solution peut
tre vrifie en temps polynomial quand la rponse est oui.
On a P NP.
?
Par contre, P = NP : problme ouvert.
Rem: il existe de nombreuses autres classes (PSPACE, EXPTIME, co-NP . . . ).

IN101
220/1
Pourquoi sacharner sur NP ?

Problme NP-complet: problme dans NP au moins aussi difficile que
tout autre problme de NP.
Il existe une rduction polynomiale permettant dcrire nimporte quelle

instance de nimporte quel problme de NP comme une instance de ce
problme.
Si on sait rsoudre toutes les instances de ce problme, on sait
rsoudre toutes les instances de tous les problmes de NP.
Si un problme NP-complet est dans P, alors P = NP.

Exemples:
Satisfiabilit dune formule logique (SAT: existence dune solution

une srie dquations logiques).
Le voyageur de commerce (plus court chemin reliant toutes les villes).
Coloration de graphe k couleurs (2 sommets relis par une arte sont
de couleur diffrente).
IN101
221/1
Un problme NP-complet: le voyageur de commerce
Pour une distance D, existe-t-il un chemin plus court que D qui passe
exactement une fois par chaque ville et revienne au point de dpart ?
Pour n villes, n! parcours possibles:
n choix pour la premire ville,

n 1 destinations possible pour la seconde ville,
etc . . .
Pour un parcours donn: vrification en temps polynomial.
IN101
222/1
Des problmes dans P / dans NP
Dans P: tris, pgcd, factorielle, etc. . . des choses que lon a vues.
Dans NP:
Trouver un diviseur de n N diffrent de 1 et n.

Vrification de la solution en temps polynomial dans NP.
Pas dalgorithme de factorisation polynomial connu.
Pourtant on sait que ce problme nest pas NP-complet.
Problme important en cryptographie: une solution polynomiale serait
ennuyeuse !
IN101
223/1
Les tris
IN101
224/1
Retour vers les tableaux

Classement un concours : dterminer la liste des gagnants ?
Dtection de doublons parmi n valeurs ?
Comment faire pour trouver efficacement ces paires ?
Ide simple:
Remplir un tableau avec les n valeurs.

Comparer chaque lmnt tous les autres du tableau.
La comparaison tant une opration binaire complexit en (n2 ).
Peut mieux faire. . .
Trier la tableau.
Puis le parcourir en comparant 2 voisins.
complexit en (n log (n)).
IN101
225/1
Le tri
Soit un tableau t de n lments,

Une relation dordre total sur ces lments,
On organise les n lments (i.e. permutation) tel que
i , j [0; n[ j i t[j] t[i]
Intrt dun tri: acclrer les processus de recherche.
Jeu plus grand / plus petit

Recherche dun lment dont le critre a servi trier le tableau.
Algorithmes lmentaires: complexit en (n2 ).
Les meilleurs algorithmes: complexit en (n log (n)).
IN101
226/1
Complexit variable
Problme du tri: complexit dpendante de la taille du tableau et de
lorganisation des valeurs et des valeurs.
Complexit dans le pire cas:
Temps de calcul dans le pire cas pour les entres de taille n fixe.
T (n) =
max
{e tel que e=n}
T (e)
Complexit moyenne:
Temps de calcul moyen sur toutes les entres de taille n fixe
Tm (n) =
e tel que e=n
Pn (e) T (e)
o Pn est une distribution de probabilit sur les entres de taille n.
IN101
227/1
Tri par insertion (insertion-sort)

void i n s e r t i o n _ s o r t ( i n t tab [ ] , unsigned i n t n ) {
int i , j ;
f o r ( i = 1 ; i < n ; ++i ) {
i n t tmp = t a b [ i ] ;
f o r ( j = i ; ( j > 0 ) && ( t a b [ j 1 ] > tmp ) ; j ) {
tab [ j ] = tab [ j 1] ;
}
t a b [ j ] = tmp ;
}
}
10 5
7
3
10
5 10 3
5 10 1
10
10
5 10 7
10
7 10
Llment i est rang parmi les i 1

prcdents (dj tris).
Insrer un lment cote au pire i en
moyenne 2i .
Complexit en (n2 ) dans le pire cas

(tableau inversement tri) et en moyenne.
IN101
228/1
Tri bulles (bubble-sort) (1)

Ide: faire remonter les grands lments la fin du tableau.
Parcours du tableau en comparant llment i au i + 1 et inversion si

ncessaire.
la fin du parcours, le dernier lment est le plus grand.
la fin du i me parcours, les i plus grands lments sont la fin.
Pour trier un tableau de taille n, il faut faire n 1 parcours.
Complexit:
On a fait (n) parcours avec (n) comparaisons pour chacun.

(n2 ) dans le pire des cas et en moyenne.
Pour optimiser un peu: arrter le tri ds que lun des parcours

ninverse aucun lment.
Ne fait que (n) comparaisons sur un tableau dj tri.
IN101
229/1
Tri bulles (2)

void bubble_sort ( i n t tab [ ] , unsigned
int n)
{
b o o l swap_done = t r u e ;
unsigned i n t i ;
int j = 0 ;
i n t tmp ;
w h i l e ( swap_done ) {
swap_done = f a l s e ;
j++ ;
f o r ( i = 0 ; i < n j ; i ++) {
i f ( tab [ i ] > tab [ i + 1 ] ) {
tmp = t a b [ i ] ;
tab [ i ] = tab [ i + 1] ;
t a b [ i + 1 ] = tmp ;
swap_done = t r u e ;
}
}
}
}
10 5
5 10 3 11 7
5
3 10 11 7
3 10 11 7
3 10 7 11
5 10 7 11
5 10 7 11
7 10 11
7 10 11
7 10 11
7 10 11
7 10 11
IN101
230/1
Tri fusion (merge-sort)

Insrer un lment dans un tableau tri cote (n).
Fusionner deux tableaux de taille
n
2
cote aussi (n).
On cherche rduire le problme:
on coupe le tableau en deux,

on trie chaque moiti,
on fusionne.
Le cot total est celui des fusions:
chaque fusion cote (r p),

le cot total est (n log (n)),
dans le pire cas et en moyenne.
IN101
231/1
Tri fusion: la fusion

On commence par recopier dos--dos les 2 tableaux: cot (n).
Puis on parcourt par les deux bouts en avanant du plus petit ct

chaque fois: cot (n).
IN101
232/1
Tri rapide (quick-sort)

Tri rcursif en 2 phases bas sur un partitionnement
On choisit un pivot.
On met les lments plus petits que le pivot gauche, ceux plus
grands droite et le pivot au milieu.
Il reste alors trier les 2 sous-tableaux de gauche et de droite. . .
. . . en faisant du tri rapide.
void quick_sort ( i n t tab [ ] , i n t l , i n t r )

{
int j ;
if ( l < r) {
j = p a r t i t i o n ( tab , l , r ) ;
q u i c k _ s o r t ( tab , l , j 1 ) ;
q u i c k _ s o r t ( tab , j + 1 , r ) ;
}
}
IN101
233/1
Tri rapide (quick-sort), partition

i n t p a r t i t i o n ( i n t tab [ ] , i n t l , i n t r )
{
i n t p i v _ v a l , i , j , tmp ;
piv_val = tab [ l ] ;
i = l ;
j = r + 1 ;
while (1) {
do ++i ; w h i l e ( t a b [ i ] <= p i v _ v a l && i <= r ) ;
do j ; w h i l e ( t a b [ j ] > p i v _ v a l ) ;
i f ( i >= j ) b r e a k ;
tmp = t a b [ i ] ; t a b [ i ] = t a b [ j ] ; t a b [ j ] = tmp ;
}
tmp = t a b [ l ] ; t a b [ l ] = t a b [ j ] ; t a b [ j ] = tmp ;
return ( j ) ;
}
<
Les permuter (11).
>V
Pour finir, rinsrer

le pivot au milieu
(13).
>
<V
V
>)
Rechercher le
premier lment
pivot en partant de
la droite (9).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
(V
Rechercher le
premier lment >
pivot en partant de
la gauche (8).
j
final
IN101
234/1
Tri rapide (quick-sort), complexit et comparaisons
Trs rapide, peut tre fait en place.

Complexit dans le pire cas (n2 ).
Complexit en moyenne (n log (n)).

Complexits compares asymptotiquement
Algorithme
Cas le pire
En moyenne
Tri par insertion

Tri bulles
Tri rapide
Tri fusion
(n2 )
(n2 )
(n2 )
(n log (n))
(n log (n))
(n log (n))
IN101
235/1
Comparaison de tris en pratique
IN101
236/1
Complexit minimale dun algorithme de tri (1)

Un tri par comparaison prend en entre n lments
Ne fait que des comparaisons ({1,4,3} est identique {2,4,3}).

n! entres possibles, selon lordre des lments
(n! = cardinal de lensemble de toutes les permutations de positions).
Un algorithme de tri par comparaison fait une suite de comparaisons,

puis donne une permutation qui remet les lments en ordre.
se comporte diffremment pour chacune des n! entres possibles.
Comportement modlis comme un arbre binaire o:
Chaque nud est une comparaison.

En fonction du rsultat on descend dans le fils gauche ou droit.
Chaque feuille correspond une permutation
Chaque entre aboutit une feuille diffrente.
IN101
237/1

n=3
x,y
z,t
e1 e 2
1,2
<
>
2,1
e2 e 3
1,2
2,3
<
1,2,3
e1 e 3
1,2
> 3,2
e1 e 3
<
1,2 1,3,2
3,2
1,3
Ordre de croissance
2,1
1,3
<
2,1,3
>
3,1,2 1,2
3,2
3,1
2,1
> 3,1
e2 e 3
<
2,1 2,3,1
3,1
2,3
>
3,2,1 2,1
3,1
3,2
Nombre de comparaisons: hauteur de la branche.

Cet arbre reprsente algorithme triant en 3 comparaisons au plus.
IN101
238/1

Un arbre binaire de hauteur moyenne h contient au plus 2h feuilles.
Donc 2h nombre de feuilles (= n!)
Do h log2 (n!)
(Constantes multiplicatives sans importance on oublie la base.)
Par la formule de Stirling, log (n!) > log ( ne n ) = n log n n log e
n
Donc h n log n n log e
h est aussi le nombre moyen de comparaisons
pour des entres quidistribues

la complexit moyenne dun tri est (n log n).
pour nimporte quelles entres
la complexit dans le pire cas est (n log n).
IN101
239/1
Fun about sorting...
Allez voir http://www.zutopedia.com/algorithm.html
IN101
240/1
Recherche en table
IN101
241/1
Pourquoi cette question ?

Problme: retrouver une information partir dune clef (info
discriminante) qui lui est associe.
Exemples:
Dictionnaire : mot dfinition.

Annuaire: (nom + prnom) (adresse + tlphone).
GPS: (latitude + longitude) plan.
Oprations souhaites:
Insertion.
Recherche.
Suppression.
? Choix de la structure de donnes utiliser ?
IN101
242/1
Paires clef-valeur
But: grer un ensemble dlments (clef, valeur).

La clef donne accs linformation valeur.
Les clefs reprsentent un ensemble m lments indexs de 0 m 1.
Clefs entires sur 16 bits: 216 = 65536, do clefs de 0 65535.

Tlphone: 10 chiffres dcimaux (en simplifiant), 1010 , 233 clefs.
Noms sur 8 lettres: 268 237 clefs.
Les clefs doivent tre idalement discriminantes: 1 clef 1 valeur.

Problme: gnralement, nombre de clefs possibles >> nombre de
valeurs enregistrer.
IN101
243/1
Plusieurs solutions
Pas de solution unique.

Compromis entre:
Complexit spatiale (cot mmoire du stockage).

Complexit temporelle des oprations (insertion, recherche,
suppression).
Cette notion de table est gnrale:

stockage en mmoire ou sur disque mme combat.
IN101
244/1
Ladressage direct
Les rsultats sportifs: 3me du classement 3me case.
0
1
info 1
info 2
m1
info 4
Utilisation dun tableau de taille m (nombre de clefs possibles).

Info lie la clef i la case dindice i: pas de stockage de la clef.
Complexit spatiale en (m), ou (m taille info).
Mais: si clef = mot de 10 lettres, m = 247 !!!
Mme avec 1 seul bit dinfo 16 To de stockage !!!

Irralisable en pratique dans la majorit des cas.
Mme problme que la reprsentation densembles par bitvect.
IN101
245/1
Recherche squentielle (1)

Utilisation dun tableau de taille n (nombre dinfos).
Infos stockes dans lordre darrive.
Mmorisation dun indice p dnotant la 1re case libre.
0
(clef3 ,info 3)
(clef1 ,info 1)
(clef2 ,info 2)
n1
(clef 0 ,info 0)
Complexit spatiale en (n) (complexit minimale).

Insertion: t[p] (clef, info)
Complexit en (1).
Si recherche pralable pour viter les doublons: ajout la
complexit.
Recherche: parcours linaire jusqu trouver la clef.
Complexit en (n).
Suppression: recherche puis dcalage.
Complexit en (n) (2 (n)).
IN101
246/1
Recherche squentielle (2)
Recherche trop lente.

Utilisable si lon insre des lments mais quon les lit rarement.
Exemple proche: les journaux (logs).
Si les comparaisons sont complexes, devient excessivement coteux:
Comparer des entiers: trivial, en (1).

Comparer 2 chanes de caractres, l = min(s1 , s2 ) (l).
Comparer sur des clefs tant elles-mmes des tableaux... M
Ou pire . . .
IN101
247/1
Recherche dichotomique (1)

La recherche dans le dictionaire.
Ncessite un tableau de taille n dont les lments sont tris.
Dans le dictionnaire: tri des mots par ordre lexicographique.
0
(clef2 ,info 2)
(clef3 ,info 3)
(clef7 ,info 7)
n1
Processus de recherche dichotomique:
Accs au milieu du tableau.

Si clef = clef recherche trouv.
Si clef < clef recherche recherche dichotomique dans la partie
gauche du tableau.
Si clef > clef recherche recherche dichotomique dans la partie
droite du tableau.
IN101
248/1
Recherche dichotomique (2)
Recherche: parcours dichotomique jusqu trouver la clef.

Complexit en (log n).
Insertion: recherche puis dcalage.
Complexit en (n).
Suppression: recherche puis dcalage.

Complexit en (n).
Bonne complexit de recherche.
Mais insertion (et suppression) trop chre(s).
Insertion: plus rentable dinsrer tout puis de trier tout le tableau dun
coup.
IN101
249/1
Table de hachage (hastable)

Rduire lespace des clefs possibles dans un espace plus petit.
Fonction de hachage h [0; m 1] [0; k 1] avec k < m.
On utilise un tableau de taille k.
On stocke chaque information dans le tableau lindice h(clef ).

Chaque case contient linformation dont le hachage de la clef vaut
lindice de cette case.
k
0
k1
info 6
h(27)=1, h(6)=3, h(15)=k1

info 15
info 27
Mais que se passe til si 2 clefs ont le mme hash ?

Collision.
IN101
250/1
Table de hachage et collisions

Collision: plusieurs infos avec le mme hachage de clef.
Au lieu de mettre 1 info dans la table, on met une liste dinfos.
Toutes les infos dune liste ont le mme hachage de leur clef.
k
0
k1
info 6
info 27
h(27)=1, h(6)=h(1)=3, h(15)=k1

info 15
info 1
(Nous tudierons les listes en dtail plus tard.)

Autre solution: adressage ouvert utiliser la 1re case contigue libre.
IN101
251/1
Complexit des tables de hachage
Les complexits dpendent du facteur de remplissage de la table.

Complexits (en moyenne) :
spatiale : (k + m)
recherche : ( ),
insertion : (1),
suppression : ( ).
(taille de la table + taille des donnes),
Ncessit dune une bonne fonction de hachage (non biaise sur les
entres).
Ncessit de connatre m lavance pour choisir k m.
IN101
252/1
Recherche de motifs
IN101
253/1
Des exemples concrets

Squence dADN du gne Antennapedia CG1028-RH:
1 ttcagttgtg aatgaatgga cgtgccaaat agacgtgccg ccgccgctcg attcgcactt
61 tgctttcggt tttgccgtcg tttcacgcgt ttagttccgt tcggttcatt cccagttctt
121 aaataccgga cgtaaaaata cactctaacg gtcccgcgaa gaaaaagata aagacatctc
181 gtagaaatat taaaataaat tcctaaagtc gttggtttct cgttcacttt cgctgcctgc
241 tcaggacgag ggccacacca agaggcaaga gaaacaaaaa gagggaacat aggaacagga
301 accagataat agtgacataa gcgacccttt cgcaaatatt ttggcgcaaa atgagcgggc
361 gccaagtgcc gcgtggtgga gccgcctgaa aatgacatgg aaaattcgcc gaaaatcgcg ...
Comment retrouver une squence particulire ?

Logs systme (serveur WEB, alertes scurit, etc.) :
May
May
May
May
May
May
May
May
May
May
May
31
31
31
31
31
31
31
31
31
31
31
13:56:46
14:03:40
14:03:40
14:03:50
14:03:50
14:03:50
14:03:50
14:03:50
14:03:50
14:03:50
14:03:51
dhcpuei9 newsyslog[82165]: logfile turned over due to size>1000K

dhcpuei9 kernel[0]: 00000000 01947949 NVEthernet::mediaChanged - Link is down
dhcpuei9 kernel[0]: 00000000 00000020 NVEthernet::setLinkStatus - not Active
MyMac kernel[0]: hibernate image path: /var/vm/sleepimage
MyMac kernel[0]: sizeof(IOHibernateImageHeader) == 512
MyMac kernel[0]: Opened file /var/vm/sleepimage, size 4294967296, partition base 0xc80500
MyMac kernel[0]: hibernate image major 14, minor 3, blocksize 512, pollers 5
MyMac kernel[0]: hibernate_alloc_pages flags 00000000, gobbling 0 pages
MyMac kernel[0]: hibernate_setup(0) took 0 ms
MyMac kernel[0]: AppleUSBMultitouchDriver::validateChecksum - 512-byte packet checksum is
MyMac kernel[0]: 00000000 00000020 NVEthernet::setLinkStatus - not Active
Comment retrouver un vnement particulier, une adresse IP, etc ?

. . . Dans des fichiers de milliers / millions de lignes !
IN101
254/1
Recherche dun motif M dans un texte T
But: savoir si un motif M apparat dans un texte T .

Petit plus: trouver toutes les occurrences du motif et leur position.
Texte T de longueur n:
(G. Brassens, La matresse dcole)
A lcole o nous avons appris lA B C,

La matresse avait des mthodes avances.
Comme il fut doux le temps, bien phmre, hlas,
O cette bonne fe rgna sur notre classe, (bis)
Avant elle, nous tions tous des paresseux,
Des lve-nez, des cancres, des crtins crasseux.
En travaillant exclusivement que pour nous,
Les marchands dbonnets dne taient sur les genoux, (bis)
IN101
255/1
Recherche dun motif M dans un texte T
But: savoir si un motif M apparat dans un texte T .

Petit plus: trouver toutes les occurrences du motif et leur position.
Texte T de longueur n:
(G. Brassens, La matresse dcole)
A lcole o nous avons appris lA B C,

La matresse avait des mthodes avances.
Comme il fut doux le temps, bien phmre, hlas,
O cette bonne fe rgna sur notre classe, (bis)
Avant elle, nous tions tous des paresseux,
Des lve-nez, des cancres, des crtins crasseux.
En travaillant exclusivement que pour nous,
Les marchands dbonnets dne taient sur les genoux, (bis)
Motif M de longueur m ( n): "ous"
IN101
256/1
Plus formellement
Soit un alphabet (bits, caractres, symboles. . . ).

Soit 2 tableaux dlments de cet alphabet:
Le texte de taille n T [0, n 1].

Le motif de taille m M[0, m 1].
Trouver tous les dcalages s [0, n m] tels que

j [0, m 1] T [s + j] = M[j]
Pour toutes les lettres du motif, on retrouve les mmes dans le texte
partir du dcalage de s positions.
IN101
257/1
Un algorithme naf
void ngrep
{
int s , j
int n =
int m =
( c h a r T , c h a r M)
;
s t r l e n (T) ;
s t r l e n (M) ;
// L o n g u e u r du t e x t e .
// L o n g u e u r du m o t i f .
/ On f a i t t o u s l e s d c a l a g e s s . /
f o r ( s = 0 ; s < n m + 1 ; s++) {
j = 0 ;
/ Tant que l e s c a r a c t r e s du m o t i f e t du t e x t e c o l l e n t on
c o n t i n u e ( s a n s d p a s s e r l a t a i l l e du m o t i f ) . /
w h i l e ( ( j < m) && (M[ j ] == T [ s+j ] ) ) j++ ;
i f ( j == m) p r i n t f ( "%d\n" , s ) ;
}
}
Complexit dans le pire des cas: ((n m + 1) m) = (n m).

IN101
258/1
Algorithme de Rabin-Karp
Ide: alphabet de taille d codage des mots en base d.

Motif p = M[0] d m1 + M[1] d m2 + . . . + M[m 1] d + M[m]
Pour tout dcalage s de [0, n m],

Texte
ts = T [s] d m1 + T [s + 1] d m2 + . . . + T [s + m 1] d + T [s + m]
(Ni plus ni moins que le schma de Horner classique.)
Il ne reste plus qu comparer des entiers.
Point intressant: ts+1 calculable facilement partir de ts :
ts+1 = (ts T [s] d m1 ) d + T [s + m]
IN101
259/1
Algorithme de Rabin-Karp : exemple

Recherche dune squence dADN:
Alphabet = {A, T , G , C }
d = 4.
On pose A = 0, T = 1, G = 2 et C = 3.
Pour texte T = TAGCAGAGA et motif M = AGA:

p = 0d2 +2d +0 = 8
(T )
(A)
(G )
(C )
(A)
(G )
(A)
t0 = 1 d 2 + 0 d + 2 = 18
t1 = 0 d 2 + 2 d + 3 = 11
t2 = 2 d 2 + 3 d + 0 = 44
t3 = 3 d 2 + 0 d + 2 = 50
t4 = 0 d 2 + 2 d + 0 = 8
t5 = 2 d 2 + 0 d + 2 = 34
t6 = 2 d 2 + 2 d + 0 = 8
IN101
260/1
Algorithme de Rabin-Karp : pseudo-code
Calculer h = d m1 .
Calculer p.
Calculer t0 et mmoriser t t0 .
Pour s allant de 0 n m 1 faire
Si p == t alors occurrence trouve.

t (t T [s] h) d + T [s + m].
Si p == t alors occurrence trouve.
IN101
261/1
Algorithme de Rabin-Karp : code

d: taille alphabet, valof: caractre alphabet entier [0; d[
v o i d r a b i n _ k a r p ( c h a r T ,
{
long int s ;
int i ;
unsigned int n = s t r l e n
unsigned int m = s t r l e n
c h a r M)
(T)
(M)
;
;
/ C a l c u l de d^{m1} une bonne f o i s

l o n g i n t h = p o w e r ( d , (m 1 ) ) ;
p o u r t o u t e . /
/ C a l c u l de p . /
long int p = 0 ;
f o r ( i = 0 ; i < m; i ++) p = ( p d ) + v a l o f
(M[ i ] )
/ C a l c u l de t_0 e t > d a n s t . /
long int t = 0 ;
f o r ( i = 0 ; i < m; i ++) t = ( t d ) + v a l o f
(T [ i ] )
/ I t r a t i o n de [ 0 nm 1 ] . /
f o r ( s = 0 ; s < n m; s++) {
i f ( p == t ) p r i n t f ( " Found o c c u r r e n c e %l d \ n " , s ) ;
t = ( t ( v a l o f (T [ s ] ) h ) ) d + v a l o f (T [ s + m] )
}
i f ( p == t ) p r i n t f ( " Found o c c u r r e n c e a t %l d \ n " , s ) ;
IN101
262/1
Algorithme de Rabin-Karp : complexit
Complexits des diffrentes tapes:
Calcul de h en (m).
Calcul de p et t0 en (m).
n m calculs des ts en (1) (n m)
Complexit totale (m + n).
IN101
263/1
Algorithme de Rabin-Karp : limitation
Si d et/ou m grand(s) nombres manipuls trs grands.

c d m1
Rapide dpassement de capacit des int.
On a utilis des long int, mais. . .
Mot de 10 lettres,
Alphabet alphanumrique maj/min ( 74 lettres),
7410 = 4923990397355877376
IN101
264/1
Algorithme de Rabin-Karp : amlioration
Ide: effectuer les calculs modulo un entier q ni trop grand ni trop

petit:
Un nombre premier (augmente le pouvoir discriminatoire du modulo).

Plus petit que 216 ( produits tiennent sur 32 bits).
65521 bon candidat (216 = 65536).
Chaque fois que le calcul modulo q tombe juste (p = ts mod q):

peut-tre bon motif prsent au dcalage.
Vrification avec algorithme naf.
Chaque fois que le calcul tombe faux: certain que le motif nest pas
prsent.
IN101
265/1
Automates finis
IN101
266/1
Un exemple de besoin
Systme de contrle dune cluse:
2 portes qui ne doivent pas tre ouvertes en mme temps.

Des commandes: Ouvrir / Fermer - Porte amont / Porte aval . . .
Des signaux: Sas rempli / vide, Bateau entr / sorti . . .
Nombre dtats possibles des portes: 4, dont 1 catastrophique.

Le systme change dtat en fonction des commande et signaux reus.
vide
Amont F
Aval F
bateau sorti
entre
aval
Vidange
vide
Amont F
Aval O
entre
amont
Vidange
porte amont
close
bateau entr
Amont F
Aval F
Remplissage
Amont F
Aval F
bateau
entr
plein
Amont O
Aval F
plein
porte aval
close
Remplissage
bateau
sorti
IN101
267/1
Quelques questions
vide
Amont F
Aval F
bateau sorti
entre
aval
Vidange
vide
Amont F
Aval O
entre
amont
Vidange
porte amont
close
bateau entr
Amont F
Aval F
Remplissage
Amont F
Aval F
bateau
entr
plein
Amont O
Aval F
plein
porte aval
close
Remplissage
bateau
sorti
Cet automate a-til des tats redondants ?

Cet automate va-til arriver dans un tat bloqu ?
Cet automate traite-til toutes les rceptions de signaux ?
Peut-til arriver sur un tat reprsentant une catastrophe systme ?
Des algorithmes sur les automates sont trs utiles.
IN101
268/1
Dfinition formelle
Automate fini: machine pouvant se trouver dans un nombre fini
dtats.
Reconnait des mots: suites de caractres reprsents par les tiquettes
sur transitions (flches).
Un automate fini dterministe est la donn de:
a
un alphabet fini,{a, b}
Q un ensemble fini dtats, {1, 2, 3, 4}

q0 Q un tat initial,
F Q un ensemble dtats finaux,
Q Q une fonction de transition.
2
a
IN101
269/1
Fonctionnement
Lecture dun mot sur

Principe: dmarrer dans ltat q0 .
Sur ltat courant q Q, lire un caractre c et passer dans ltat
(q , c).
Recommencer jusqu arriver un tat F .

Si transition impossible alors le mot lu / erreur.
IN101
270/1
Exemple de fonctionnement:
Que reconnait . . . ?
a
1
2
a
Reconnat par exemple les mots ab, aba, abbb et ababbaa.

Etat 4 : puit = tat non final dont on ne ressort pas.
IN101
271/1
Que reconnait . . . ?
a
1
Simplification: suppression du puit.

Cet automate reconnat le langage L = ab(abb) = a(ba b) ba :
ab : un a suivi dun b,
(abb): a ou bb,
a : un nombre quelconque de a, y compris 0,
a+ : un nombre strictement positif de a ( aa ).
Description du langage par des expressions rgulires.

Trs utilis pour lanalyse lexicale (compilateurs).
IN101
272/1
Reconnatre exactement . . .
Reconnaissance de digicode.
Code: 0203
09
0
19
q0
1, 39
qf
0
1, 49
Accepte nimporte quelle entre . . .

. . . mais doit se terminer par le suffixe 0203 pour succs.
Exactement notre problme de recherche de motif.
IN101
273/1
Retour sur la recherche de chanes:
construction de lautomate
Pour tout motif M de longueur m, on peut construire un

automate A qui reconnat L = M .
Lalphabet de A est .
A possde m + 1 tats numrots {0, 1, ..., m}.
0 est ltat initial.
m est lunique tat final.

Construire la fonction de transition.
IN101
274/1
Construction de lautomate ababba (1)
Point de dpart: squelette reconnaissant le mot.

0
Pour chaque tat, brancher les transitions sur les autres caractres.
IN101
275/1

M qr
qr
a b a b a ......
Mi a
0
M 4 a = ababa
aba bba
a
Transition vers 3
Si caractre lu, a, partir de ltat i est diffrent de celui attendu

dans le motif:
Alors, Mi est un prfixe de M.

Retourner un tat qr tel que Mqr soit le plus long suffixe de Mi a.
On ajoute donc la transition. (i , a) = qr
Pour calculer ce qr on utilise la partie de lautomate dj construite.

Revient parcourir lautomate avec les i derniers caractres de Mi a.
IN101
276/1
tat 0 sur b: impossible de passer en 1.

Rester en 0.
0
IN101
277/1
tat 1 sur a: jouer les 1 derniers caractres de M1 a. . .

aa = a
Aller en 1.
0
IN101
278/1
tat 2 sur b: jouer les 2 derniers caractres de M2 b. . .

abb = bb
Aller en 0.
b
IN101
279/1

abaa = baa
Aller en 1.
b
a
b
IN101
280/1

ababa = baba
Aller en 3.
a
a
b
Etc.
IN101
281/1
Reprsentation dun automate
Ltat courant: un int.

La fonction de transition: un tableau 2 dimensions:
int transitions [m + 1][TAILLE_ALPHABET] ;
(m tant la taille du mot chercher)
(q , a) transitions [q ][ a]
IN101
282/1
Recherche de motif par automate

v o i d s t r _ s e a r c h ( i n t t e x t , i n t t r a n s i t i o n s , i n t m, i n t n )
{
int state = 0 ;
f o r ( i n t s = 0 ; s < n ; s++) {
state = transitions [ state ] [ text [ s ] ] ;
i f ( s t a t e == m) {
p r i n t f ( " M o t i f t r o u v l a p o s i t i o n %d\n" , s m + 1 ) ;
}
}
}
Complexit optimale: (n).
Mais ne pas oublier le cot de cration de lautomate:

(n + m) en temps.
(m) en espace.
IN101
283/1
Domaines dapplication
Nombreuses applications.
Sapplique tout ce qui a un nombre fini dtats.
Machine caf, ascenseur, analyse lexicale, recherche de squences

dADN, systmes de contrle-commande (automates de modes de
fonctionnements),
Toutefois, puissance de calcul limite: ne peut reconnatre an b n .
IN101
284/1
Automates non-dterministes
IN101
285/1
Non-dterminisme
Automate non-dterministe, sur un mme tat:
Peut avoir plusieurs transitions sur un mme symbole.

Peut avoir des transitions sur le symbole vide.
Peut avoir plusieurs tats terminaux.
Automates dterministes et non-dterministes reconnaissent les mmes

langages.
Version non-dterministe souvent plus facile crire.
Il existe un algorithme automate non-dterministe dterministe.
Pour un automate non-dterministe n tats, le dterministe peut en
avoir 2n .
IN101
286/1
Parcours non-dterministe
Reconnatre: ab(ab)+
Lautomate non-dterministe est simple:
Lors du parcours, ncessit de maintenir un ensemble dtats courants.

En lisant aab, on passe par les tats {0}, {1, 3, 0}, {1, 3, 0}, {2, 3, 0}
IN101
287/1
Dterminisation: N D (1)
tat initial: reste le mme.
Chaque tat de D est un ensemble des tats de N.
Ltat initial d0 de D : tat initial de N + tats de D accessibles,
directt ou indirectt par -transitions.
IN101
288/1
Dterminisation: N D (2)
Pour chaque lment s de sur
lequel lun au moins des
lments de d0 a une transition,
construire une transition sur s
partant de d0 vers un nouvel
tat constitu de lensemble des
tats destination des transitions
sur s au dpart de lun des
lments de d0 .
Complter cet tat en y
ajoutant les tats de N
accessibles par des -transitions
issues de lun de ses lments.
Processus rcursif pour chacun des tats crs.
tats finaux de D: tats qui contiennent un tat final de N.
IN101
289/1
Simplification
Automate dterministe obtenu par dterminisation souvent complexe.

Beaucoup dtats, beaucoup de transitions.
Rduction par simplification.
Existence dalgorithme de simplification.
Quelques rgles simples:
Deux tats dont toutes les transitions sont identiques peuvent tre
fusionns.
Un tat duquel aucune suite de symboles ne permet datteindre un tat
final peut tre supprim.
Un tat final pour lequel toute suite de symbole ramne sur lui-mme
peut tre boucl sur lui-mme.
IN101
290/1
Construction automatique dautomates non-dterministes

On concatne. . .
Expression rationnelle
Automate
a
MN
N
M
MN
M
IN101
291/1
Piles
IN101
292/1
Quand utiliser une pile ? (stack)

Comme dans la vie courante: stocker des choses comme une pile
dassiettes.
Dernier pos au sommet premier retir.
En Anglais: LIFO (Last In First Out).
On peut consulter les lments sous le sommet mais pas les retirer
tant que ceux au-dessus sont dans la pile.
1)
elem4
elem4
2)
elem3
elem4
elem3
elem2
elem1
elem3
elem2
elem1
elem2
elem1
IN101
293/1
Oprations sur une pile

Empiler (push) : Ajouter un lment au sommet.
push elem stack stack
Dpiler (pop) : Retirer llement du sommet.
pop stack > (elem stack)
Consulter (peek) : Accder un lment sans le retirer.
peek stack > int > elem
Le pointeur de pile indique la prochaine place libre.
Le pointeur de pile varie au cours des oprations (sauf peek).
On peut tester si la pile est vide.
elem4
elem4
elem4
elem3
elem3
elem3
elem2
elem2
elem2
elem1
elem1
elem1
Empiler
Dpiler
IN101
294/1
Pile: implmentation avec un tableau

Ici, pile de ints avec une taille maximale MAX_SIZE
Utiliser un tableau dynamique pour supprimer cette restriction.
#d e f i n e MAX_SIZE 64
struct stack {
unsigned i n t sp ;
/ P o i n t e u r de p i l e . /
i n t d a t a [ MAX_SIZE ] ; / Mmoire de p i l e . /
};
Pile simple tableau.

Pointeur de pile entier positif:
Reprsente lindice de la prochaine case libre.

Reprsente le nombre dlments prsents dans la pile.
On ajoute et on retire toujours par le haut.
IN101
295/1
Pile: fonctionnement avec un tableau (1)
???
sp
data[MAX_SIZE 1]
???
data[2]
???
data[1]
???
data[0]
sp
Init: Pile vide, sp = 0.
IN101
296/1
???
data[MAX_SIZE 1]
push 42:
sp
???
data[2]
???
data[1]
42
data[0]
sp
Vrifier que sp < MAX _SIZE

42 mis lindice sp 0
Incrmenter sp :
sp sp + 1 1
IN101
297/1
???
data[MAX_SIZE 1]
push 5:
sp
???
data[2]
data[1]
42
data[0]
sp

5 mis lindice sp 1
Incrmenter sp :
sp sp + 1 2
IN101
298/1
pop:
???
data[MAX_SIZE 1]
sp
???
data[2]
?5?
data[1]
42
data[0]
sp
Vrifier que sp > 0

Dcrmenter sp :
sp sp 1 1
Retourner la valeur lindice sp
(sommet de la pile)
La valeur reste dans la pile mais

nest plus utiliser.
Elle sera crase au prochain push.
IN101
299/1
???
data[MAX_SIZE 1]
push 34:
sp
???
data[2]
34
data[1]
42
data[0]
sp

5 mis lindice sp 1
Incrmenter sp :
sp sp + 1 2
Ancienne valeur ?5? crase par

34.
IN101
300/1
sp
56
data[MAX_SIZE 1]
push dans une pile pleine:
64
5
data[2]
pop sur une pile vide:
data[1]
42
data[0]
MAX_SIZE
sp
push !!!
sp = MAX _SIZE .
erreur.
sp
sp = 0.
erreur.
0
pop !!!
IN101
301/1
Pile: implmentation en C
i n t pop ( s t a c k P)
{
i f (P>s p == 0 ) {
/ P i l e v i d e . /
error () ;
}
P>sp ;
r e t u r n (P>d a t a [ P>s p ] ) ;
}
v o i d push ( s t a c k P , i n t v a l ) {
i f (P>s p == MAX_SIZE) {
/ P i l e p l e i n e . /
error () ;
}
P>d a t a [ P>s p ] = v a l ;
P>s p++ ;
}
IN101
302/1
Pile: implmentation en C avec un tableau dynamique

Taille maximale nest plus une constante
Appartient la structure de pile.
Tableau dynamique pointeur.
struct stack {
unsigned int size ;
unsigned i n t sp ;
i n t data ;
};
/* Taille de la pile. */
/ P o i n t e u r de p i l e . /
/ Mmoire de p i l e . /
Seul push change: en cas de pile pleine, on agrandit le tableau.

v o i d push ( s t a c k P , i n t v a l ) {
i f (P>s p == P->size ) {
/ P i l e p l e i n e . /
P->size *= 2 ;
P->data = realloc (P->data, P->size) ;
}
P>d a t a [ P>s p ] = v a l ;
P>s p++ ;
}
IN101
303/1
Une bonne application
Notation RPN: notation prfixe.

Oprateurs avant oprandes.
Comme les bonnes vieilles calculatrices HP.
Oprandes mises sur la pile, oprateur oprant sur les lments de la
pile.
Base de nombreuses machines virtuelles.
IN101
304/1
Files
IN101
305/1
Quand utiliser une file ?
Stocker des choses traiter dans lordre darrive ( file dattente).

Premier insr en queue premier retir en tte.
En Anglais: FIFO (Fast In First Out).
On peut consulter les lments dans la file mais pas les retirer tant
que ceux de devant sont dans la file.
entre
e3 e2 e1 e0
sortie
temps
IN101
306/1
Oprations sur une file

Ajouter (enqueue) : Ajouter un lment en queue.
enqueue elem file file
Retirer (take) : Retirer llement de tte.
take file > (elem file)
Consulter (peek) : Accder un lment sans le retirer.

peek file > int > elem
On peut tester si la file est vide.
e3 e2 e1 e0
enqueue
e4
e3 e2 e1 e0
e4 e3 e2 e1 e0
e4 e3 e2 e1
take
e0
e4 e3 e2
take
e1
e4 e3
take
e2
IN101
307/1
File: implmentation avec un tableau

Utilisation dun tableau avec taille borne.
Comme les piles: on peut utiliser un tableau dynamique.
Ajout des lments en fin du tableau.
Retrait des lments en dbut de tableau.
Mais on ne veut pas dcaler tout le tableau (impossible en (1)).
Utilisation du tableau de manire cyclique.

Arriv au bout du tableau, on recommence au dbut.
Besoin de garder lindice du 1er lment (le + ancien encore vivant).

struct file_t {
u n s i g n e d i n t max_nb ;
u n s i g n e d i n t cur_nb ;
unsigned i n t f i r s t ;
i n t data ;
};
/ Nombre max d l m e n t s . /
/ Nombre a c t u e l d l m e n t s . /
/ I n d i c e du p r e m i e r l m e n t . /
IN101
308/1
File: fonctionnement avec un tableau (1)
max_nb
cur_nb
first
???
???
???
???
data
Taille de la file: 4.
Initialisation: file vide, i.e. aucune donne.
cur_nb, first = 0.
IN101
309/1
max_nb
cur_nb
first
???
???
???
first
enqueue 5
data
enqueue 5:
Vrifier que la file nest pas pleine.

Ajouter au premier indice libre.
Incrmenter nb_cur : nb_cur nb_cur + 1 1
IN101
310/1
max_nb
cur_nb
first
data
42
56
???
first
enqueue 42
enqueue 56
enqueue 42, enqueue 56:
Vrifier que la file nest pas pleine.

Ajouter au premier indice libre.
Incrmenter nb_cur : nb_cur nb_cur + 1 3
Premier indice libre: first + cur _nb . . . tant que / taille max.
IN101
311/1
max_nb
cur_nb
first
?5?
42
56
???
first
take
data
take:
Vrifier que la file nest pas vide.

Rcuprer la donne lindice first.
Incrmenter first: first first + 1 1 . . . tant que / taille max.
Dcrmenter nb_cur: nb_cur nb_cur 1 2
La case redevient libre mais nest pas efface.

IN101
312/1
max_nb
cur_nb
first
?5?
42
56
27
first
enqueue 27
data
enqueue 27
IN101
313/1
max_nb
cur_nb
first
42
56
27
first
enqueue 9
data
enqueue 9
Arriv en bout de tableau la file nest pas forcment pleine.
Dpend de sil y a de la place en dbut du tableau.
On fait un cycle et rinsre en dbut.

Premire case libre: (first + cur _nb) mod max_nb
IN101
314/1
max_nb
cur_nb
first
?42?
?56?
?27?
first
data
42
take
56
27
take
take
take; take; take

Arriv en bout de tableau la file nest pas forcment vide.
Dpend de sil y a des donnes en dbut du tableau.
On fait un cycle et extrait en dbut.

first (first + 1) mod max_nb
Situation identique celle aprs la 1re insertion.

IN101
315/1
File: implmentation en C
i n t t a k e ( queue F ) {
int res ;
i f ( F>cur_nb == 0 ) {
/ F i l e v i d e . /
error () ;
}
r e s = F>d a t a [ F> f i r s t ] ;
F> f i r s t = ( F> f i r s t + 1 ) %F > max_nb ;
F>cur_nb ;
return ( res ) ;
}
v o i d e n q u e u e ( queue F , i n t v a l ) {
i f ( F>cur_nb == F>max_nb ) {
/ F i l e p l e i n e . /
error () ;
}
F>d a t a [ ( F> f i r s t + F>cur_nb ) %F > max_nb ] = v a l ;
F>cur_nb++ ;
}
IN101
316/1
Utiliser laspect dynamique pour viter la file pleine (1)
Traitement intercaler en cas de file pleine (cur_nb == max_nb).

Plus compliqu que pour les piles: realloc ne convient pas.
first
max_nb
cur_nb
first
data
42
56
27
42
56
27
first
realloc
5 ne suit pas 27 puisque espace libre aprs 27 !
IN101
317/1
Ide:
Recopier depuis first fin du tableau en dbut de nouveau tableau.

Recopier depuis 0 first la suite du nouveau tableau.
Remettre first au dbut du nouveau tableau ( 0).
first
max_nb
cur_nb
first
data
42
56
27
42
56
27
first
malloc
Plus de realloc grer la libration de mmoire.
IN101
318/1

memcpy(dest , src , size): copie mmoire-mmoire.
Ncessite #include <string.h>
v o i d e n q u e u e ( queue F , i n t v a l ) {
i n t new_data ;
i f ( F>cur_nb == F>max_nb ) {
/ F i l e p l e i n e . /
new_data = m a l l o c ( F>max_nb 2 s i z e o f ( i n t ) ) ;
memcpy
( new_data , &(F>d a t a [ F> f i r s t ] ) ,
( F>max_nb F> f i r s t ) s i z e o f ( i n t ) ) ;
memcpy
(&( new_data [ F>max_nb F> f i r s t ] ) , F>data ,
F> f i r s t s i z e o f ( i n t ) ) ;
f r e e ( F>d a t a ) ;
/ L i b r a t i o n a n c i e n d a t a . /
F>d a t a = new_data ;
F> f i r s t = 0 ;
F>max_nb = 2 ;
}
...
}
IN101
319/1
Listes chanes
IN101
320/1
Structure de liste
Une liste cest:
une liste vide

ou un lement suivi dune liste.
Type inductif: list = Nil elem; list

En C, pas de types inductifs encodage base de pointeurs:
On forme une chane.

Chaque lment est un maillon de la chane.
On passe dun lment au suivant (prcdent) en suivant un pointeur.
struct l i s t {
i n t data ;
// Le c o n t e n u n e s t p a s f o r c m e n t un i n t .
s t r u c t n e x t ; // P o i n t e u r v e r s l l m e n t s u i v a n t ( ou NULL) .
};
On ne sait pas efficacement accder au i me lment.

Une liste est simplement un pointeur vers son premier lment.
Le dernier lment pointe vers NULL.
IN101
321/1
Organisation mmoire
En mmoire, lments disperss =/ tableau o lments contigus.
Impossible daccder directement au i me lment.
Ncessit de suivre toute la chane pour parcourir la liste.

Toujours garder accs la tte de la liste.
val
17
val
next
next
L
val
next
42
(NULL)
IN101
322/1
Intrts de listes (1)
Liste [ 1; 5; 6 ]
tte (head) = 1
queue (tail) = [ 5; 6 ]
de type elem.
de type elem list.
Nombreuses oprations en temps constant ((1)).
Insrer un lment au dbut (cons).

Supprimer le premier lment (la tte).
Avancer llment suivant.
Insrer un lment aprs un lment dont on connait ladresse.
Supprimer llment suivant un lment dont on connait ladresse.
IN101
323/1
Intrts de listes (2)
Dautres oprations pour pas cher, juste 1 ou 2 changements de

pointeurs:
Concatner 2 listes (append).

Construire 2 listes partageant la mme queue.
Attention ne pas faire de double-libration de mmoire !
changer les queues de 2 listes. . .
Structure facilement re-dimensionnable (extension, rduction).

Accs direct plus cher que pour les tableaux. . .
Mais dimensionnement dynamique plus facile !
IN101
324/1
Implmentation en C: ajout en tte (cons)

cons elem list list
s t r u c t l i s t c o n s ( i n t elem , s t r u c t l i s t l s t )
{
s t r u c t l i s t tmp = m a l l o c ( s i z e o f ( s t r u c t l i s t ) ) ;
i f ( tmp == NULL) r e t u r n (NULL) ;
tmp>d a t a = e l e m ;
tmp>n e x t = l s t ;
r e t u r n ( tmp ) ;
}
lst
...
lst
...
IN101
325/1
Implmentation en C: impression (1)

print list void
void p r i n t ( struct l i s t l s t )
{
printf (" [ ") ;
w h i l e ( l s t != NULL) {
p r i n t f ( " %d" , l s t >d a t a ) ;
l s t = l s t >n e x t ;
}
printf (" ] ") ;
}
criture (plus simple, mais plus coteuse en pile) en rcursif:

void rec_print ( struct l i s t l s t )
{
i f ( l s t != NULL) {
p r i n t f ( " %d" , l s t >d a t a ) ;
r e c _ p r i n t ( l s t >n e x t ) ;
}
}
IN101
326/1
Implmentation en C: impression (2)

void p r i n t ( struct l i s t l s t )
{
printf (" [ ") ;
p r i n t f ( " %d" , l s t >d a t a ) ;
l s t = l s t >n e x t ;
}
printf (" ] ") ;
}
ntf
ntf
pri
pri
ntf
pri
tmp != NULL
tmp != NULL
ntf
pri
ntf
pri
tmp != NULL
tmp != NULL
urn
ret
tmp == NULL
tmp != NULL
IN101
327/1
Implmentation en C: concatnation (append)

append list list list
s t r u c t l i s t append ( s t r u c t l i s t l 1 , s t r u c t l i s t l 2 )
{
s t r u c t l i s t tmp ;
i f ( tmp == NULL) r e t u r n ( l 2 ) ;
tmp = l 1 ;
w h i l e ( tmp>n e x t != NULL) tmp = tmp>n e x t ;
tmp>n e x t = l 2 ;
return ( l1 ) ;
}
l1
l2
l1
parcours...
l2
IN101
328/1
Implmentation en C: libration
free_list list void
void f r e e _ l i s t ( struct l i s t l s t )
{
s t r u c t l i s t tmp ;
tmp = l s t >n e x t ;
free ( lst ) ;
l s t = tmp ;
}
}
criture (plus simple, mais plus coteuse en pile) en rcursif:

void r e c _ f r e e _ l i s t ( struct l i s t l s t )
{
i f ( l s t != NULL) {
r e c _ f r e e _ l i s t ( l s t >n e x t ) ;
free ( lst ) ;
}
}
IN101
329/1
Implmentation en C: double libration

l1
l2
l3 = append (l1, l2)
free_list (l2)
free_list (l1)
vieux pointeur suivi
double libration
IN101
330/1
Implmentation en C: libration anticipe

l1
l2
l3 = append (l1, l2)
free_list (l3)
l1 > next
l1
IN101
331/1
Variations sur les listes

Beaucoup de variantes:
Doublement chanes (pointeur prev) pour reculer.

Listes circulaires: dernier lement pointe sur le premier.
Listes circulaires doublement chanes . . .
La liste peut tre plus que le pointeur vers son premier lment:
Peut contenir le nombre dlments.

Peut contenir le pointeur vers le dernier lment.
...
struct l i s t {
i n t nb_elems ;
s t r u c t c e l l head ;
struct c e l l last ;
};
struct c e l l {
i n t data1 ;
i n t data2 ;
struct c e l l next ;
};
En fait, listes = cas simple de arbres ( voir plus tard).

IN101
332/1
Les arbres
IN101
333/1
Arbre ?
Structure arborescente: forme dun . . . arbre !

Des nuds, des arcs.
Pas de boucle.
IN101
334/1
Vocabulaire (1)
Nud (node):
racine
Racine (root)
Nud interne
Feuille (leaf)
Arc (edge)
Sous-arbre (subtree)
Parent:
Pre (parent)
Fils (child)
Frre (sibling)
noeuds internes
arc
feuilles
sousarbre
pre
Fils
Frres
IN101
335/1
Vocabulaire (2)
Degr dun nud: nombre de fils.

Arit dun arbre: nombre max de fils.
Certains nuds peuvent en avoir moins.
Arbre binaire: arit 2.
Sinon, arbre n-aire.
IN101
336/1
Exemple: les listes
[1; 3; 8]
Type inductif:
Liste vide.
lement suivi dune liste.
Longueur de la liste: hauteur de larbre.
1
3
8
IN101
337/1
Exemple: les arbres de syntaxe
Expressions arithmtiques (+ gnralement, termes):
Constantes.
Oprateurs binaires entre expressions arithmtiques.
Appel de fonction avec des expressions arithmtiques en arguments.
Variables.
Exemple: cos(y + 3) z 5
Permet de calculer sur les expressions:
valuation,
drivation,
simplification,
compilation. . .
*
cos
+
y
IN101
338/1
Exemple: le dictionnaire
Arbre n-aire (26-aire).
Permet la partage de prfixes communs.
Puisque mots prfixes dautres, ncessit de marquer les fins de mots.
Exemple: { allo, bac, bache, barbe, barre, cou, court, courte }.
IN101
339/1
Exemple: le systme de fichiers

/
|-|
|
|
|
|-|
|
|
|
|
|
|
|
|
|-|-|
bin
|-- alsaunmute
|-- arch
|-- awk
-- zcat
boot
|-- config-2.6.40.6-0.fc15.i686
Racine: /
|-- grub
|
|-- device.map
Noeuds internes:
|
|-- e2fs_stage1_5
Feuilles: fichiers.
|
|-- ufs2_stage1_5
|
|-- vstafs_stage1_5
|
-- xfs_stage1_5
|-- initramfs-2.6.40.6-0.fc15.i686.img
-- vmlinuz-2.6.43.2-6.fc15.i686
cgroup
dev
|-- autofs
rpertoires.
IN101
340/1
Implmentation par pointeurs
Cas gnral: nombre quelconque de fils:
Liste chane de tous les fils (frres).

Le parent a un pointeur sur son 1er fils.
ld
chi
data
brother
d
hil
ch
ild
ild
ch
brother
brother
brother
s t r u c t node {
i n t data ;
s t r u c t node c h i l d ;
s t r u c t node b r o t h e r ;
};
IN101
341/1
Arbres binaires
Un nud a au plus 2 fils:
1 fils droit
1 fils gauche
Simples mais nombreuses applications:
left
Codage de Huffman.
Calcul de la complexit optimale du tri.
Recherche sur un ensemble ordonn.
Satisfiabilit de formules boolennes (Binary Decision Diagram) . . .
data
right
s t r u c t bnode {
i n t data ;
s t r u c t bnode l e f t ;
s t r u c t bnode r i g h t ;
};
IN101
342/1
Implmentation par tableau

Un nud a un indice i.
Ses fils sont aux indices 2i + 1 et 2i + 2.
Son pre est lindice floor ((i 1)/2).
Pas besoin de pointeurs.
Si arbre binaire complet, pas de perte de place.

2*0+1
2*0+2
4*0+1
a
b
d
c
e
h
7
IN101
343/1
Arbres binaires: parcours en profondeur

En Anglais: Depth First Search (DFS).
Descente au plus profond en commenant par le fils gauche.
Parcours rcursif:
chaque nud, on applique la descente sur le fils gauche.

Une fois le sous-arbre gauche explor, on explore le fils droite.
Une fois le sous-arbre droite explor, on remonte et applique le
parcours.
Fin: fin de lexploration du sous-arbre droite.
v o i d d f s ( s t r u c t b_node n )
{
i f ( n != NULL) {
d s f ( n> l e f t ) ;
d s f ( n> r i g h t ) ;
}
Ici, on a fait que parcourir, aucun

traitement. . .
IN101
344/1
Arbres binaires: parcours en profondeur prfixe
3 endroits pour insrer du traitement du nud courant.
Au dbut.
v o i d p r e f i x ( b_node n ) {
i f ( n != NULL) {
do_something ( n>d a t a ) ;
p r e f i x ( n> l e f t ) ;
p r e f i x ( n> r i g h t ) ;
}
}
IN101
345/1
Arbres binaires: parcours en profondeur infixe

Au milieu.
Si do_something est limpression: correspond lcriture normale
dune expression arithmtique.
4
v o i d i n f i x ( s t r u c t b_node n )
{
i f ( n != NULL) {
i n f i x ( n> l e f t ) ;
i n f i x ( n> r i g h t ) ;
}
}
+
1
3
3
sqrt
/
7
(3 * (sqrt (4))) + (7 / 2) (= 9.5)
IN101
346/1
Arbres binaires: parcours en profondeur postfixe

la fin.
Si do_something est limpression: correspond lcriture RPN
(polonaise inverse).
7
v o i d p o s t f i x ( s t r u c t b_node n )
{
i f ( n != NULL) {
p o s t f i x ( n> l e f t ) ;
p o s t f i x ( n> r i g h t ) ;
0
do_something ( n> v a l ) ;
}
}
+
3
*
2
sqrt
7
4
/
2
5
3 4 sqrt * 7 2 / + (= 9.5)
IN101
347/1
Arbres binaires: parcours en profondeur, applications
Recherche de composantes connexes.

Tri topologique.
Recherche de points dans un graphe.
Recherche de composantes fortement connexes.
Test de planarit dun graphe.
Recherche de solution de jeux (labyrinthe par exemple).
Gnration de labyrinthe (DFS alatoire).
Etc. . .
IN101
348/1
Arbres binaires: parcours en largeur

En Anglais: Breadth First Search (BFS).
Parcours par niveaux (croissants).
On visite dabord tous les nuds de mme profondeur.
Utilisation dune file:
On extrait un nud, on le traite, on insre tous ses fils.
0
1
3
7
+
2
*
4
sqrt
/
6
v o i d l a r g e u r ( s t r u c t b_node n )
{
enqueue ( n ) ;
w h i l e ( ( n = t a k e ( ) ) != NULL) {
i f ( n> l e f t != NULL)
e n q u e u e ( n> l e f t ) ;
i f ( n> r i g h t != NULL)
e n q u e u e ( n> r i g h t ) ;
}
}
IN101
349/1
Arbres binaires de recherche

Structure darbre binaire telle que:
Chaque nud contient une clef.

La clef dun nud est > celle de son fils gauche.
Inductivement > celles du sous-arbre gauche.
La clef dun nud est < celle de son fils droite.
Inductivement < celles du sous-arbre droite.
< 21
> 21
21
42
7
1
35
10
64
> 42
22
38
> 21 et < 42
IN101
350/1
Arbres binaires de recherche: intrts

Stockage en (n).
Recherche en (h)
(h hauteur de larbre).
Insertion en (h).
Suppression en (h).
En moyenne h = (log (n)) : bonne solution au problme de

recherche en table.
Dans le pire cas h = n : intrt davoir des arbres quilibrs.
Par rapport aux tables de hachage :
Pas besoin de connatre n lavance.

Pas de mmoire gaspille.
Les ABR quilibrs sont une solution efficace dans le pire cas.
IN101
351/1
Arbres binaires de recherche: recherche

35 ?
35 > 21
21
35 < 42 42
7
1
35
10
22
64
38
23 ?
21
23 > 21
#i n c l u d e <s t d b o o l . h>
bool
{
if
if
if
( n == NULL) r e t u r n ( f a l s e ) ;
( v == n>d a t a ) r e t u r n ( t r u e ) ;
( v < n>d a t a )
r e t u r n ( s e a r c h ( v , n> l e f t ) ) ;
else
r e t u r n ( s e a r c h ( v , n> r i g h t ) ) ;
23 < 42 42
s e a r c h ( i n t v , s t r u c t b_node n )
}
1
10
23 < 35 35
23 > 22 22
64
38
IN101
352/1
Arbres binaires de recherche: insertion (version nave)

Rechercher la position du nud dans larbre.
Lajouter comme fil du dernier nud rencontr.
Ajouter 23
23 > 21
21
23 < 42 42
7
1
10
23 < 35 35
23 > 22 22
64
38
23
IN101
353/1
Arbres binaires de recherche: suppression
On commence par rechercher le nud supprimer dans larbre.

3 cas dont 2 simples:
Suppression dune feuille ( facile).

Suppression dun nud avec 1 seul fils ( facile).
Suppression dun nud avec 2 fils ( plus compliqu).
IN101
354/1
ABR, suppression: 1 feuille

21
7
1
42
35
10
22
64
Suppression du nud 8 . . .
38
Mettre le pointeur droit du nud 10 NULL.

Librer la mmoire occupe par le nud 8.
21
7
1
42
35
10
22
64
38
IN101
355/1
ABR, suppression: 1 seul fils

21
7
1
42
35
10
22
64
38
Faire pointer son pre (7) vers son fils (8).

Librer la mmoire occupe par le nud 10.
21
7
1
42
35
10
22
64
38
IN101
356/1
ABR, suppression: 2 fils

21
7
42
1
35
10
22
64
38
Remplacement par le min du fils droit ou le

max du fils gauche.
Successeur ou prdcesseur le plus proche.
Choisir un candidat.
10
7
On recopie sa clef et ses donnes pour

remplacer le nud 21.
42
Ensuite, comme prcdemment avec 1 fils.

1
35
10
22
64
38
IN101
357/1
Pour la culture . . . darbres. . .
Nombreuses autres formes darbres de recherche:
AVL trees.
Red-Black trees.
Patricia trees (radix trees).
Splay trees.
Etc. . .
IN101
358/1
Les graphes
IN101
359/1
Motivations: exemple du GPS (1)
IN101
360/1
Motivations: exemple du GPS (2)
Intersection = sommet.
Routes = arcs entre les sommets.
Routes: peuvent avoir des caractristiques
Une orientation (double-sens, sens unique).

Des poids (vitesse, distance, charge. . . )
Plan = graphe orient pondr.

But: trouver / optimiser un trajet analyser le graphe.
IN101
361/1
Quelques utilisations
Graphes utiliss pour reprsenter de nombreuses structures.

Rseaux de communication (routes, trains, mtros, tlcoms . . . ).
Planification de tches (dpendance / antriorit).
Flot de contrle de programme (compilation).
Synthse de types (union-find & path-compression).
Etc.
IN101
362/1
Dfinitions: graphe orient

Graphe orient: couple (S , A)
S : ensemble de sommets (vertex/vertices).

A : ensemble darcs (edge), sous-ensemble de S S.
Chemin: suite darcs conscutifs (path).

Longueur dun chemin: nombre darcs sur ce chemin.
Chemin simple: chemin o aucun arc nest parcouru plusieurs fois.
Cycle: chemin qui boucle.
arc
4
2
cycle
1
sommet
chemin de longueur 3
IN101
363/1
Dfinitions: graphe non-orient

Graphe non-orient: comme un graphe orient . . . sans orientation sur
les liens entre sommets.
Les arcs sont souvent appels artes la place.
Les chemins sont souvent appels chanes la place.
arte
4
2
cycle
1
sommet
chane de longueur 3
IN101
364/1
Reprsentation en machine: liste de successeurs (1)

Mthodes par chanage et manipulation de pointeurs.
Plusieurs mthodes selon les besoins.
Par exemple:
Tableau t des successeurs de chaque sommet.
t[i] pointe la liste chane des successeurs du sommet i.
Accs direct un sommet via t.
Complexit spatiale optimale en (S + A).
t
0
0
2
5
3
IN101
365/1
Reprsentation en machine: liste de successeurs (2)

On peut aussi physiquement partager les sommets.
Chaque sommet est reprsent 1 et 1 seule fois.

Chaque sommet a une liste dont les lments pointent sur ses
successeurs.
Reprsentation trs similaire au dessin.

4
0
0
2
5
IN101
366/1
Reprsentation en machine: matrice dadjacence

Ensemble S des sommets indxs de 0 n 1.
Arcs A S S.
Matrice M de taille n n telle que:
Mij = 1 sil existe un arc i j (i.e. (i , j) A).
Mij = 0 sinon.
Complexit spatiale: (n2 ).
dest (j)
src (i)
4
2
5
1
3
IN101
367/1
Parcours de graphe : pourquoi parcourir ?
Un graphe ne sert pas stocker des donnes.

On construit un graphe partir de donnes.
On analyse le graphe pour dduire des proprits sur les donnes.
Parcours = manire danalyser un graphe.
Permet dextraire de nombreuses informations:
Existence de chemin(s).
Plus court(s) chemin(s).
Composantes (fortement) connexes ( accessibilit).
Recouvrements ( sous-graphes, arbres).
Tri topologique ( dpendances).
Etc.
IN101
368/1
Recouvrement de graphe
Un parcours sert en gnral produire un recouvrement dun graphe.

Recouvrement: arbre contenant tous les somments du graphe.
Arbre chaque sommet a au plus 1 parent.
Et sans cycles.
En quelque sorte, cest le graphe amput de certains arcs.
But: simplifier un graphe
Garder seulement une information intressante.
IN101
369/1
Exemple de recouvrement
1
Pre
Noeud
5
3
0
_
3
2
Reprsentation par un tableau de pres.

On cherchera des recouvrement intressants.
Celui de lexemple ??? Fait au hasard . . .
IN101
370/1
Parcours en largeur
quivalent du parcours par niveaux des arbres :
On part dun sommet,

on visite tous les voisins,
on visite tous les voisins des voisins. . .
Sommets de distance d dcouverts avant ceux de distance d + 1.

Problmes:
Ne pas boucler en visitant les cycles.

Ne pas visiter plusieurs fois le mme sommet.
Marquage des sommets lors du parcours:
Blanc: non visit (ou non marqu).

(Gris: en cours de visite, si besoin.)
Noir: dj visit (ou marqu).
IN101
371/1
Parcours en largeur: algorithme gnral

Utilisation dune file F : contient initialement 1 seul sommet (racine).
Complexit en O(A) pour une reprsentation par listes.
Soit r la racine ;
Marquer r ;
E n f i l e r r dans l a f i l e F ;
Tant que F n e s t p a s v i d e {
s = l m e n t en t t e de F ;
T r a i t e r (s ) ;
Pour chaque v o i s i n v du sommet s {
S i v n e s t p a s marqu a l o r s {
Marquer v ;
E n f i l e r v dans l a f i l e F ;
}
}
}
IN101
372/1
Parcours en largeur: application un labyrinthe (1)

But: trouver la sortie dans un labyrinthe.
De prfrence, le plus court chemin !
Crer un graphe partir du labyrinthe.
IN101
373/1
On commence le parcours par lentre (sommet vert).
IN101
374/1

On descend en largeur en mmorisant le pre de chaque sommet visit.
5
3
5
IN101
375/1

On descend en largeur en mmorisant le pre de chaque sommet visit.
Arriv la sortie, on retrace le chemin en remontant les pres.
4
13
12
10
11
14
10
11
12
13
12
11
10
11
12
13
14
13
14
13
12
13
14
IN101
376/1
Parcours en profondeur: algorithme gnral

quivalent du parcours en profondeur des arbres:
On descend au plus profond en premier.

Algorithme naturellement rcursif.
Aucune garantie de plus court chemin.

Mmes problmes que pour le parcours en largeur marquage.
Complexit en O(A) pour une reprsentation par listes.
DFS ( sommet s )
{
Marquer s ;
( Pr t r a i t e r s ; ) / S e l o n l e b e s o i n . /
Pour chaque v o i s i n non marqu v du sommet s
DFS ( v ) ;
( Post t r a i t e r s ; ) / S e l o n l e b e s o i n . /
}
}
IN101
377/1
Parcours en profondeur: mmorisation des dates de visite

On conserve une variable temps t.
On enregistre les dates de dbut / fin (beg [] / end[]) de visite.
DFS ( sommet s )
{
Marquer s ;
beg [ s ] t ;
//
Pour chaque v o i s i n
p a r [ v ] s ; //
DFS ( v ) ;
}
t t + 1 ;
end [ s ] ;
//
}
Mmoriser date dbut .

non marqu v du sommet s {
Mmoriser l a p a r e n t .
Mmoriser date f i n .
IN101
378/1
Parcours en profondeur: exemple (1)
4
0
5
3
On commence par le sommet 4, on le marque.

On inspecte son premier voisin . . . lui-mme.
Dj marqu, donc on ne visite pas dans cette direction.
IN101
379/1
5
3
On inspecte un autre voisin de 4: par exemple 0.

Il nest pas encore marqu, donc on va le visiter.
IN101
380/1
5
3
On inspecte un voisin de 0: par exemple 6.

Il nest pas encore marqu, donc on va le visiter.
IN101
381/1
5
3
Le sommet 6 na pas de voisin descente termine.

On va inspecter un autre voisin de 0: par exemple 2.
Pas encore marqu donc on le visite.
Puis le voisin de 2: 6. Dj marqu descente termine.
IN101
382/1
0
3
5
4
On remonte va inspecter le dernier voisin de 0: 3.

Pas marqu donc on le visite.
Etc.
IN101
383/1

la fin on obtient un recouvrement du graphe.
En rouge, le dernier sommet visit.
En pointill les arcs non suivis lors de la visite.
Dans un graphe orient sans cycle:
Les fins de visite forment un ordre.

Sil existe un chemin de u v alors end[u] > end[v ].
0
3
5
4
IN101
384/1
Application du parcours en profondeur: tri topologique
Soit un ensemble de tches raliser selon des contraintes dordre.

Certaines doivent tre ralises avant dautres.
Exemples:
Gestionnaire de compilation (make).

Chane de montage en usine.
Gestion de projets, construction de btiment.
Construire un graphe de dpendances.

Le parcourir en profondeur en notant les dates de fin.
Retourner les sommets en ordre dcroissant des dates de fin.
Sil y a un cycle impossible de planifier !
IN101
385/1
Tri topologique et ordonnancement (1)

Construire une maison. . .
fondations
murs
crpis
cloisons
fentres
pelouse
eau
toit
cuisine
sanitaires
papier/peinture
IN101
386/1

Parcours en profondeur. . .
beg=0
end=21 fondations
beg=1
end=20
murs
beg=13
end=16
crpis
beg=12
end=17
beg=2
end=11 cloisons
fentres
beg=14
pelouse end=15
beg=7
beg=18
end=19
toit
beg=3
end=6
eau end=10
cuisine
beg=8
end=9
beg=4
end=5
sanitaires
papier/peinture
IN101
387/1

Tches effectuer en ordre dcroissant des dates de fin de visite.
Todolist
beg=1
end=20
murs
beg=13
end=16
crpis
beg=12
end=17
beg=2
end=11 cloisons
fentres
toit 19
fentres 17
beg=14
pelouse end=15
beg=7
beg=18
end=19
toit
beg=3
end=6
beg=4
end=5
cuisine
sanitaires
sanitaires
papier/peinture
crpis 16
pelouse 15
cloisons 11
eau 10
eau end=10
beg=8
end=9
fondations 21
murs 20
temps
beg=0
end=21 fondations
cuisine
5
9
6
papier/peinture
IN101
388/1
Matrice dadjacence: ne pas jeter tout de suite

Rappel: matrice n n.
Possibilit de compression car matrice binaire 1 bit par case.

Mais souvent, quand mme trop lourd en espace mmoire.
On a vus des algos linaires avec une reprsentation par liste de
successeurs ! Pourquoi revenir sur une matice ?
Elle permet de traiter plusieurs problmes la fois:
Calculer tous les chemins de longueur l dun coup.

Trouver tous les plus courts chemins dun coup.
Calculer une fermeture transitive.
Matrice toute lartillerie dalgbre linaire. . .
IN101
389/1
Calcul du nombre de chemins

Soit M la matrice n n dadjacence dun graphe.
Le nombre de chemins de longueur k reliant i j est Mik,j .
Preuve par rcurrence sur lexposant k:
Pour k = 1, immdiat puisque matrice initiale binaire, que des 1s et un

chemin de longueur 1 est un arc du graphe.
Pour k > 1 on a M k = M k1 M.
Donc pour k > 1,
n
1
Mik,,j = (Mik
,l Ml ,j )
l=1
1
Mik
,l
Par hypothse de rcurrence,

est le nombre de chemins de
longueur k 1 de i l.
Ml ,j est gal 1 si (l , j) est un arc de G et 0 sinon.
1
Donc, Mik
,l Ml ,j est le nombre de chemins de i j de longueur k
dont le dernier arc est (l , j).
Donc la sommation nl=1 donne donc toutes les possibilits de longueur
k de i j quelque soit le sommet de dpart l du dernier arc.
IN101
390/1
Existence de chemins
Dans un graphe n sommets, si un chemin existe entre i et j il est au
plus de longueur n.
On pose M + = M + M 2 + M 3 + ... + M n .
M + est le nombre de chemins de longueur 1 n reliant i j.

Si Mi+,j = 0, il ny a pas de chemin.
Il existe un chemin de i a j si et seulement si Mi+,j 0.
b o o l e x i s t s _ p a t h ( i , j , mat )
{
prod_mat mat ;
sum_mat mat ;
f o r ( k = 1 ; ( sum_mat [ i ] [ j ] == 0 ) && ( k < n ) ; k++) {
prod_mat prod_mat mat ;
sum_mat sum_mat + prod_mat ;
}
r e t u r n ( sum_mat [ i ] [ j ] != 0 ) ;
}
IN101
391/1
Fermeture transitive dun graphe G = (S , A)

Relation transitive minimale contenant la relation (S , A).
Graphe G tel que chaque chemin de G est reprsent par un arc.

3
0
1
Permet de rpondre aux questions dexistence de chemins entre 2

sommets quelconques.
Navement on peut calculer sa matrice M partir de M + :
Mi,j = 0 si Mi+,j = 0.
M i ,j = 1 sinon.
Complexit en (n4 ) M
IN101
392/1
Fermeture transitive plus efficace

Algorithme attribu Roy & Warshall.
Justification non triviale (itration dune opration dajout darcs).
Complexit en (n3 ).
Utilisation de simples oprations boolennes.

On pose N la mme matrice que M avec en plus des 1 sur la diagonale.
for (k = 1; k <
for ( i = 1; i
for ( j = 1;
N[ i ] [ j ] =
}
}
}
n ; k++) {
< n ; i ++) {
j < n ; j ++) {
N [ i ] [ j ] | | (N [ i ] [ k ] && N [ k ] [ j ] ) ;
IN101
393/1
Dans la vraie vie. . .
IN101
394/1
Jusqu prsent. . .
On a vu comment crire des algorithmes.

On a vu comment faire de petits programmes.
Toujours depuis zro.
Seul appui : bibliothque standard de C.
(Exception: bibliothque graphique utilise pour les TDs).
IN101
395/1
Dveloppement de taille raliste
Logiciel de taille relle: entre millier(s) et million(s) de lignes de code.

Pas le temps de rinventer (et dbugger) la roue.
Besoin de rutiliser du code entre applications.
Gain de temps et de cohrence.
Peut inclure des composants mtiers.
On na pas la connaissance pour implmenter.
Utilisation de composants logiciels dj existants.
Les bibliothques (en Anglais, libraries).
IN101
396/1
Bibliothque
Collection de fonctions mises disposition pour traiter un problme.

Code sur lequel on peut sappuyer.
Deux formes: bibliothque statique ou dynamique.
Statique: fichier .a similaire un .o linker votre programme.
Forcment disponible une fois le programme compil.
Augmente la taille du programme.
Dynamique: code charg lors de lexcution.
Partag par dautres programmes.
Naugmente pas la taille du programmes.
Mais si lexcution bibliothque absente: excution impossible.
IN101
397/1
Exemples
Faire du graphisme: gestion des diffrents types de cartes, de types de

reprsentation en mmoire graphique.
Calcul numrique: besoin de structure et doprations de base pour
implmenter le calcul souhait.
Travailler sur des images: lecture et criture de fichiers aux formats
standards (JPG, GIF, BMP, PNG, etc.).
Accder des documents WEB: ouverture de connexion, rcupration
et envoi de donnes.
Souvent des traitements non triviaux, mais pr-requis votre
traitement.
IN101
398/1
Utilisation
Une bibliothque fournit:
Du code binaire.
Des fichiers dentte (.hs) : lApplication Programming Interface.
(. . . Souvent) une documentation.
Lecture de la documentation:
Paradigme dutilisation.
Organisation de la bibliothque ( chapitres).
Quand cest bien fait, comme les enttes plus des explications. . .
Lecture des enttes:
Quelles fonctions disposition.

Comment, avec quoi les appeler, quen obtenir en retour.
IN101
399/1
Un exemple: GSL (GNU Scientific Library)
Bibliothque de calcul scientifique.

Complexes, matrices, algbre linaire, statistique, qua-diffs, etc.
Permettra de se concentrer sur problme mathmatique. . .
. . . Et pas sur limplmentation efficace des donnes primitives
mathmatiques.
Ex: calcul des dcimales de (nombreux algorithmes, mais supposent
des rationnels non approxims).
IN101
400/1
GSL: documentation
IN101
401/1
GSL: (trs bonne) documentation
IN101
402/1
GSL: enttes et code

...
-rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r-...
1
1
1
1
1
1
1
1
1
1
1
root
root
root
root
root
root
root
root
root
root
root
admin
admin
admin
admin
admin
admin
admin
admin
admin
admin
admin
2781
519
4533
6655
6852
4460
4533
7560
4606
4918
4845
14
14
14
14
14
14
14
14
14
14
14
sep
sep
sep
sep
sep
sep
sep
sep
sep
sep
sep
22:04
22:04
22:04
22:04
22:04
22:04
22:04
22:04
22:04
22:04
22:04
gsl_spline.h
gsl_statistics.h
gsl_statistics_char.h
gsl_statistics_double.h
gsl_statistics_float.h
gsl_statistics_int.h
gsl_statistics_long.h
gsl_statistics_long_double.h
gsl_statistics_short.h
gsl_statistics_uchar.h
gsl_statistics_uint.h
...
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif
__BEGIN_DECLS
double gsl_stats_char_mean (const char data[], const size_t stride, const size_t n);
double gsl_stats_char_variance (const char data[], const size_t stride, const size_t n);
double gsl_stats_char_sd (const char data[], const size_t stride, const size_t n);
...
IN101
403/1
GSL: code
-rwxr-xr-x
-rw-r--r-lrwxr-xr-x
-rwxr-xr-x
-rwxr-xr-x
-rw-r--r-...
1
1
1
1
1
1
root
root
root
root
root
root
admin
admin
admin
admin
admin
admin
2169752
3380304
14
925
236088
342232
14
14
14
14
14
14
sep
sep
sep
sep
sep
sep
22:04
22:04
22:04
22:04
22:04
22:04
/opt/local/lib/libgsl.0.dylib
/opt/local/lib/libgsl.a
/opt/local/lib/libgsl.dylib -> libgsl.0.dylib
/opt/local/lib/libgsl.la
/opt/local/lib/libgslcblas.0.dylib
/opt/local/lib/libgslcblas.a
Ncessit de #include des enttes utiliss.

Ncessit de donner les options gcc pour trouver les enttes.
Option -I<rpertoire> de gcc.
Ncessit de linker la bibliothque votre programme.
Option -l<nom bibliothque> de gcc.
Binaire de bibliothque nomm "libfoobar.a" -lfoobar
Parfois -L<rpertoire> pour trouver les bibliothques.
Vous lavez fait sans le savoir avec les TDs graphiques.
-I/opt/local/include/SDL -D_GNU_SOURCE=1 -D_THREAD_SAFE
-L/opt/local/lib -lSDLmain -lSDL -Wl,-framework
IN101
404/1
Quand a ne marche pas . . .
Vous ntes plus matre de tout le code de votre programme.

3 possibilits:
a plante dans votre code . . .

a plante parce que vous utilisez mal la bibliothque . . .
a plante car la bibliothque est bugge . . . /
IN101
405/1
Quand a continue de ne pas marcher . . .
Outil spcialis pour le debuggage : le debugger.

Sous Unix gdb (interfaces: cgdb, ddd, xxgdb . . . ).
Souvent intgrs aux IDEs: Xcode, Eclipse, Code::Blocks . . .
Permet:
dinterrompre lexcution,
poser des points darrt spcifiques / conditionnels,
surveiller les valeurs des variables,
trouver la ligne de code o a plante,
Etc.
Ncessite de compiler avec loption -g (pour avoir la vue source).
IN101
406/1
gdb: lancement
IN101
407/1
gdb: points darrt
IN101
408/1
gdb: inspection de variables
IN101
409/1
gdb: excution pas--pas
IN101
410/1
gdb: suivre les appels de fonctions
IN101
411/1
Construire un excutable
En TDs: petits programmes.

Taille raliste: des centaines, des milliers de fichiers source:
crits la main,
gnrs automatiquement (lexer, parsers, automates, etc.).
Tout re-compiler chaque fois: trop long.

Ordre de dpendances entre fichiers: non trivial.
En cas de modif, re-compiler le minimum et dans lordre.
Gestionnaire de build.
Commande make sous Unix (c.f. TD n12).
IN101
412/1
Un Makefile
Fichier de description de build: Makefile.
Dfinit:
Des cibles,
fabriquer partir de pr-requis,
en appliquant des commandes.
Possibilit dutiliser des variables.

Vrifie les fichiers changs depuis la dernire invocation . . .
. . . ne reconstruit que ce qui dpend de ces changements.
BINDIR=
GCC=$(BINDIR)gcc
COMPFLAGS=-Wall
all: code1 enonce.pdf
code1: stack.h stack.c test_stack.c
$(GCC) $(COMPFLAGS) stack.c test_stack.c -o test_stack.x
enonce.pdf: pictures enonce.tex
echo "" > flags.tex
latex enonce.tex
dvipdf enonce.dvi
pictures: auto1.fig
fig2dev -L eps auto1.fig > auto1.eps
Algorithmique
clean: et programmation
rm -f a.out
*.o *.x *~ .*~ flags.tex *.dvi *.pdf
*.aux *.log
Franois Pessaux
, francois.pessaux@ensta-paristech.fr,
ENSTA
IN101
413/1
Grer les volutions

Un programme volue: corrections, nouvelles fonctionnalits.
Des changements peuvent casser le programme.
Parfois besoin de reproduire un tat antrieur (rapport de bug).
Restituer ltat des fichiers en fonction de leurs dpendances.
Besoin darchiver et de pouvoir revenir en arrire.
Plusieurs personnes travaillant sur les (mmes) fichiers.
Ncessit de grer les conflits (modifications concurrentes).
Outils de gestion de configuration.
git, svn, cvs, etc.
IN101
414/1
Diffrents outils langage

C: langage gnraliste, mais bas niveau.
Certains problmes dautomatisation peuvent tre:
trs particuliers (traitement de lignes de texte),

trs ponctuels (dveloppement jetable, usage unique),
sans besoin de relles performances.
Si ncessaire sorienter vers des langages plus ddis et/ou des

langages de script.
Ex: OCaml, C++, Java, bash, sed, awk.
Ex: sed: Pour chaque ligne, on applique la commande puis on affiche
sur la sortie standard la ligne modifie ou non.
sed -e "s/$[0-9][0-9]*$/**\1**/" fichier :
encadre le premier nombre de chaque ligne avec des **.
Si ncessaire, combiner plusieurs outils de dveloppement !
IN101
415/1
changes de donnes (1)

Besoin dchanger des informations entre programmes.
Sortie de lun = entre de lautre.
Diffrents types: texte, images, donnes structures, etc.
Forme binaire interne pas adapte
Dpend des structures du programme.

Dpend de larchitecture de la machine hte.
Ncessite des transformations (criture / lecture).

Pas (toujours) de format universel (unique).
Ex pour les images: gif, jpg, bmp, etc.
Quelques standards: XML (structur), CSV (plat).
Essayer de trouver un format simple et reconnu, sinon:
Les conversions seront compliques.

Vous naurez aucune aide (bibliothque) pour vous appuyer.
Personne ne saura lire vos donnes.
IN101
416/1
changes de donnes: CSV
Format plat: Comma Separated Values.

Exportation de valeurs spares par des virgules.
Pas de structure propre.
Facile manipuler.
Reconnu par les tableurs.
Exemple: change de valeurs dates dun capteur:
Date,Sensor,Temperature
10,Th0,110
11,Th0,115
11,Th1,102
12,Th0,112
IN101
417/1
changes de donnes: XML

Permet de reprsenter une hirarchie.
Permet de reprsenter des entits composites.
Trs verbeux.
Ncessite une mise plat des cycles et du partage.
Mais
Normalis, gnraliste, extensible, textuel.

Existence de bibliothques permettant la manipulation.
<?xml version="1.0" encoding="UTF-8"?>

<osm version="0.6" generator="OpenStreetMap server">
<bounds minlat="48.69134" minlon="2.1811" maxlat="48.70314" maxlon="2.19748"/>
<node id="26691576" lat="48.6992595" lon="2.1875437" version="13" changeset="10777
<tag k="place" v="town"/>
<tag k="name" v="Orsay"/>
<tag k="postal_code" v="91400"/>
<tag k="population" v="14800"/>
<tag k="code_INSEE" v="91471"/>
<tag k="code_departement" v="91"/>
</node>
IN101
418/1
Interfaces utilisateur (1)
Programmes en TDs: utilisation en ligne de commande.

Parfois besoin dinterfaces plus complexes, amicales.
Fentres, boutons, menus, etc. IHM (en Anglais, GUI).
Bibliothques existantes pour crer et programmer des IHMs.
Malheureusement: rien duniversel !
Changement en fonction des OS: (Mac, Linux, Windows, Androd. . . )

Changement en fonction des versions dOS.
Plusieurs pour un mme OS: (Linux: X11, Gnome, KDE).
Diffrents paradigmes:
vnementiel: droulement contrl par la survenue dvnements.

Procdural: droulement contrl par une boucle de surveillance
explicite.
IN101
419/1
Interfaces utilisateur (2)
Mise en place souvent coteuse.

Ncessite de cbler les actions aux lments graphiques.
Mais ncessite aussi de penser la facilit dutilisation !
Ergonomie.
Existence de gnrateurs dinterfaces: le look.
Le code qui ragit reste votre charge.
Possibilit (parfois ncessit) de crer dynamiquement des lments:
Par programmation manuelle.
IN101
420/1
Interfaces utilisateur: programmer le comportement

// C a l l e d on v i e w l o a d e d i n memory .
( void ) viewDidLoad
{
[ super viewDidLoad ] ;
[ modeSegControl addTarget : s e l f
a c t i o n : @ s e l e c t o r ( changeUsageMode : )
forControlEvents :
UIControlEventValueChanged ] ;
}
// C a l l e d on " r e t u r n " k e y h i t i n t h e e d i t b o x .
(BOOL) t e x t F i e l d S h o u l d R e t u r n : ( U I T e x t F i e l d
) a T e x t F i e l d
{
i f ( a T e x t F i e l d == r e q u e s t F i e l d ) {
[ aTextField resignFirstResponder ] ;
[ s e l f submitRequest : r e q u e s t F i e l d . text ] ;
}
/ R e t u r n s YES t o s a y t h a t t h e s t a n d a r d
b e h a v i o u r must be a p p l i e d . /
r e t u r n ( YES ) ;
}
IN101
421/1
Ce quil faut retenir de ce cours. . .

Un dveloppement logiciel peut tre trs complexe.
Mlange des problmes diffrents niveaux (noyau, IHM,
performances, inter-connexion, interface hard/soft, etc.).
Il existe des algorithmes / structures de donnes connus.
Tout le reste cest de limagination . . . puis de la combinaison.
Il existe diffrents outils: ne pas sen priver. . .
. . . choisir les plus adapts votre problme et vos contraintes.
Programmer . . . nest pas toujours sur un PC.
Diffrentes contraintes en fonction de larchitecture.
Pas de solution universelle.
Il faudra toujours rflchir M
Derrire tout a: modles thoriques et mathmatiques formels.
. . . Bonne programmation pour la suite . . .
IN101
422/1

2015 10 14 IN1gh01-allslides-2012-2013

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

2015 10 14 IN1gh01-allslides-2012-2013

Hochgeladen von

Copyright:

Verfügbare Formate

Algorithmique et programmation

ENSTA - TC 1re anne

Avec certaines planches / ides de

Systmes informatiques omniprsents.

Ncessit pour tout ingnieur dy tre sensibilis.

Apprendre un premier langage, vous vous adapterez ensuite aux autres.

Vous avez dit ordinateur ?

Architecture dun ordinateur:

Mmoire(s) : pour stocker de linformation.

Traitement description de comment: programme.

Le programme est stock dans la mmoire...

Certains traitements peuvent se faire directement: x x + 1.

Diffrents fonctionnements de mmoire:

RAM (Random Access Memory) : lecture / criture Volatile.

Diffrents types de mmoire:

Mmoire de masse (disques) : 10 ms

Cest lunit qui travaille.

Lunit arithmtique et logique (UAL / ALU) : effectue les calculs.

Contient de la mmoire trs rapide ( 1 s): les registres.

Quest-ce que programmer ?

noncer une manire deffectuer un calcul.

En suivant la smantique des instructions / constructions.

Quest-ce quun programme ?

Lexpression () formelle dun problme rsoudre,

Il faut une spcification avant le code !

Y: Parfois, entres revoir en cours dlaboration de lalgorithme.

Instructions CPU trs simples travail dmesur.

Un langage de programmation permet:

De fournir des constructions de haut niveau.

Il suffit de traduire le programme pour lexcuter.

Soit avec un interprteur : JavaScript, shell, Matlab, Perl . . .

Des tonnes de langages de programmation !

Cr B. Kernighan, D. Ritchie et K. Thompson aux Bell Labs en 1972.

Trs utilis dans lindustrie malgr certains dfauts/difficults.

Algorithmique, programmation / langage.

Une mine dinfos: http://www.lysator.liu.se/c/

La plus simple manire dafficher en C Aloha cousins !

#include <> : Demander accs aux fonctions entre/sortie (printf).

Ignors par le langage.

Espaces non-significatifs mais indentez votre code !

Fonction main : point dentre du programme.

Fonction printf : affiche un message dans le terminal.

return : sortir dune fonction en retournant la valeur qui suit.

Code de sortie du programme.

Compilation et excution dun programme

> emacs aloha.c &

gcc aloha.c ou gcc aloha.c -o first.x

Activer tous les warnings (all plus que recommand).

Si tout sest bien pass, le compilateur naffiche rien.

Quelques constructions lmentaires

Diffrentes formes de donnes

En maths: entiers naturels, rels, rationnels, complexes . . .

En linguistique: caractres, mots (chanes de caractres)

De base primitifs, ( pour les chanes) inscables.

en terme de smantique (sens),

3 (4) types de donnes de base: entiers, rels, (boolens), caractres.

Les scalaires de base

Les entiers: type int.

Avant dtre excut, le programme est charg en mmoire.

Dclaration (cration) de variables, rceptacles dinformation.

2 zones mmoire diffrentes:

La pile: variables locales (temporairement accessibles).

un octet en mmoire peut avoir diffrentes significations.