2015_10_14_in1gh01-allslides-2012-2013

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

1/425

Algorithmique et programmation

ENSTA - TC 1ère année

François [email protected]

UIIS - Sûreté

2012-2013

Avec certaines planches / idées deMatthieu FiniaszFrançoise LévyMichel Mauny

http://find/http://goback/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

2/425

Introduction

Algorithmique et programmation IN101

François Pessaux , [email protected], ENSTA 2/1


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

3/425

But de ce cours

Systèmes informatiques omniprésents.▸ ⇒ Nécessité pour tout ingénieur d’y être sensibilisé.▸ ⇒ Nécessité de savoir juger l’efficacité et les limites de “l’informatique” .

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

Apprendre à automatiser des tâches quelque soit le domaine métier.

Acquérir un bagage scientifique supplémentaire.

Comprendre que informatique = science = mathématiques.

Entrevoir quelques problèmes scientifiques / de recherche intéressants.



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

4/425

Règles d’or

Ne pas hésiter à poser des questions. Même en amphi !Se rappeler que si vous avez une question “bête”, au moins 1/4 de lapromo’ se pose la même.

Le ridicule ne tue pas. Sinon ne je serais plus devant vous.

Ne s’avouer ni perdu ni vaincu. Venez demander des précisions, mêmeen mode “entretien particulier” .

Ne pas hésiter à venir me voir dans mon bureau pour me parler dequelque problème que ce soit.

Ne pas hésiter à dire “Mais M’sieur, vous ne vous êtes pas trompé sur xxx ?”

Ne pas hésiter à me faire part de vos facilités / difficultés.




8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

5/425

Architecture




8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

6/425

“Vous avez dit ordinateur ?”

Mais pour quoi faire ? Pour traiter de l’information.“Information ?”

▸ C’est un message.▸ Écriture avec des symboles : code.▸ Monde numérique : code binaire.

Architecture d’un ordinateur:▸ Mémoire(s) : pour stocker de l’information.▸ Micro-processeur (CPU) : pour travailler l’information.▸ Périphériques : pour échanger avec “l’extérieur” .

“Traitement” ⇒ description de “comment” : programme.

Architecture de Von Neumann :▸ Le programme est stocké dans la mémoire...▸ ... dans la même mémoire que les données (informations).




8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

7/425

La mémoire

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 (d’un) “l’ état ” précédent.

Différents fonctionnements de mémoire:▸ 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.

Différents types de mémoire:▸ Mémoire de masse (disques) : ∼ 10 ms ▸ Mémoire vive (RAM) externe au CPU : ∼ 40 − 50 ηs▸ Mémoire cache ± interne au CPU : ∼ 5 − 10 ηs▸ Registres : ∼ 1 ηs




8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

8/425

Le micro-processeur

C’est l’unité qui “travaille” .Idéalement segmentée en 2 parties:

▸ L’unité arithmétique et logique (UAL / ALU) : effectue les calculs.▸ L’unité de contrôle : décodage et séquencement des instructions.

Contient de la mémoire très rapide (∼ 1 ηs): les registres.“Instruction” : opération élémentaire effectuée par le CPU (addition de2 registres, copie registre ↔ mémoire, registre ← registre, décalages,sauts ...

Chaque CPU (x86, ARM, amd64 . . . ) est différent, a son propre jeud’instructions.




8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

9/425

Programmation

Algorithmique et programmation IN101François Pessaux , [email protected], ENSTA 9/1

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

10/425

“Qu’est-ce que programmer ?”

Énoncer une manière d’effectuer un calcul.Il existe toujours plusieurs manières d’effectuer un calcul.

Une machine ne sait que calculer (pas de raisonnement).

Un calcul s’effectue sur des données, des valeurs.

Programmer c’est donner une suite d’ordre au CPU.

Cette suite est un algorithme.Mais c’est surtout concevoir des objets mathématiques.

▸ En suivant la sémantique des instructions / constructions.

▸ Avec des propriétés bien définies.▸ ... sinon ... bug.


http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

11/425

“Qu’est-ce qu’un programme ?”

Un programme c’est:▸ L’expression (±) formelle d’un problème à résoudre,▸ puis l’expression de ce que l’on attend en sortie,

▸ puis l’établissement de ce que l’on a à disposition en entrée,▸ et enfin l’algorithme.

⇒ Il faut une spécification avant le code !: Parfois, entrées à revoir en cours d’élaboration de l’algorithme.


http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

12/425

Un langage de programmation

“Pourquoi utiliser un langage de programmation ?” ▸ Instructions CPU très simples ⇒ travail démesuré.▸ Instructions différentes entre CPU ⇒ pas de portabilité / compatibilité.

Un langage de programmation permet:▸ De fournir des constructions de “haut niveau” .

▸ D’automatiser la génération de nombreuses instructions élémentairespour ces constructions.▸ D’écrire un calcul de manière standard, (relativement) indépendante de

l’architecture cible.

Il “suffit” de traduire le programme pour l’exécuter.

▸ Soit avec un interpréteur : JavaScript, shell, Matlab, Perl . . .▸ Soit un compilateur : C, OCaml, Fortran . . .▸ Soit un peu des deux : Java, Python ...


http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

13/425

Le langage C

Des tonnes de langages de programmation !⇒ Choix d’un langage. . . C.Créé B. Kernighan, D. Ritchie et K. Thompson aux Bell Labs en 1972.Pourquoi C ?

▸ Très utilisé dans l’industrie malgré certains défauts/difficultés.▸ “Souple” (programmation haut et bas niveau).▸ Vous en ferez en IN102 et IN104.

Algorithmique, programmation ≡ langage.Langage = support, mots pour le dire.

Une mine d’infos: http://www.lysator.liu.se/c/


U C

http://www.lysator.liu.se/c/http://www.lysator.liu.se/c/http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

14/425

Un premier programme en C

aloha.c# i n c l u d e < s t d i o . h> /∗ Pour a cc éd er à p r i n t f . ∗/

i n t main ( ){

p r i n t f ( " Al oha c o us i n s ! \ n" ) ;r e t u r n ( 0 ) ;

}

La plus simple manière d’afficher en C “Aloha cousins !”

Équivalent à la commande shell> echo "Aloha cousins !"


U i C

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

15/425



i n t main ( ){


}

#include : Demander accès aux fonctions entrée/sortie (printf)./* ... */ : Commentaires.

▸ Ignorés par le langage.▸ Mais pas les lecteurs !▸

Servent à la documentation du code.▸ Documentez vos programmes !

Espaces non-significatifs mais indentez votre code !


U i C


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

16/425



i n t main ( ){


}

Fonction main : point d’entrée du programme.

Toujours automatiquement appelée en premier.

Un programme en C doit toujours contenir une fonction main.

Type int (entier) au début : type renvoyé par main.

Pour le main : toujours un entier.


U i C

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

17/425



i n t main ( ){


}

Fonction printf : affiche un message dans le terminal.

"Aloha cousins !\n" : chaîne de caractères (à afficher). \n : représente le caractère “retour à la ligne” .

; Point-virgule : fin d’instruction, marque la séquence.


U i C


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

18/425



i n t main ( ){


}

return : sortir d’une fonction en retournant la valeur qui suit.

return n’est pas une fonction mais une instruction.

Ici, la valeur de retour est 0, c’est 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 s’est exécuté normalement.▸ Convention: 0 ≡ “OK”.


Compilation et e éc tion d’ n programme

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

19/425

Compilation et exécution d un programme

Édition du source:▸ > emacs aloha.c &▸ emacs : Éditeur de texte, permet de taper le source.▸ “Human-readable” .▸ Vous pouvez utiliser n’importe quel éditeur (vi, vim, joe. . . )

Compilation:▸ gcc aloha.c ou gcc aloha.c -o first.x▸ gcc (compilateur) transforme le source en exécutable.▸ “Computer-readable” : compilateur ≡ traducteur.▸ Par défaut, nom de l’exécutable = “a.out”.▸ Option -o : permet de spécifier un nom d’exécutable.

Exécution:▸ ./a.out ou ./first.x▸ ... en fonction du nom de votre exécutable.▸ Exécute votre programme dans le répertoire courant.▸ “./” devant car le répertoire courant n’est pas dans le PATH.



8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

20/425

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

21/425

Quelques constructions élémentaires


Différentes “formes” de données


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

22/425

Différentes formes de données

En maths: entiers naturels, réels, rationnels, complexes . . .En logique: booléens {vrai , faux }En linguistique: caractères, mots (chaînes de caractères)

⇒ Besoin de types de données de base différents.“De base” ≡ primitifs, (± pour les chaînes) insécables.Ces types de données sont intrinsèquement différents:

▸ en terme de sémantique (sens),▸ en terme de représentation dans la machine.

3 (4) types de données de base: entiers, réels, (booléens), caractères.

. . . et les fonctions . . . un peu à part.


Les scalaires de base


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

23/425

Les scalaires de base

Les entiers: type int.

Les réels: type float ou double.

Vue simplifiée: on y reviendra plus tard.


La mémoire

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

24/425

La mémoire

Avant d’être exécuté, le programme est chargé en mémoire.Un “pointeur” indique où en est l’exécution.

À chaque instruction il avance d’une “case” .

Il y a parfois des sauts (appels de fonctions, tests, boucles. . . ).

Pendant l’exécution, le programme peut aussi réserver de la mémoire:▸ Déclaration (création) de variables, réceptacles d’information.▸ À chaque variable correspond une “case mémoire” .

2 zones mémoire différentes:▸ La pile: variables “locales” (temporairement accessibles).▸ Le tas: variables “globales” (durée de vie arbitraire).


Nécessité de typage

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

25/425

Nécessité de typage

Mémoire: contient de l’information codée en binaire.

Nous avons vu quelques formes de données.

⇒ un octet en mémoire peut avoir différentes significations.L’octet 01010111 peut représenter:

▸ l’entier 87 (= 64 + 16 + 4 + 2 + 1),▸ le flottant 4.85 ⋅10−270,▸ (le caractère ’W’),▸ une instruction en langage machine,▸ une adresse mémoire, etc . . .

Il faut associer un type à chaque case mémoire, chaque variable !

C’est son type (lors de la déclaration) qui va définir sa significationréelle.


Déclaration et initialisation de variable (1)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

26/425


i n t main ( ){

f l o a t c ;i n t i , j = 42 ;

d o u b l e b ;b = 0. 00 34 5 ;c = 3 .1 41 5 9 ;

}

On déclare une variable en donnant son type suivide son nom.

Cela réserve une case mémoire contenant a priori une valeur aléatoire.

L’initialisation fixe sa valeur.Cela peut se faire dès la déclaration, ou après.

Le tout c’est de ne pas lire dans une variable avant son initialisation !

Sa valeur est “ce qu’il y avait dans la mémoire”.

Ça n’a aucun sens de l’utiliser, c’est un oubli, une erreur.



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

27/425


i n t main ( ){

f l o a t c ;i n t i , j = 42 ;d o u b l e b ;b = 0. 00 34 5 ;c = 3 .1 41 5 9 ;

}

Avec ce code, la mémoire ressemble à:


Expressions (de base) du langage

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

28/425

Expressions (de base) du langage

Une expression est quelque chose qui “a une valeur” .

Opposition à une instruction (slides suivants) qui “fait” .

À partir d’expressions de base, on combine les expressions.Expressions de base: les variables et les littéraux.

▸ Variables: toute variable déclarée et de portée accessible.▸ Entiers: 4 −5▸ Booléens: true false (. . . et les entiers !)▸ Caractères: ’U’ ’n’▸ Flottants: −4.6 5e-12▸ Chaînes: "plop" "\tGlop\n"


Composition d’expressions

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

29/425

p p

Arithmétique: entre entiers et/ou flottants.▸ +, −, /, ∗ avec leur sens “habituel”, % (modulo)▸ Ex: 4 − (5 ∗ 7)

Relationnel (“tests”): entre expressions de même type.▸ Rem: conversions implicite entre scalaires (entiers, flottants, caractères

et booléens).▸ == (égalité), < (inférieur à), >, =.▸ Ex: y

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

30/425

g g

Une instruction est quelque chose qui “fait” une action, sans valoirquelque chose.

Opposition à une expression qui vaut une valeur.Plusieurs (nombreuses) formes d’instructions.


L’affectation

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

31/425

Dénotée par le signe = (à ne pas confondre avec ==).

Donne une valeur à une variable.Attention matheux !

▸ Variable “mathématique” ≠ variable “informatique”.▸ En maths, variable ≡ inconnue.

▸ En info, variable ≡ réceptacle d’information.▸ En info, une variable a toujours une valeur . . . même incohérente.

v = 15 ; stocke 15 dans la variable v.

15 = v ; n’a aucun sens.

À gauche du =: case mémoire (variable, case de tableau. . . ).À droite du =: expression dont la valeur va être stockée.


L’affectation

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

32/425

Besoin de “compatibilité” entre type de la case mémoire et type de lavaleur à stocker !

Si les types sont les mêmes, aucun problème.Si les types sont compatibles, transformation implicite:

▸

Entier ↤

entier avec signe et/ou taille différents,▸ Flottant ↤ entier,▸ Entier ↤ caractère.

. . . mais attention aux problèmes de précision et débordement !

Et sinon, les types n’ont rien à voir (ex: tableau à la place d’un

entier): erreur de typage par le compilateur.


Instructions d’affectation-arithmétique abrégée

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

33/425

Il existe des versions courtes des opérations “courantes” :

i n t i = 0 ;

i++ ; // i = i + 1 ;i −− ; // i = i − 1 ;i += 3 ; // i = i + 3 ;i −= 3 ; // i = i − 3 ;i ∗= 3 ; // i = i ∗ 3 ;i / = 3 ; // i = i / 3 ;i %= 3 ; // i = i % 3 ;i |= 3 ; // i = i | 3 ;i &= 3 ; // i = i & 3 ;

i ^= 3 ; // i = i ^ 3 ;


Exécution conditionnelle

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

34/425

Besoin d’effectuer un traitement ...ou pas ...ou un autre.

Notion de condition (expression booléenne).

Condition toujours entre parenthèses !if (expression) { instruction(s ) ; }:

▸ instruction

(s

) exécutée(s) si expression renvoie ≠ 0

instruction(s) exécutée(s) si expression renvoie ≠ 0.if (expression) { instruction1(s ) ; } else { instruction2(s ) ; }:

▸ instruction1(s ) exécutée(s) si expression renvoie ≠ 0▸ sinon, instruction2(s ) exécutée(s).

Remarquez la construction { ... }: groupement de plusieursinstructions: “bloc” .


Exécution conditionnelle: petit exemple

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

35/425

i n t x ;. . .i f ( x == 0) p r i n t f ( " x e s t n ul . \ n" ) ;i f ( x > 0) { p r i n t f ( " x e s t p o s i t i f . \ n" ) ; }e l s e {

i f ( ( x −5) )p r i n t f ( "x e s t n é g a t i f e n t re ] −5 ; −3 ] ou n ul . \ 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 négatif hors ]-5;-3] ou nul."

x = 0⇒"x est nul.""x est négatif hors ]-5;-3] ou nul."

x = −4⇒"x est négatif entre ]-5;-3] ou nul."


http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

36/425

Approfondissement des types de base de C



Les entiers (naturels et relatifs)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

37/425

Plusieurs tailles.Signés ou non.

Par défaut: un entier est signé.Ex: 0 -3 +0 15657

Taille Valeur(bits) Min Max

short 16 -32768 32767unsigned short 16 0 65535

int 32 −231 231 − 1unsigned int 32 0 232 − 1

long 32 ou 64 dépend de l’architectureunsigned long 32 ou 64 dépend de l’architecturelong long 64 −263 263 − 1

unsigned long long 64 0 264 − 1



Codage des entiers

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

38/425

Entiers codés en binaire: base 2.

▸ 421 ↦ 0000000110100101 (sur 16 bits)▸ = 28 + 27 + 25 + 22 + 20

Base 2 :▸ Pratique au niveau électronique mais encombrant !▸ ⇒ On préfère la base 16 (hexadécimal).

▸ 0000 0001 1010 01010x 0 1 A 5

Pour avoir des entiers signés: complément à 2.▸ Inverser les bits de l’écriture binaire de sa valeur absolue,▸ puis ajouter 1 au résultat.▸ Calcule 2l − x où l est la longueur de représentation d’un entier.▸ ⇒ 1 seule représentation de 0.▸ ⇒ + et − identiques sur signés / non-signés, positifs / négatifs.



Débordement d’entiers

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

39/425

Arithmétique modulo la taille des mots machine.

Pour les exemples suivants, taille = 4 bits.⇒ Perte de plein de “bonnes” propriétés mathématiques ▸ Débordement de non signé: 9 + 7 = 16 ?

1001 + 0111 = 10000 = sur 4 bits . . . 0000 = 0▸ Débordement 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 → 01 * 4 = 4 En entiers . . . 4. Donc, / 4, → 1



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

40/425

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

41/425

Des réels différents égaux. . .

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

42/425

thiskillsme.c# i n c l u d e < s t d i o . h>

i n t m a i n ( ){

f l o a t f l 1 = 4 84 31 .1 23 1 ;f l o a t f l 2 = 4 84 31 .1 23 9 ;f l o a t f l 3 = 4 84 31 .1 25 0 ;

p r i n t f ( " f l 1 : %f f l 2 : %f f l 3 : %f \ n " , f l 1 , f l 2 , f l 3 ) ;p r i n t f ( " f l 1 == f l 2 ? %d \n " , ( f l 1 == f l 2 ) ) ;

p r i n t f ( " f l 2 == f l 3 ? %d \n " , ( f l 2 == f l 3 ) ) ;p r i n t f ( " f l 1 == f l 3 ? %d \n " , ( f l 1 == f l 3 ) ) ;f l 1 = f l 1 + 0 .0 0 0 1 ;p r i n t f ( " f l 1 + 0 . 00 0 1 : %f \ n" , f l 1 ) ;r e t u r n ( 0 ) ;

}

> ./thiskillsme

fl1: 48431.125000 fl2: 48431.125000 fl3: 48431.125000fl1 == fl2 ? 1

fl2 == fl3 ? 1

fl1 == fl3 ? 1

fl1 + 0.0001: 48431.125000



. . . et des réels égaux différents

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

43/425

thiskillsmeagain.c# i n c l u d e < s t d i o . h># i n c l u d e # d e f i n e EPSILON (1 e −6) // Tout p e t i t e p s i l o n . . .

i n t m a i n ( ){

d o u b l e f l 1 = 0 . 1 ;d o u b l e f l 2 = 0 . 2 ;d o u b l e f l 3 = 0 . 3 ;d o u b l e f l 4 = f l 1 + f l 2 ;

p r i n t f ( " 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 ) ;p r i n t f ( " f l 3 = f l 4 ? %d \ n " , ( f l 3 == f l 4 ) ) ;p r i n t f ( " f l 3 ~ f l 4 ? %d \ n " , ( f a b s ( f l 3 − f l 4 ) < EPSILON) ) ;r e t u r n ( 0 ) ;

}

> ./thiskillsmeagainfl1: 0.100000 fl2: 0.200000 fl3: 0.300000 fl4: 0.300000

fl3 = fl4 ? 0

fl3 ~ fl4 ? 1



Les booléens

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

44/425

Valeurs dans l’ensemble { vrai ; faux }Valeurs logiques booléennes.En fait, comme une valeur entière avec:

▸ 0 ≡ false▸ Tout sauf 0 ≡ true

On peut donc tester une valeur entière comme un booléen.

Tirage aléatoire dans cet ensemble “booléen” non équiprobable !Fichier d’entête #include “pseudo-définit” les booléens:

▸ Type bool (alias de int)▸ Constante true (=1) et false (= 0).



Les chaînes de caractères

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

45/425

Ce sont en fait des “tableaux” de caractères.

Intuition : suite contigue de caractères terminée par le caractère ’\0’.

Caractère: type prédéfini char. Par ex: ’a’.

Chaîne: moyen facile d’écrire des morceaux de texte. Ex: "Eat at Joe’s .’’

Fichier d’entête requis: #include

Peuvent être copiées: fonction strcpy (dest , source ).Longueur d’une chaîne: fonction strlen

(chaine

).

ATTENTION: ne compte pas le ’\0’ final !



Quelques formes particulières de caractères

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

46/425

Utilisables en tant que caractères individuels ou dans des chaînes.▸ ’\n’ : Retour à la ligne.▸ ’\\’ : Le caractère \.▸ ’\” : Le caractère ’.▸ ’\"’ : Le caractère ".▸ ’\t’ : La tabulation.

▸ ’\x’ ••: Le caractère dont le code en hexadécimal suit.▸ ’\’ •••: Le caractère dont le code en octal suit.▸ . . . et quelques autres que l’on passe sous silence.

Ex: printf ("foo\n\"\’bar\\\x65\046");

foo

"’bar\e&



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

47/425

Plus de constructions



Répéter, toujours répéter. . .

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

48/425

Informellement, certains traitements parfois spécifiés par:▸

Faire un traitement T ,▸ Puis si une condition C est vérifiée s’arrêter,▸ Sinon recommencer le traitement T .

Notion de “répétition”.

Exemple: cos

(x

)= 1 − x

2

2! +x 4

4! −x 6

6! + . . .

Et d’ailleurs ... n! = 1 ∗ 2 ∗ . . . ∗ nNécessité de préciser comment mener la répétition:

▸ Nombre de fois connu à l’avance ?▸ Condition C doit être testée avant le 1er traitement T ?▸

Condition C

doit être testée après le 1

er

traitement T

?⇒ Plusieurs schémas d’itération.⇒ Plusieurs constructions de boucles.



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

49/425

La boucle for dégénérée

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

50/425

Possibilité d’omettre des parties de la construction.

Initialisation, condition, post-traitement, voire corps !Poussé à l’extrême: formes étranges voire illisibles . À é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++ ;}



“Tant que” . . . faire: la boucle while

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

51/425

while (expression) { instruction(s ) }Sémantique:

1 Si expression s’évalue en true1.1 Exécuter instruction(s ).1.2 Retourner en 1.

Ex: U n+1 = U n2 Si U n est pair3 ∗ U n + 1 Sinonsyracuse.c

i n t main ( ){

i n t x = 134560 ;w h i l e ( x != 1 ) { // R ép é t e r t an t que x e s t d i f f é r e n t de 1 .

i f ( x % 2 == 0 ) // S i x e s t p a i r .

x = x / 2 ; // On l e d i v i s e p ar 2 .e l s e x = 3 ∗ x + 1 ;

}r e t u r n ( 0 ) ;

}



Équivalence entre boucles for et while

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

52/425

Remplacement de for en while:

f o r ( i n i t ; t e s t ; p o s t l u d e ) {i n s t r u c t i o n ( s ) ;

}

i n i t ;w h i l e ( t e s t ) {

i n s t r u c t i o n ( s ) ;p o s t l u d e ;

}

Remplacement de while en for:

w h i l e ( t e s t ) {i n s t r u c t i o n ( s ) ;

}

f o r ( ; t e s t ; ) {i n s t r u c t i o n ( s ) ;

}



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

53/425

En résumé des boucles

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

54/425



Construction conditionnelle “généralisée” (1)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

55/425

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" ) ;e l s e {



i f . . . e l s e . . . i f . . . e l s e . . .. . . p r i n t f ( " A u t r e c a s \n" ) ;

} } . . . }}

}}

Pas franchement pratique ni lisible



Construction conditionnelle “généralisée” (2)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

56/425

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 valeurde expression alors exécutées.

Fin de chaque cas par break ;Cas “autre” , par défaut: default.

. . .s w i t c h ( x ) {

c a s e 0 : p r i n t f ( "x : 0\ n" ) ; b r e a k ;c a s e 1 : p r i n t f ( "x : 1\ n" ) ; b r e a k ;c a s e 4 : p r i n t f ( "x : 4\ n" ) ; b r e a k ;d e f a u l t : p r i n t f ( " Au t r e c a s \n" ) ; b r e a k ;

}



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

57/425

Quelques utilitaires de C



Les entrées/sorties (“I/Os” ) élémentaires

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

58/425

Communication avec “l’extérieur” : clavier, écran, fichiers. . .

Lecture (Input), écriture (Output).

Écriture à l’écran: printf.Lecture au clavier: scanf.



Sortie à l’écran printf (1)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

59/425

Nécessite: #include printf ("Aloha cousins\n") ;

printf ("%d = %d + %d\n", x + y, x, y);Format= chaîne de caractères contenant (ou pas) des séquences %.

%d un int%ld un long int en décimal

%u un unsigned int en décimal%x un int en hexadécimal%f un float%lf un double%e un double en notation scientifique

%.7lf un double avec 7 chiffres après la virgule%07d un int en décimal sur 7 digits (padding frontal avec des 0)% 7d un int en décimal sur 7 digits (padding frontal avec des ’ ’)%c un char (comme caractère ASCII, pas comme entier)



Sortie à l’écran avec printf (2)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

60/425

# i n c l u d e < s t d i o . h>

i n t main ( ){

p r i n t f ( "%d\ n" , 4 2) ;p r i n t f ( "%l d \ n" , 42 ) ;

p r i n t f ( "%u\ n" , 4 2) ;p r i n t f ( "%x \n" , 4 2) ;p r i n t f ( "%f \ n" , 4 2 .0 ) ;p r i n t f ( "%e \n" , 4 2 . 0) ;p r i n t f ( "%.7 f \n" , 4 2 . 0 ) ;p r i n t f ( "%07d \n " , 4 2) ;p r i n t f ( "% 7d\n" , 42 ) ;

p r i n t f ( "%c \n" , 4 2) ;r e t u r n ( 0 ) ;

}

42

42

422a

42.000000

4.200000e+01

42.0000000

0000042

42

*



Entrée au clavier avec scanf (1)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

61/425

Nécessite: #include

Lecture au clavier selon le format spécifié (séquences %).Saisie pas en accord avec ce qu’attend le format: imprévisible.

Format avec uniquement des % (pas de “message” ).

input.c# i n c l u d e < s t d i o . h>

i n t main ( ){

i n t i , j ;s c a n f ( "%d %d " , &i , & j ) ;

p r i n t f ( " i = %d , j = %d\n" , i , j ) ;r e t u r n ( 0 ) ;

}

mymac:/tmp$ gcc input.c -o input

mymac:/tmp$ ./input45 67

i = 4 5 , j = 6 7

mymac:/tmp$ ./input

5

FHG

i = 5, j = 0

mymac:/tmp$ ./input

DFG 6

i = 0, j = 0



Entrée au clavier avec scanf (2)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

62/425

scanf ("%d", & i ) ;

Pour le moment, & reste un peu “magique”.

Sera approfondi ultérieurement.

Idée: “à mettre devant une variable pour permettre sa modification parscanf”.

Rem: lecture de chaînes de caractères (%s) nécessite quelquesexplications ultérieures. On vivra sans pour le moment.



Constantes, macros et préprocesseur

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

63/425

Définir des constantes littérales dans le source: pas maintenable !

Nécessité de changer partout la valeur.

⇒ Utilisation de macros.# d e f i n e SI ZE ( 4 2 ). . .i n t i = SIZE ;i f ( j < SIZE ) . . .

Remplacement textuel avant compilation par le préprocesseur C (cpp).Mieux vaut parenthéser:

# d e f i n e SIZE 42 + 1. . .i n t i = SIZE ∗ 10 ;

→ i = 52 et non 430 !

Possibilité de macros “paramétrées”: #define TWICE(x)((x)∗ (x))



Alias de types

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

64/425

Vous en avez assez de taper unsigned long int ?

⇒ Définissez un alias.

typedef unsigned long int uli_t ; uli_t: nom, abréviation de unsigned long int. Utilisable ensuite comme nom de type: uli_t i = 42 ;

Ne définit pas un nouveau type !

De manière générale: typedef

Fonctionnera avec les types que nous verrons plus tard.



Les fonctions (1)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

65/425

Vus jusqu’à présent: expressions (arithmétiques, logiques), affectation,séquence et boucles.

Permet déjà d’effectuer des calculs.Parfois, besoin:

▸ D’effectuer le même calcul à plusieurs endroits⇒ Pas envie de répéter les instructions.

▸ D’effectuer un calcul en “instanciant” des inconnues de différentesmanières.

Par exemple: calcul de cosinus en invoquant 2 fois l’exponentielle:

mycos (x )↦

e ix

+e −ix

2



Les fonctions (2)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

66/425

C’est typiquement la notion de fonction mathématique:▸ Soit A et B 2 ensembles.▸ Fonction f définie sur A à valeur dans B : correspondance qui ∀x ∈ A

associe au plus (fonction partielle) 1 élément de B .▸ A: domaine.▸ B : codomaine.

Autrement dit:▸ Prend 1 (ou des) argument(s).▸ Retourne 1 valeur.

D’où, une fonction est définie par:▸ le type de la valeur qu’elle retourne,▸ son nom,▸ les types des paramètres qu’elle attend,▸ et son corps: la description du calcul qu’elle effectue, spécification

exécutable.



Les fonctions (3): exemples

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

67/425

i n t t w i ce ( i n t i ){

r e t u r n ( i ∗ 2 ) ; // C o r p s : r e t o u r n e b i en un i n t .}

f l o a t s q u ar e _ mi n us (

f l o a t x ,

f l o a t y ){

f l o a t t = ( x − y ) ; /∗ V a r i a b l e l o c a l e . ∗/ r e t u r n ( t ∗ t ) ;

}



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

68/425

Les fonctions (5): remarques pour puristes

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

69/425

Fonctions en C légèrement différentes du modèle théorique du calcul(λ-calcul).λ-calcul:

▸ Fonction à n arguments = fonction à 1 argument retournant unefonction à n − 1 argument(s).

▸ ⇒ Les fonctions sont de valeurs.▸ Pas de fonction à 0 argument: paramètre de type trivial (void, unit)

habité par 1 seule valeur.▸ Supprime la différence artificielle entre “fonction” , “procédure” et “arité”

(nb d’arguments).▸

Cas des langages fonctionnels (OCaml, Haskell, LISP. . . )



http://goforward/http://find/http://goback/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

70/425

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

71/425

Déclaration / prototype (1)

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

72/425

Utilisation d’une fonction en dehors de son fichier hôte ⇒ son typedoit être connu.

Donner juste le type: déclaration (et non définition).

Rend visible par toute personne ayant accès à cette déclaration.

Règle valable pour les autres types de variables, d’ailleurs.Prototype d’une entité: son nom + son type.Déclaration:

▸ Faite au “toplevel” d’un fichier d’entête (.h).▸ Utilisée via les directives #include.



Déclaration / prototype (2)

Pour une fonction:

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

73/425

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 définition de variable !),▸ son type,

▸ son nom.

/∗ D é c l a r a t i o n d ’ u ne v a r i a b l e ( g l o b a l e ) e n t i è r e . ∗/ e xt er n i n t e rr no ;/∗ 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 nt e ( d e y / x ) . ∗/ f l o a t a ta n2 ( f l o a t y , f l o a t x ) ;

Indique “comment” utiliser la fonction.

...Mais pas ce qu’elle fait.



Quelques fonctions déjà vues

printf: affichage à l’écran

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

74/425

printf: affichage à l écran▸ Prototype un peu bizarre car nombre et types des arguments variables.

▸ void printf (const char ∗ restrict format, ...) ; main : LA fonction point d’entrée de tout programme

▸ int main () ;☀ Retourne un entier: le code de retour du programme.☀ Ne prend pas d’argument.

▸ int main (int argc, char ∗argv []) ;☀ Forme alternative: arguments en provenance de la ligne de commande.☀ argc : nombre d’entrées dans argv.☀ argv: tableau (plus de détails plus tard) de chaînes de caractères.☀ 1er élément: nom du programme.☀ Éléments suivants: arguments effectifs.☀ Ex: > ./myprog 1 hop 4

⇒ argv = 0 1 2 3

”myprog ” ”1” ”hop ” ”4”



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

75/425

La récursivité



La récursivité: une autre façon d’itérer

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

76/425

Soit la fonction “factorielle”.

▸ Spécification par abstraction: n! =∏ni =1 i ▸ Spécification par récurrence: Fact n = 1 Si n = 0n ∗ Fact n−1 Sinon

Idée: problème P de la forme

⇒ Traitement T sur P :▸

Traiter “la partie orange”.▸ Traiter ce qui reste. . . qui est un problème de la même forme que P .



La récursivité (2)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

77/425

Une fonction qui s’appelle elle-même est dite récursive.

Ex: recherche d’un fichier sur un disque.

booléen existe_fichier (nom, répertoire)

{

liste fs = noms_de_fichier (répertoire) ;

si (name est dans fs) retourner (vrai) ;

sinon {liste srs = sous_répertoires (répertoire) ;

pour chaque r dans srs {

si (existe_fichier (nom, r)) retourner (vrai) ;

// Sinon, implicitement continuer le pour-chaque.

}

}

retourner (faux) ;}



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

78/425

Exemple: factorielle

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

79/425

1 i n t f a c t ( i n t n )2 {3 i f (n

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

80/425

1

fact (4)

4 * fact (3)

3 * fact (2)

2 * fact (1)

1 * fact (0)



Exemple: factorielle - Déroulement du calcul (2)

24

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

81/425

fact (4)

4 * fact (3)

3 * fact (2)

2 * fact (1)

1 * fact (0)

1

1

1 * 1

2 * (1 * 1)

3 * (2 * (1 * 1))

4 * (3 * (2 * (1 * 1)))



Pour résoudre notre problème de factorielle. . .

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

82/425

On a trouvé au moins un cas où la solution est connue: 0!

On a tenté de ramener le problème posé pour n quelconque au mêmeproblème...

. . . Mais posé sur une valeur plus simple (plus “proche” du cas connu).

On a raisonné par récurrence pour obtenir une définition récursive.Principe de récurrence. Soit P une propriété sur N:

▸ Si P (0) est vérifiée,▸ si de l’hypothèse “P (n) est vérifié” on peut déduire que P (n + 1) est

vérifiée,▸

alors ∀

m∈ N,

P (m) est vérifiée.



Exemple: élévation à la puissance


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

83/425

Spécification récursive:

x n = x ∗ x n−1x 0 = 1

À chaque appel récursif, l’exposant n décroit

⇒ il converge vers 0 et la fonction power termine bien.

d o u b l e p ow er ( d o u b l e x , u ns ig ne 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 ) ) ;

}



Exemple: puissance - Déroulement du calcul (1)


8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

84/425

power (a, 4)

1

a * power (a, 3)

a * power (a, 2)

a * power (a, 1)

a * power (a, 0)


François Pessaux [email protected] ENSTA 80/1

Exemple: puissance - Déroulement du calcul (2)

a* a * a* a

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

85/425

1

a * power (a, 3)

a * power (a, 2)

a * power (a, 1)

a * power (a, 0)

power (a, 4)

1

a

a * a

a * a * a

a* a * a* a



Exemple: élévation à la puissance - “square & multiply”

Spécification récursive:

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

86/425

⎧⎪⎪⎪⎨⎪⎪⎪⎩x

2n= x

n

∗ x n

x 2n+1 = x ∗ x 2n

x 1 = x .

d o u b l e power_sm ( d o u b l e x , u n si gn ed 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 ) ) ;}



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

87/425

Ex: “square & multiply” - Déroulement du calcul (2)

a * a * a 2( )2

( )

2

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

88/425

2( )2

a * a 2

a * a 2( )2

( )

2

a * a 2( )2

( )

2

( )( )

power (a, 6) ^ 2

power (a, 3) ^ 2

power (a, 2) ^ 2

power (a, 13)

a * power (a, 12)

power (a, 1) ^ 2

a

a2

a

a *

a * a


François Pessaux francois pessaux@ensta-paristech fr ENSTA 84/1

Appels récursifs multiples

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

89/425

Suite de Fibonacci: F n = F n−1 + F n−2 et F 0 = 0,

F 1 = 1Une fonction récursive peut faire plusieurs appels récursifs.

Exemple: suite récurrente double, algorithmes de tri (c.f. plus tard).Déroulement comme des appels de fonction “normaux” :

▸

Entrer dans le premier appel récursif.▸ Ce dernier va lui-même effectuer ses appels internes.▸ Quand premier appel terminé, on passe au second.

Attention: pas de notion de parallélisme !

Les appels ne sont pas exécutés en “même temps”.



Appels récursifs multiples: déroulement

F n = F n−1 + F n−2 et F 0 = 0, F 1 = 1

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

90/425

fib(4) ;

fib(3) ;

fib(2) ;



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

91/425

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

92/425

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

93/425


F n = F n−1 + F n−2 et F 0 = 0, F 1 = 1

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

94/425

0

fib(4) ;

fib(3) ;

fib(2) ;

fib(2) ;

fib(0) ;

fib(1) ;

fib(1) ;

1

1


François Pessaux francois pessaux@ensta paristech fr ENSTA 90/1


F n = F n−1 + F n−2 et F 0 = 0, F 1 = 1

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

95/425

1

fib(4) ;

fib(3) ;

fib(2) ;

fib(2) ;

fib(0) ;

fib(1) ;

fib(1) ;

2

1

1

0




F n = F n−1 + F n−2 et F 0 = 0, F 1 = 1

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

96/425

1

fib(4) ;

fib(3) ;

fib(2) ;

fib(2) ;

fib(1) ;

fib(0) ;

fib(0) ;

fib(1) ;

fib(1) ;

2

1

1

0

1

0




F n = F n−1 + F n−2 et F 0 = 0, F 1 = 1

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

97/425

1fib(4) ;

fib(3) ;

fib(2) ;

fib(2) ;

fib(1) ;

fib(0) ;

fib(0) ;

fib(1) ;

fib(1) ;

3

2

1

1

0

1

0

1


F ançois Pessa [email protected]

ENSTA 93/1

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

98/425

Fonctions mutuellement récursivesPlusieurs fonctions s’appelant mutuellement.Pas d’ordre (ni partiel, ni total) de précédence de définition.

f d fi “ ”

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

99/425

Sont en fait définies “en même” temps.En C, (comme dans beaucoup de langages): toutes les fonctions sontimplicitement mutuellement récursives (si besoin).

# i n c l u d e < s t d b o o l . h>

b oo l n at ur al _ ev en ( u ns ig ne d i n t n ){i f ( n == 0) r e t u r n ( t r u e ) ;e l s e r e t u r n ( n a t ur a l _ od d ( n − 1) ) ;

}

b o ol n at ur al _o dd ( u ns ig ne d i n t n )

{i f ( n == 0) r e t u r n ( f a l s e ) ;e l s e r e t u r n ( n a t ur a l _ e ve n ( n − 1 ) ) ;

}


F i P [email protected]

ENSTA 95/1

“Récursion, boucles, ça se termine quand ?”

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

100/425

Pour obtenir un résultat, un calcul doit terminer.

Boucle avec condition d’arrêt toujours fausse ⇒ boucle “infinie”.

Récursion avec cas de base (≡ condition d’arrêt) jamais atteint ⇒récursion “infinie”.

Dans ces cas . . . on peut attendre longtemps.

La terminaison est une propriété très importante.



Le problème de l’arrêt

Un programme pour déterminer l’arrêt de programmes ?

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

101/425

p g p p g

Halt (prog , data) = Vrai Si prog avec les données data s’arrêteFaux SinonUn programme:

Hic (prog ) = Boucler si Halt (prog, prog) = VraiTerminer sinon

Hic (Hic ) → ?Termine si Hic ne termine pas et ne termine pas si Hic termine

Dans les 2 cas: contradiction → hypothèse initiale fausse.

Impossibilité de programmer un prédicat de test d’arrêt: problèmeindécidable.



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

102/425

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

103/425

Appel(s) de fonction(s)



Déroulement d’un appel de fonction

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

104/425

Illustration sur le calcul de la racine carrée d’un réel a.

Méthode itérative de Newton.√ a donnée par x n+1 = 12(x n + ax n )

n: Nombre d’itérations (à fixer arbitrairement).x 0 > 0 : Point de départ (à fixer arbitrairement).



Protocole d’appel

A l f i ’

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

105/425

Appeler une fonction c’est:▸ stocker la valeur de ses paramètres,▸ aller exécuter son code,▸ et en revenir avec le résultat.

Différentes conventions d’appel selon les langages, les architectures.

Principe restant majoritairement le même: utilisation de la pile.Différences dans “qui (appelant/appelé) fait quoi”.

Différences dans l’agencement mémoire d’informations (registres vspile).



Protocole d’appel de manière générique

Côté appelant:▸ Évaluation des arguments à passer → mis sur la

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

106/425

g p

pile.▸ Adresse de retour mise sur la pile.

Côté appelé:▸ Réservation des variables locales sur la pile.▸ Exécution du code.

▸ Stockage de la valeur à retourner (en registre oupile).

▸ Aller . . . à l’adresse de retour.

Côté appelant:▸ Récupérer la valeur retournée par l’appelé.▸ Supprimer de la pile les arguments passés lors de

l’appel.

1

var locale

arg

arg

...

var locale

@ retour

C r o i s s a n c e d e l a p i l e

var locale

... A

p p e l é

A p p e l a n t

m

1

2

arg n

2



Déroulement d’un appel de fonction1 # d e f i n e X 0 ( 3 . 0 ) // Germe : q u e l c o n q ue > 0 2

3 d o u b l e s q ur ( d o u b l e a , i n t m a x _ i t e r ) {i t i

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

107/425

Pile

nb_iters 15

???

2.0

res

v m a i n

4 i n t i ;5 d o u b l e xn = X0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 r e t u r n ( xn ) ;9 }

10

11 i n t main

( ) {12 int nb_iters = 15 ;13 double res, v = 2.0 ;14 r e s = s qu r ( v , n b_ i t e rs ) ;15 p r i n t f ( " s q r t (% f ) = %f \ n" , v , r e s ) ;16 r e t u r n ( 0 ) ;17 }

Définition et initialisation des variables locales de main




3 d o u b l e s q ur ( d o u b l e a , i n t m a x _ i t e r ) {4 i n t i ;

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

108/425

Pile

nb_iters 15

???

2.0

res

v m a i n

a 2.0

15max_iter

ligne 14 s q ur

4 i n t i ;5 d o u b l e xn = X0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 r e t u r n ( xn ) ;9 }

10

11 i n t main ( ) {12 i n t n b_ i te r s = 15 ;13 d o u b l e r e s , v = 2. 0 ;14 r e s = squr (v, nb_iters) ;15 p r i n t f ( " s q r t (% f ) = %f \ n" , v , r e s ) ;16 r e t u r n ( 0 ) ;17 }

Appel de la fonction squr




3 d o u b l e s q ur ( d o u b l e a , i n t m a x _ i t e r ) {4 int i ;

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

109/425

Pile

nb_iters 15

???

2.0

res

v m a i n

a 2.0

15max_iter

ligne 14 s q ur

i

xn

???

3.0

4 int i ;5 double xn = x0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 r e t u r n ( xn ) ;9 }

10

11 i n t main ( ) {12 i n t n b_ i te r s = 15 ;13 d o u b l e r e s , v = 2. 0 ;14 r e s = s qu r ( v , n b_ i t e rs ) ;15 p r i n t f ( " s q r t (% f ) = %f \ n" , v , r e s ) ;16 r e t u r n ( 0 ) ;17 }

Définition et initialisation des variables locales de squr




Pil

1 # d e f i n e X 0 ( 3 . 0 ) // Germe : q u e l c o n q ue > 0 2


http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

110/425

Pile

nb_iters 15

???

2.0

res

v m a i n

a 2.0

15max_iter

ligne 14 s q ur

i

xn 1.414998

2

4 i n t i ;

5 d o u b l e x n = x0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0.5 * (xn + (a / xn)) ;8 r e t u r n ( xn ) ;9 }

10


Itérations de la boucle (ici i = 2, xn = 1.41499)




Pil



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

111/425

Pile

nb_iters 15

???

2.0

res

v m a i n

a 2.0

15max_iter

ligne 14 s q ur

i

xn 1.414214

15

4 i n t i ;5 d o u b l e x n = x0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 return (xn) ;9 }

10


Sortie de la boucle, prêt à retourner de la fonction squr




Pile



d o u b l e

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

112/425

nb_iters 15

???2.0

resv m

a i n

a 2.0

15max_iter

ligne 14 s q ur

5 d o u b l e

x n = x0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 r e t u r n ( xn ) ;9 }

10

11 i n t main ( ) {

12 i n t n b_ i te r s = 15 ;13 d o u b l e r e s , v = 2. 0 ;14 r e s = s qu r ( v , n b_ i t e rs ) ;15 p r i n t f ( " s q r t (% f ) = %f \ n" , v , r e s ) ;16 r e t u r n ( 0 ) ;17 }

Retour de la fonction: suppression des variables locales, retourner àl’adresse spécifiée sur la pile




Pile



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

113/425

Pile

nb_iters 15

1.414214

2.0

res

v m a i n

5 d o u b l e x n = x0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 r e t u r n ( xn ) ;9 }

10

11 i n t main ( ) {12 i n t n b_ i te r s = 15 ;13 d o u b l e r e s , v = 2. 0 ;14 res = s q ur ( v , n b _i t e rs ) ;15 p r i n t f ( " s q r t (% f ) = %f \ n" , v , r e s ) ;16 r e t u r n ( 0 ) ;17 }

Affectation de la valeur de retour de la fonction squr




Pile



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

114/425

Pile

nb_iters 15

1.414214

2.0

res

v m a i n

"sqrt (%f)..."

1.414214

2.0

format

arg[1]

arg[2]

ligne 15

pr i n t f

5 d o u b l e x n = x0 ;6 f o r ( i = 0 ; i < m ax _i te r ; i ++)7 xn = 0 . 5 ∗ ( xn + ( a / xn ) ) ;8 r e t u r n ( xn ) ;9 }

10

11 i n t main ( ) {12 i n t n b_ i te r s = 15 ;13 d o u b l e r e s , v = 2. 0 ;14 r e s = s qu r ( v , n b_ i t e rs ) ;15 printf ("sqrt (%f) = %f\n", v, res) ;16 r e t u r n ( 0 ) ;17 }

Appel à la fonction printf . . . etc . . .



Appels de fonctions récursives

Rappel: une fonction récursive se rappelle elle-même.

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

115/425

Principe d’appel identique à ce que l’on vient de voir.▸ À chaque appel on empile les informations nécessaires.▸ Lorsque l’on sort d’un appel, on dépile.

⇒ La pile augmente avec la profondeur de récursion.

En cas de récursion trop profonde, possibilité de dépassement de pile

(“stack overflow” ).Pour autant la récursivité n’est pas à banir !

▸ Permet d’exprimer simplement et élégamment certains algorithmes.▸ Incontournable pour certains problèmes (sinon, obligation de se gérer

manuellement une pile en fait).▸ Les compilateurs savent dé-récursiver la récursion terminale !



Déroulement d’appels de fonction récursive

Pile1 unsigned int fact (unsigned int n)2 {

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

116/425

f a c t

i 4

4

ligne 10

n m a i n

f a c t

ligne 4

3n

n 2

n

ligne 4

1

ligne 4

f a c t

f a

c t

f a c t

ligne 4

n 0

3 i f (n == 0 ) r e t u r n ( 1 ) ;4 e l s e r e t u r n ( n ∗ f a c t ( n − 1 ) ) ;5 }6

7 i n t main ( )8 {9 u ns ig ne d i n t i = 5 ;

10 p r i n t f ( " F a ct (%d )=%d \n " , i , f a c t ( i ) ) ;11 r e t u r n ( 0 ) ;12 }

État de la pile à l’entrée de l’appel à fact

avec l’argument 0.



Déroulement d’appels de fonction récursive

Pile1 u ns ig ne d i n t f a c t ( u ns ig ne d i n t n )2 {

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

117/425

f a c t

i 4

4

ligne 10

n m a i n

f a c t

ligne 4

3n

n 2

n

ligne 4

1

ligne 4

f a c t

f a

c t

3 i f (n == 0 ) r e t u r n ( 1 ) ;4 e l s e r e t u r n ( n * fact (n - 1) ) ;5 }6

7 i n t main ( )8 {9 u ns ig ne d i n t i = 5 ;

10 p r i n t f ( " F a ct (%d )=%d \n " , i , f a c t ( i ) ) ;11 r e t u r n ( 0 ) ;12 }

État de la pile au retour de l’appel à fact avec

l’argument 0.



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

118/425

Les tableaux



Limite des types de base

1 variable ≈ 1 case mémoire.

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

119/425

Par exemple 1 point d’image ARBG (alpha-rouge-vert-bleu):

bleu

T T T T R R R R G G G G B B B B 32 bits

transparence rouge vert

1 image 1024×

768 = 786432 cases mémoires 32 bits.Déclaration de 786432 variable ?

⇒ Types de base insuffisants pour manipuler de grandes quantités dedonnées.

⇒ Besoin de structures de données.



“Dessine-moi un tableau. . . ”

Tableau =▸

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

120/425

ensemble de “cases” mémoire consécutives,▸ du même type,▸ dénoté par un seul nom de variable.

Accès à 1 case particulière (“élément”) par indexation: t[3].

Le type d’un élément détermine la taille d’une “case”.

⇒ Si on connait où se trouve la 1ère “case” , (“base”) on trouvefacilement l’endroit où se trouve la ième “case” en mémoire.

Numérotation des cases (“indices”) commence à 0 !

Élémenti à l’octet: “base” + i × taille d’un élément.



Quand utiliser un tableau ?

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

121/425

Besoin de grouper plusieurs données de même type.Besoin d’accéder rapidement (tps constant) à n’importe quel élément.

Chaque élément est identifié par son indice (place) dans le tableau.

Pas (peu) de trous entre les éléments effectifs.

⇒ Un tableau est une structure:▸ Homogène.▸ Dense.▸ À accès direct par indexation entière.



“Tableaux et mémoire”

Deux sortes de tableaux:▸ Statiques : taille connue à la compilation.

→ gérés à la compilation comme des variables “standard” .

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

122/425

▸ Dynamiques: taille déterminée à l’exécution.→ Nécessite une primitive ou un fonction d’allocation de mémoire.⇒ Cours ultérieur: uniquement des tableaux statiques pour commencer.

dyn[0] dyn[1] dyn[2] dyn[3]

Mémoire

Pile Tas

dyn

sta[0]

sta[2]

sta[1]

i 4

s t a

i n t i ;/∗ B la b l a . . . i ← 4 ∗/ / ∗ D yn amiq ue . ∗ / i n t dyn [ ] = « a l l o u e r i c as es »/∗ S t a t i q u e . ∗/ i n t s t a [ 3 ] ;



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

123/425

Initialisation de tableaux

Lorsqu’on déclare un tableau, il n’est pas initialisé.

Il contient “ce qu’il y avait dans la mémoire” .

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

124/425

Comme pour les autres variables, il faut l’initialiser:⇒ donner une valeur à chaque case.Initialisation case par case:

f l o a t t [ 3 ] ;t [ 0 ] = 1 . 0 ;

t [ 1 ] = 1 . 5 ;t [ 2 ] = 2 . 0 ;

Tableaux statiques: on peut initialiser d’un coup à la définition:

f l o a t t [ 3 ] = { 1 .0 , 1 . 5 , 2 . 0 } ;

t = { 2.0, 4.7 } ; ne marche pas !



Parcours de tableaux

Un tableau étant une zone contigue indexée, il est naturel d’utiliserune boucle pour le parcourir.Boucle sur les indices de 0 à “taille du tableau −1” .

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

125/425

i n t t [ SIZE ] ;i n t i = 0 ;w h i l e ( i < SIZE ; i ++) {

d o _s o me t hi n g ( t [ i ] ) ;i++ ;

}

Exemple: initialisation

i n t t [ SIZE ] ;i n t i ;f o r ( i = 0 ; i < SIZE ; i ++) t [ i ] = i ∗ i ; /∗ t [ i ] = i 2 . ∗/

Boucle for très pratique !



Petit retour sur les chaînes de caractères string

En C: chaîne = un tableau de caractères. . .

. . . terminé par le caractère ’\0’.

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

126/425

str.c# i n c l u d e < s t d i o . h>i n t main ( ){

i n t i ;c h a r f o o [ ] = " s t u p e f i x " ;f o r ( i = 0 ; f o o [ i ] != ’ \ 0 ’ ; i ++)

p r i n t f ( "%c " , f oo [ i ] ) ;p r i n t f ( "\n" ) ;

r e t u r n ( 0 ) ;

}

mymac:/tmp$ gcc str.c -o str mymac:/tmp$ ./str

s t u p e f i x



Tableaux à plusieurs dimensions

U i i d l d

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

127/425

Une image est une partie de plan: coordonnées x et y .Espace à 2 dimensions ⇒ structure 2 D ⇒ tableau à 2 dimensions.

type nom [ taille 1 ][ taille 2 ] ;

Accès par indexation sur les 2 dimensions: t [x ][ y] = ... ;

Généralisable à n dimensions: int t [3][2][6][7][4] ;Tailles de tableaus statiques: connues à la compilation.

Tableaux dynamiques: subtilités d’initialisation, on verra plus tard.



Tableaux statiques à plusieurs dimensionsst_array.c

# i n c l u d e < s t d i o . h>#define X (4)#define Y (3)

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

128/425

i n t main ( ){

i n t 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 ;}

f o r ( x = 0 ; x < X ; x++) {f o r ( y = 0 ; y < Y ; y++)

p r i n t f ( "%d " , c [ x ] [ y ] ) ;p r i n t f ( "\n" ) ;}r e t u r n ( 0 ) ;

}

mymac:/tmp$ gcc st_array.c -o st_array

mymac:/tmp$ ./st_array

c:

0 1 21 2 3

2 3 4

3 4 5



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

129/425

Quelques remarques sur argv (1)

Déterminer le nombre d’éléments pour savoir jusqu’où aller dans argv.

→ Utilisation de la valeur de argc.

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

130/425

mymac:/tmp$ ./args bar gee 42

’b’ ’a’ ’r’

’g’ ’e’ ’e’

’2’’4’

Pile

Mémoire

Tas

argv[0]

argv[1]

argv[2]




argv contient uniquement des chaînes de caractères.

O pe t pa fois ece oi des omb es e a me ts

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

131/425

On peut parfois recevoir des nombres en arguments.⇒ Nécessité de conversion chaîne → nombre.

Nécessite une transformation algorithmique, et non un changement“simple” de regarder la zone mémoire !

Fonctions à disposition (requièrent #include ):▸ atoi : string → int▸ atol : string → long int▸ atoll : string → long long int▸ atof : string → float




string-to-nums.c# i n c l u d e < s t d i o . h>

# i n c l u d e < s t d l i b h> /* Pour accéder a atoXXX */

http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

132/425

# i n c l u d e < s t d l i b . h> / Pour accéder a atoXXX /i n t main ( i n t argc , c h a r ∗ ar gv [ ] ){

i n t i = a t o i ( a r g v [ 1 ] ) ;l o n g l = a t o l ( a r g v [ 2 ] ) ;l on g l on g l l = a t o l l ( a r g v [ 3 ] ) ;f l o a t f = a t o f ( a rg v [ 4 ] ) ;

p r i n t f ( " i : %d , l : %l d , l l : %l l d , f : %f \ n" , i , l , l l , f ) ;r e t u r n ( 0 ) ;

}

mymac:/tmp$ gcc -Wall string-to-nums.c

mymac:/tmp$ ./a.out 1 2 4559924234322424 4.5i: 1, l: 2, ll: 4559924234322424, f: 4.500000



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

133/425

Phases de construction d’un exécutable



http://find/

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

134/425

L’analyse lexicale (lexical analysis, lexing)

Découper le texte source en mots du langage.

Mots de C: if , int , else , break, switch . . .

Mots (lexèmes) = suite de caractères

8/19/2019 2015_10_14_IN1gh01-allslides-2012-2013

135/425

Mots (lexèmes) = suite de caractères.

∃ plusieurs catégories de lexèmes: littéraux, mots-clefs, ponctuation,identificateurs, “blancs” . . .

Mots décrits par des expression

2015_10_14_in1gh01-allslides-2012-2013

Documents