Cours de C Xavier Dupré xavier.dupre@wanadoo.fr

http://perso.wanadoo.fr/x.dupre/programmation/index.html

I. Première séance : Variables, tests, boucles, fonctions .....................................................................2

1.0. Quelques définitions utiles pour la suite...................................................................................3 1.1. Variables...................................................................................................................................3 1.2. Les tests.....................................................................................................................................8 1.3. Les boucles..............................................................................................................................14 1.4. Exemple : écriture d'un programme calculant l'intégrale d'une fonction................................16

II. Seconde séance : tableaux, structures, fonction, passage des paramètres.....................................18 2.1. Tableaux..................................................................................................................................18 2.2. Structures................................................................................................................................20 2.3. Fonction ..................................................................................................................................21 2.4. Passage des paramètres...........................................................................................................30 2.5. Portée d’une variable..............................................................................................................34 2.6. Bibliothèque de fonctions.......................................................................................................34 2.7. Exemple : un programme de tri ..............................................................................................34

III. Troisième séance : pointeurs........................................................................................................37 3.1. Définition et utilisation...........................................................................................................37 3.2. Pointeurs et structures.............................................................................................................40 3.3. Pointeurs et tableaux ...............................................................................................................41 3.4. Allocations dynamiques..........................................................................................................41 3.5. pointeurs multiples..................................................................................................................44 3.6. Exemple..................................................................................................................................45 3.7. Arithmétique des pointeurs.....................................................................................................47 3.8. Erreurs courantes ....................................................................................................................48

IV. Quatrième séance : les chaînes de caractères ..............................................................................52 4.1. Définition................................................................................................................................52 4.2. Traitement des chaînes de caractères......................................................................................53 4.3. Conversion..............................................................................................................................56 4.4. Exemple..................................................................................................................................58

V. Cinquième séance : les fichiers.....................................................................................................60 5.1. Type de fichiers.......................................................................................................................60 5.2. Accès aux fichiers...................................................................................................................61 5.3. Fonctionnement.......................................................................................................................62 5.4. Fonctions.................................................................................................................................63 5.5. Modifier la position courante..................................................................................................70 5.6. Erreurs fréquentes...................................................................................................................71 5.7. Exemple : dessin d'un histogramme avec Excel .....................................................................72

6. Algorithme du plus court chemin ..................................................................................................75 7. Index ..............................................................................................................................................84 8. Tables des matières détaillées........................................................................................................89

I. Première séance : Variables, tests, boucles, fonctions L’ informatique présentée dans ce cours est abordée d’un point utilitaire. C’est un outils qui permet avant tout de concrétiser des idées (applications mathématiques, communications, jeux, …).

Exemple simple : le calcul de l’ intégrale d’une fonction àààà

On peut considérer simplement qu’un ordinateur est composé de trois parties :

- le microprocesseur - la mémoire - les périphériques (écran, imprimantes, disque dur, …)

Le microprocesseur est le cœur de l’ordinateur, il suit les instructions qu’on lui donne et ne peut travailler qu'avec un très petit nombre d'informations. C'est pourquoi on lui adjoint une mémoire avec laquelle il échange sans arrêt des données. Sa capacité se mesure en octets (kilo-octets, mégaoctets, gigaoctets). Ces échanges entre processeur et mémoire sont rapides. Les périphériques regroupent tout le reste (écran, clavier, souris, disque dur, imprimante…), tout ce qui nous permet de dialoguer avec l'ordinateur et tout ce qui nous permet de conserver des informations une fois que celui-ci est éteint.

1.0. Quelques définitions utiles pour la suite Définition : algor ithme Un algorithme est une suite finie de règles à appliquer dans un ordre déterminé à un nombre fini de données pour arriver avec certitude, en un nombre fini d’étapes, à un certain résultat et cela, indépendamment des données. Leur écriture est indépendante du langage choisi. Qu’ il soit écrit en Basic, en Pascal, en C, en français, un algorithme reste le même. Définition : programme Un programme informatique est une suite d’ instructions ou séquence d'instructions. C'est la réalisation informatique d'un algorithme. Définition : compilateur et compilation Le compilateur est un programme qui traduit un code écrit dans un langage de programmation (ici le C) en langage dit "machine", compréhensible par l'ordinateur. La compilation est le fait de traduire un programme. Par la suite, certaines erreurs de compilations courantes seront citées, celles-ci dépendant du compilateur choisi qui est pour ce cours celui de Microsoft Visual C++ . Définition : éditeur de liens, édition de liens (link en anglais) Le compilateur se contente de traduire un programme en langage machine mais n'assemble pas entre eux les nombreux éléments qui composent un programme (fonctions, fichiers). C'est la tâche de l'éditeur de lien. Définition : mot clé Un mot clé est une composante du langage et fait partie de sa grammaire.

1.1. Var iables

1.1.1. Définition d’une variable Les variables permettent de manipuler des informations en les nommant.

mémoire

emplacement de la

variable v

Définition : var iable Une variable est un espace de la mémoire caractérisé par :

- un nom : il commence par une lettre mais peut inclure des chiffres (attention : minuscules et majuscules sont des lettres différentes), ce nom doit être unique

- un type : c’est une information sur le contenu de l’espace mémoire qui indique au compilateur la manière de lire et d’écrire ce contenu.

A chaque type correspond une manière de lire et d’écrire dans l’espace mémoire de la variable :

un entier (ou « int ») = 4 octets = 32 bits

un « float » = 4 octets = 32 bits mantisse = 23 bits exposant = 8 bits signe = 1 bit

= signe x mantisse x 10exposant Par conséquent, le type d'une variable doit être choisi en fonction des opérations à faire. Exemple : var iable

i nt i ; / / cr éat i on d’ un ent i er doubl e d ; / / cr éat i on d’ un r éel sur 8 oct et s f l oat d ; / * cr éat i on d’ un r éel sur 4 oct et s

( moi ns de pr éci s i on dans l es cal cul s) * /

bool b ; / / cr éat i on d' un bool éen char c ; / / cr éat i on d' un car act èr e

Remarque 1 : commentaires Les signes // sont faits pour insérer des commentaires : le texte suivant les signes // jusqu'à la fin de la ligne ne fait pas partie du programme à compiler. Les signes /* et * / permettent également de commenter un programme, le texte compris entre ces deux bornes n'est pas compilé.

Si le signe * / est oublié, le compilateur retourne l'erreur suivante :

C: \ TEMP\ t r y\ mai n. cpp( 38) : f at al er r or C1071: unexpect ed end of f i l e f ound i n comment

Si le signe /* est oublié, le compilateur retourne les erreurs suivantes :

C: \ TEMP\ t r y\ mai n. cpp( 35) : war ni ng C4138: ' * / ' f ound out s i de of comment C: \ TEMP\ t r y\ mai n. cpp( 35) : er r or C2059: synt ax er r or : ' / '

Remarque 2 : point-virgule Toute déclaration de variable est suivie d'un point virgule, toute instruction (calcul, appel de fonction) est aussi suivie d'un point virgule, il indique au compilateur la fin d'une instruction et le début de la suivante. Par conséquent, bien que ce soit peu conseillé, il est possible de déclarer deux variables sur la même ligne ou même d'écrire deux points-virgules consécutifs :

i nt i ; ; doubl e d ; / * cr éat i on d’ un ent i er et d' un r éel * /

Lorsqu'un point virgule est oublié, le compilateur peut produire les erreurs suivantes :

- lorsque le point virgule est oublié avant la création d'une variable ou l'appel d'une fonction :

C: \ TEMP\ t r y\ mai n. cpp( 34) : er r or C2146: synt ax er r or : mi ssi ng ' ; ' bef or e i dent i f i er ' n'

- lorsque le point virgule est oublié avant une boucle for ou une

accolade :

C: \ TEMP\ t r y\ mai n. cpp( 22) : er r or C2143: synt ax er r or : mi ssi ng ' ; ' bef or e ' f or '

En règle générale, si ces deux erreurs surviennent, il manque un point virgule ou une parenthèse. Remarque 3 : initialisation Il est possible d'attribuer une valeur par défaut à une variable dès sa création.

i nt i = 3 ; / * cr éat i on d’ un ent i er et af f ect at i on d' une val eur par déf aut * /

Lorsqu'un type est mal orthographié, le compilateur déclenche l'erreur suivante :

doul e x ;

C: \ TEMP\ t r y\ mai n. cpp( 21) : er r or C2065: ' doul e' : undecl ar ed i dent i f i er

1.1.2. Utilisation des variables Les variables sont des cases mémoires où est stockée une information numérique. Les opérateurs suivants permettent de modifier et de manipuler ces variables :

opérateurs sens = affectation + addition - soustraction * multiplication / division

% modulo ++ incrémentation -- décrémentation

Exemple : opérateurs

i nt i ; i nt j = 3 ; i = 4 + j ; / / i est égal à 7 i nt k = i + j ; / / k = égal à 10 ++k ; / / k = égal à 11 k++ ; / / k = égal à 12

Il existe d'autres opérateurs associant opération et affectation :

opérateurs sens += addition et affectation -= soustraction et affectation *= multiplication et affectation /= division et affectation

%= modulo et affectation Exemple : opérateur et affectation

i nt i ; i nt j = 3 ; j += 4 ; / / j est égal à 7 i = 4 + j ; / / i est égal à 11 i nt k = i + j ; / / k = égal à 18 k += 1 ; / / k = égal à 19 k += k ; / / k = égal à 38

Il n'y a pas d'espace entre les signes + et =, dans le cas contraire, l'erreur suivante se produit :

x + = 1. 567e15 ;

C: \ TEMP\ t r y\ mai n. cpp( 33) : er r or C2059: synt ax er r or : ' ='

Pour l'ordinateur, toutes les variables sont de types numériques. Liste des types numér iques :

type type de nombre codé précision taille bornes shor t i nt entier relatif court 2 de -32768 à 32767 unsi gned i nt

entier positif 4 de 0 à 4294967295

i nt entier relatif 4 de -2147483648 à 2147483647 enum énumération 4 de -2147483648 à 2147483647 f l oat réel 7 chiffres 4 de ±3,4.10-38 à ±3,4.10+38 doubl e réel 15 chiffres 8 de ±1,7.10-308 à ±1,7.10+308 l ong doubl e

réel 17 chiffres 10 de ±3,4.10-4932 à ±1,1.10+4932

char caractère 1 de -128 à 127 unsi gned char

caractère 1 de 0 à 255

Il est possible de convertir un nombre d'un type numérique vers un autre. Si cette conversion est possible, alors le résultat est le même. Sinon, le résultat est imprévisible. Conversion de types : Pour convertir une valeur de son type vers un autre, on fait précéder cette valeur de cet autre type écrit entre parenthèses.

doubl e x = 3. 5 ; i nt i = ( i nt ) x ; / / r ésul t at i = 3 x = 1. 567e15 ; i = ( i nt ) x ; / / r ésul t at i = -1638076416

Le type de conversion souhaité est facultatif mais son absence déclenche le message préventif suivant :

doubl e x = 1. 567e15 ; i nt i = x ;

C: \ TEMP\ t r y\ mai n. cpp( 34) : war ni ng C4244: ' =' : conver si on f r om ' doubl e' t o ' i nt ' , possi bl e l oss of dat a

1.2. Les tests

1.2.1. Principe des tests Définition : test Un test permet d’utiliser le résultat d’une comparaison numérique afin de déterminer quelles instructions exécuter à cet instant du programme. Syntaxe :

i f ( condi t i on) { . . . / * i nst r uct i ons exécut ées s i l a condi t i on est vr ai e

* / } el se { . . . / * i nst r uct i ons exécut ées s i l a condi t i on est

f ausse, cet t e par t i e est f acul t at i ve * / }

Exemple : obtention de la par tie entière d’un nombre réel

doubl e x = 3. 5 ; i nt i ; i f ( x > 0) { / * cas posi t i f * / i = ( i nt ) x ; } el se { i f ( x == ( i nt ) x) { / * cas négat i f et égal * / i = ( i nt ) x ; } el se { i = ( i nt ) x – 1 ; / * cas négat i f et di f f ér ent * / } }

Définition : indentation L’ indentation consiste à décaler d’un cran certaines parties du code pour illustrer le fait que leur exécution est conditionnée par les dernières lignes décalées d'un cran de moins et situées en amont. L’objectif est de rendre les programmes plus lisibles. Exemple : arrondi

doubl e x = 3. 5 ; i nt i ; i f ( x > 0) { i = ( i nt ) x ; i f ( x- ( doubl e) i > 0. 5) {

i ++ ; } } el se { i = ( i nt ) x – 1 ; i f ( x- ( doubl e) i > 0. 5) { i ++ ; } }

S’ il n’y qu’une seule instruction à exécuter, les accolades sont facultatives : Exemple : arrondi (2)

doubl e x = 3. 5 ; i nt i ; i f ( x > 0) { i = ( i nt ) x ; i f ( x- ( doubl e) i > 0. 5) i ++ ; } el se { i = ( i nt ) x – 1 ; i f ( x- ( doubl e) i > 0. 5) i ++ ; }

L'oubli d'une accolade peut provoquer une des erreurs de compilation suivantes :

C: \ TEMP\ t r y\ mai n. cpp( 40) : f at al er r or C1004: unexpect ed end of f i l e f ound

C: \ TEMP\ t r y\ mai n. cpp( 42) : er r or C2601: ' f onct i on' : l ocal f onct i on def i ni t i ons ar e i l l egal

C: \ TEMP\ t r y\ mai n. cpp( 47) : er r or C2181: i l l egal el se wi t hout mat chi ng i f

1.2.2. Opérateurs

1.2.2.1. Opérateurs de comparaison Les opérateurs de comparaison sont valables pour tous les types numériques :

opérateurs de comparaison traduction en langage C inférieur < supérieur >

inférieur ou égal <= supérieur ou égal >=

égal ==

différent != L'opérateur de comparaison est la source d'un grand nombre d'erreurs car le code suivant est valide :

i nt i = 2 ; i f ( i = 5) { / * i r eçoi t 5 et i est compar é à 1 / / … }

Ce code est équivalent au suivant :

i nt i = 2 ; i = 5 ; i f ( i == 1) { / / … }

1.2.2.2. Opérateurs logiques Les opérateurs logiques permettent d’associer les conditions :

opérateurs logiques traduction en langage C ET & & OU ||

négation ! Les opérateurs logiques sont entièrement définis par une table logique :

table logique de l'opérateur ET VRAI ET VRAI = VRAI VRAI ET FAUX = FAUX FAUX ET VRAI = FAUX FAUX ET FAUX = FAUX

table logique de l'opérateur OU

VRAI OU VRAI = VRAI VRAI OU FAUX = VRAI FAUX OU VRAI = VRAI FAUX OU FAUX = FAUX

table logique de l'opérateur XOR

ou " OU exclusif" VRAI XOR VRAI = FAUX VRAI XOR FAUX = VRAI FAUX XOR VRAI = VRAI

FAUX XOR FAUX = FAUX

table logique de l'opérateur négation NON VRAI = FAUX NON FAUX = VRAI

Exemple : opérateur XOR

bool i = f al se ; bool j = t r ue ; bool r es ; i f ( ( ( i == f al se) && ( j == f al se) ) | | ( ( i == t r ue) && ( j == t r ue) ) ) { r es = f al se ; } el se { r es = t r ue ; }

Exemple : opérateur XOR , autre écr iture

bool i = f al se ; bool j = t r ue ; bool r es ; i f ( ( ! i && ! j ) | | ( i && j ) ) { r es = f al se ; } el se { r es = t r ue ; }

Pour un booléen, i f ( i ) ou i f ( i == t r ue) sont des écritures équivalentes. De même pour i f ( ! i ) et i f ( i == f al se) .

1.2.3. Tests enchaînés et autres écritures possibles

1.2.3.1. Tests enchaînés Définition : tests enchaînés On appelle des tests enchaînés une série de tests consécutifs. Syntaxe :

i f ( condi t i on) { . . . / * i nst r uct i ons exécut ées s i l a condi t i on est vr ai e

* /

} el se i f ( condi t i on1) { . . . / * i nst r uct i ons exécut ées s i l a condi t i on 1 vr ai e * / } el se i f ( condi t i on2) { . . . / * i nst r uct i ons exécut ées s i l a condi t i on 2 est

vr ai e * / } el se { . . . / * i nst r uct i ons exécut ées s i aucune des condi t i ons

n’ est vr ai e * / }

Exemple : obtenir le signe d’un nombre

i nt = 5 ; i nt s i gne ; i f ( i > 0) { s i gne = 1 ; } el se i f ( i < 0) { s i gne = - 1 ; } el se { s i gne = 0 ; }

1.2.3.2. test switch… case … Lorsque les instructions à exécuter dépendent de certaines valeurs d’une variable entière, il est possible de rédiger les tests différemment. Syntaxe :

swi t ch ( var i abl e ent i èr e i ) { case val eur : . . . / * i nst r uct i ons à execut er s i i = val eur * / br eak ; case val eur 1 : . . . / * i nst r uct i ons à execut er s i i = val eur 1 * / br eak ; case val eur 2 : case val eur 3 : . . . / * i nst r uct i ons à execut er s i i = val eur 2 ou

val eur 3 * / br eak ; def aul t :

. . . / * i nst r uct i ons à execut er s i i n’ est égal à aucune des val eur s pr ésent ées c i - dessus * /

br eak ; }

Exemple : switch case

i nt = 5 ; i nt s i gne ; i f ( i > 0) { s i gne = 1 ; } el se i f ( i < 0) { s i gne = - 1 ; } el se { s i gne = 0 ; } swi t ch ( s i gne) { case –1 : pr i nt f ( “ i est négat i f ” ) ; br eak ; case 0 : pr i nt f ( “ i est nul ” ) ; br eak ; case 1 : pr i nt f ( “ i est posi t i f ” ) ; br eak ; def aul t : pr i nt f ( “ i est de s i gne i nconnu” ) ; br eak ; }

1.2.3.3. écr iture abrégée Il est possible d’abréger l’écriture d’un test concernant une affection : Syntaxe :

var i abl e = condi t i on ? valeur si la condition est vraie : valeur si elle est fausse

Exemple : obtenir le signe d’un nombre

i nt = 5 ; i nt s i gne = i > 0 ? 1 : ( i < 0 ? –1 : 0) ;

1.3. Les boucles Définition : boucle Les boucles servent à répéter un nombre fini de fois un même jeu d’ instructions.

1.3.1. Boucles for Syntaxe :

f or ( i ni t i al i sat i on ; condi t i on ; i ncr ément at i on ) { . . . / * j eu d’ i nst r uct i ons exécut ées t ant que l a

condi t i on est vr ai e * / }

La condition est testée au début de chaque exécution de la boucle. Exemple : somme des entiers de 1 à n

i nt n = 10 ; i nt sum = 0 ; i nt i ; f or ( i = 1 ; i <= n ; i ++ ) { sum += i ; }

Il peut y avoir plusieurs instructions d’ initialisation ou d’ incrémentation séparés par une virgule. Exemple : somme des entiers de 1 à n

i nt n = 10 ; i nt sum = 0 ; i nt i , j ; f or ( i = 1, j = n ; i < j ; i ++, j - - ) { sum += i + j ; } i f ( i == j ) sum += i ;

Remarque : La boucle for peut être vide.

f or ( ; ; ) { }

Dans ce cas, le programme est sans fin et reste cantonné dans cette boucle : c’est une boucle infinie.

Exemple : boucle infinie, er reur dans la condition

i nt n = 10 ; i nt sum = 0 ; i nt i ; f or ( i = 1 ; i <= n ; i - - ) { sum += i ; }

Une erreur est fréquente lors de l'écriture d'une boucle for, c'est le substitution d'un ; par :, l 'erreur de compilation suivant apparaît :

C: \ TEMP\ t r y\ mai n. cpp( 11) : er r or C2143: synt ax er r or : mi ssi ng ' ; ' bef or e ' : '

1.3.2. Boucle while Syntaxe :

whi l e ( condi t i on) { . . . / * j eu d’ i nst r uct i on exécut ées t ant que l a condi t i on

est vr ai e * / }

La condition est testée au début de chaque exécution de la boucle. Exemple : somme des entiers de 1 à n

i nt n = 10 ; i nt sum = 0 ; i nt i = 1 ; whi l e ( i <= n) { sum += i ; i ++ ; }

1.3.3. Boucle do … while Syntaxe :

do { . . . / * j eu d’ i nst r uct i on exécut ées t ant que l a condi t i on

est vr ai e * / } whi l e ( condi t i on) ;

La condition est testée à la fin de chaque exécution de la boucle. Exemple : somme des entiers de 1 à n

i nt n = 10 ; i nt sum = 0 ; i nt i = 1 ; do { sum += i ; i ++ ; } whi l e ( i <= n) ;

Les boucles while et do…while ont des comportements différents lors du premier passage dans la boucle :

- la boucle while teste d’abord la condition avant de passer pour la première fois dans la boucle

- la boucle do…while ne vérifie pas la condition avant de passer pour la première fois dans la boucle, par conséquent, la boucle est exécutée au moins une fois

Par conséquent, les deux programmes suivants sont différents :

i nt n = 0 ; i nt sum = 0 ; i nt i = 1 ; whi l e ( i <= n) { sum += i ; i ++ ; }

i nt n = 0 ; i nt sum = 0 ; i nt i = 1 ; do { sum += i ; i ++ ; } whi l e ( i <= n) ;

résultat

sum == 0 sum == 1

1.4. Exemple : écr iture d'un programme calculant l' intégrale d'une fonction

La fonction à intégrer est : ( ) xxxf cos= entre les bornes a = -2 et b = 3, le pas est h.

La valeur approchée de l’ intégrale est :

( )�

−

=

+=h

ab

i

ihafhI0

La réalisation du programme fait intervenir les étapes suivantes :

1. algorithme 2. choix des variables 3. implémentation

Mise en pratique àààà La fonction printf sert à afficher des informations, elle écrit à l'écran du texte dans lequel il est possible d'insérer des nombres et du texte : Exemple : printf

pr i nt f ( " ent i er %d r éel %f r éel exponent i el %e r éel 2 chi f f r e avant , 3 déci mal es %2. 3g car act èr e %c chaî ne de car act èr es %s " ,

5, 5. 6, 1e- 10, 3. 1416e- 45, ' A' , " exempl e" ) ;

Cette fonction remplace chaque code du type %d, %f , %e, %g, %c , %s par les valeurs qui suivent la première virgule hors guillemets. Résultat :

Solution :

doubl e a = - 2 ; doubl e b = 3 ; doubl e h = 0. 1 ; doubl e x ; doubl e I = 0 ; f or ( x = a ; x <= b ; x += h) { I += x * cos ( x) ; } I * = h ; pr i nt f ( “ I = %f “ , I ) ;

II. Seconde séance : tableaux, structures, fonction, passage des paramètres

2.1. Tableaux

2.1.1. Définition et utilisation Un tableau est défini comme suit :

t ype nom [ di mensi on1] [ di mensi on2] . . . ;

Exemple : tableaux

i nt t i [ 10] ; doubl e t d [ 100] ; doubl e mat [ 100] [ 50] ;

Pour accéder à un élément du tableau, on utilise la même notation : Exemple : tableaux et indices

t i [ 5] = 0 ; t d [ 99] = 5. 1 ; mat [ 0] [ 15] = 1 ;

Attention : La dimension d’un tableau doit être une constante et en aucun cas une variable, l’exemple suivant ne compile pas :

i nt n = 5 ; doubl e t [ n] ;

et provoque les erreurs de compilation suivantes :

er r or C2057: expect ed const ant expr essi on er r or C2466: cannot al l ocat e an ar r ay of const ant s i ze 0

2.1.2. Indices Indices : Les éléments d’un tableau de n éléments sont indicés de 0 à n-1. Exemple : er reur d'exécution (tableau)

i nt t i [ 10] ; t i [ 10] / * Pr ovoque une er r eur d' exécut i on, cet t e er r eur n' est pas pr évi s i bl e car l e pr ogr amme accède à une case mémoi r e qui ne l ui " appar t i ent " pas. * /

2.1.3. Initialisation Il est possible d'affecter une valeur à une variable numérique, c'est également possible pour les tableaux. Exemple : initialisation d'un tableau

i nt t [ 5] = { 3, - 5, 6, 7, 8 } ; doubl e not e [ ] = { 12. 5, 13. 5, 14. 78 } ; i nt t 2 [ 2] [ 3] = { { 0, 1, 2 } , { 3, 4, 5} } ;

Pour le second exemple, la dimension du tableau n'est pas précisée. Cette information est facultative à partir du moment où tous les éléments sont connus.

2.2. Structures

2.2.1. Définition Définition : Une structure est un ensemble de variables.

t ypedef st r uct { t ype1 var 1 ; t ype2 var 2 ; . . . } nom_st r uct ur e ;

Exemple : structure (déclaration)

t ypedef st r uct { i nt age ; i nt annee ; doubl e moyenne ; i nt nb_not e ; / * nombr e de not es, i nf ér i eur à 1000

* / doubl e not e [ 1000] ; / * possi bi l i t é de st ocker 1000 not es

au maxi mum pour chaque él ève * /

} el eve ;

Une structure permet de "coller" plusieurs variables ensemble.

2.2.2. Utilisation Pour déclarer une variable de type structure, la syntaxe suivante est utilisée :

t ypedef st r uct { t ype1 var 1 ; t ype2 var 2 ; . . . } nom_st r uct ur e ; nom_st r uct ur e v ;

Pour accéder à un de ses membres :

v . var = . . . ;

Exemple : structure

t ypedef st r uct { i nt age ; i nt annee ; doubl e moyenne ; i nt nb_not e ; / * nombr e de not es, i nf ér i eur à 1000

* / doubl e not e [ 1000] ; / * possi bi l i t é de st ocker 1000 not es

au maxi mum pour chaque él ève * /

} el eve ; el eve e ; e. age = 20 ; e. annee = 2 ; e. moyenne = 12. 5 ; e. nb_not e = 2 ; e. not e [ 0] = 12 ; e. not e [ 1] = 13 ;

2.3. Fonction

2.3.1. Définition Définition : fonction Une fonction en C est similaire à celle d’une fonction mathématique. Elle prend comme entrées des paramètres et retourne un résultat. On les appelle aussi des sous-programmes.

t ype_r esul t at nom_f onct i on ( t ype1 par 1, t ype2 par 2, . . . ) { / * . . . i nst r uct i on à exécut er dans l a f onct i on * / r et ur n r esul t at ; / * l e mot c l é r et ur n per met de r et our ner

l e r ésul t at de l a f onct i on * /

}

Exemple : somme des éléments d’un tableau

doubl e somme ( i nt nb, doubl e t [ 10] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; }

Exemple : lorsque le tableau ne contient pas forcément 10 éléments

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; }

Un programme informatique en C est un assemblage de fonctions (de préférence petites). Il n'est pas possible en C d'imbriquer les fonctions, l'exemple qui suit n'est pas correct : Exemple : impossible imbr ication de fonctions

doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; r et ur n s ; } doubl e s = somme ( nb, t ) ; r et ur n s / nb ; }

Dans ce cas, l'erreur de compilation suivante est déclenchée :

C: \ TEMP\ t r y\ t r y. cpp( 4) : er r or C2601: ' somme' : l ocal f onct i on def i ni t i ons ar e i l l egal

2.3.2. Appel d’une fonction Maintenant qu'une fonction est définie, il suffit de l'utiliser. La syntaxe est la suivante :

nom_f onct i on ( par 1, par 2, . . . ) ;

Exemple : moyenne des éléments d’un tableau

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ;

i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; } doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( nb, t ) ; / * appel de l a f onct i on somme

* / r et ur n s / nb ; }

Attention : Il est possible d'appeler une fonction sans se soucier du résultat qu'elle retourne, l'exemple qui suit est tout-à-fait correct bien qu'inutile. Exemple : appel d'une fonction sans utilisation du résultat

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; } doubl e moyenne ( i nt nb, doubl e t [ ] ) { somme ( nb, t ) ; / * appel de l a f onct i on somme sans

st ocker l e r ésul t at , synt axi quement cor r ect mai s i nut i l e * /

r et ur n 0 ; }

Ordre d'appel L'appel d'une fonction doit toujours suivre sa déclaration. Dans l’exemple précédent, la fonction moyenne appelle la fonction somme, dans l’exemple suivant aussi mais l’ordre des deux fonctions a été inversé : Exemple : moyenne des éléments d’un tableau

doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( nb, t ) ; r et ur n s / nb ; } doubl e somme ( i nt nb, doubl e t [ ] ) {

doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; }

Le compilateur produit l’erreur suivante :

er r or C2065: ' somme' : undecl ar ed i dent i f i er

La fonction moyenne appelle une fonction (somme) dont il doit connaître l’existence. Elle doit :

- soit avoir été écrite avant la fonction appelante, - soit avoir été signalée même si sa définition n'intervient qu'après la fonction

appelante. Exemple : moyenne des éléments d’un tableau

doubl e somme ( i nt nb, doubl e t [ ] ) ; / * f onct i on somme s i gnal ée * / doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( nb, t ) ; r et ur n s / nb ; } doubl e somme ( i nt nb, doubl e t [ ] ) / * f onct i on somme

déf i ni e * / { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; }

2.3.3. Erreurs courantes

2.3.3.1. Erreur dans les paramètres Exemple : er reur dans les paramètres (nombre)

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ;

} r et ur n s ; } doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( nb) ; / / i l manque un par amèt r e r et ur n s / nb ; }

Cet exemple génère une erreur de compilation car la fonction somme est appelée avec un nombre de paramètres différent de celui qu'elle requiert.

C: \ t emp\ t r y\ t r y. cpp( 13) : er r or C2660: ' somme' : f onct i on does not t ake 1 par amèt r es

Exemple : er reur dans les paramètres (type)

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; } doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( t , nb) ; / / mauvai s appel r et ur n s / nb ; }

Cet exemple génére une erreur de compilation car la fonction somme est appelée avec des paramètres de types différents de ceux qu'elle requiert.

C: \ t emp\ t r y\ t r y. cpp( 13) : er r or C2664: ' somme' : cannot conver t par amet er 1 f r om ' doubl e [ ] ' t o ' i nt ' Thi s conver si on r equi r es a r ei nt er pr et _cast , a C-st y l e cast or f onct i on- st y l e cast

2.3.3.2. Point virgule après la déclaration d'une fonction Exemple : er reur , point-virgule en trop

doubl e somme ( i nt nb, doubl e t [ ] ) ; / / poi nt v i r gul e en t r op { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ;

}

Cet exemple génère l'erreur suivante :

C: \ t emp\ t r y\ t r y. cpp( 2) : er r or C2447: mi ssi ng f onct i on header ( ol d- st y l e f or mal l i s t ?)

2.3.3.3. Oubli d'une accolade fermante Exemple : er reur , oubli d'une accolade fermante

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; / / pas d' accol ade pour t er mi ner l a boucl e f or r et ur n s ; } doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( nb, t ) ; r et ur n s / nb ; }

Comme il n'est pas possible d'imbriquer les fonctions, cet exemple génère les erreurs suivantes :

C: \ t emp\ t r y\ t r y. cpp( 12) : er r or C2601: ' moyenne' : l ocal f onct i on def i ni t i ons ar e i l l egal C: \ t emp\ t r y\ t r y. cpp( 17) : f at al er r or C1004: unexpect ed end of f i l e f ound

2.3.3.4. Fonction déclarée mais pas définie Exemple : er reur , fonction non définie mais déclarée

doubl e somme ( i nt nb, doubl e t [ ] ) ; doubl e moyenne ( i nt nb, doubl e t [ ] ) { doubl e s = somme ( nb, t ) ; r et ur n s / nb ; }

Le compilateur peut traduire ce programme mais l'éditeur de liens ne peut faire aboutir l'appel de la fonction somme puisqu'elle n'est définie nulle part et provoque l'erreur suivante :

t r y . obj : er r or LNK2001: unr esol ved ext er nal symbol " doubl e __cdecl somme( i nt , doubl e * const ) " ( ?somme@@YANHQAN@Z)

2.3.4. Fonctions récursives Définition : fonction récursive Une fonction récursive est une fonction qui s’appelle elle-même. Exemple : factor ielle

i nt f act or i el l e ( i nt n) / / cal cul e n! { i f ( n <= 1) { r et ur n 1 ; } el se { r et ur n n * f act or i el l e ( n- 1) ; } }

Les fonctions récursives sont élégantes mais la condition d'arrêt de la récursivité doit être bien spécifiée. Exemple : factor ielle mal implémentée

i nt f act or i el l e ( i nt n) { r et ur n n * f act or i el l e ( n- 1) ; }

Cette fonction est syntaxiquement correct mais son exécution mène à l'erreur d'exécution suivante :

2.3.5. Fonction sans résultat Il est possible de construire une fonction qui ne retourne aucun résultat, le type du résultat est alors void.

Exemple : fonction sans résultat

voi d f onct i on_sans_r esul t at ( i nt i ) { / / . . . r et ur n ; / / i nst r uct i on f acul t at i ve }

Dans d'autres langages, elles sont appelées procédures. Appeler une telle fonction s'effectue de la même manière que pour les autres fonctions. Exemple : appel d'une fonction sans résultat

voi d pr i nt _l i ne ( ) { pr i nt f ( " \ n" ) ; } voi d mai n ( ) { i nt n ; f or ( n = 0 ; n < 10 ; n++) { pr i nt _l i ne ( ) ; } }

2.3.6. Fonction main Un programme en C doit obligatoirement contenir la fonction main qui sera la première fonction exécutée, elle est appelée point d’entrée du programme. Exemple : fonction main

voi d mai n ( ) { i nt i = 0 ; / / pr emi èr e i nst r uct i on du pr ogr amme / / . . . i = 1 ; / / der ni èr e i nst r uct i on exécut ée }

L'absence de cette fonction provoque une erreur de l'éditeur de liens qui ne sait pas quelles instructions exécuter pour commencer.

LI BCD. l i b( cr t 0. obj ) : er r or LNK2001: unr esol ved ext er nal symbol _mai n

2.3.7. Nom des fonctions Les noms des fonctions sont soumis aux mêmes contraintes que les noms de variables :

- leur nom commence par une lettre - il contient soit des lettres, soit des chiffres, soit ‘_’ mais pas d’espace

ni d’accent - le nom ne doit pas être attribué à une autre fonction, une variable ou

une structure

2.3.8. Variables locales Définition : var iable locale Toute variable déclarée à l’ intérieur d’une fonction est appelée variable locale, elle n’est utilisable qu’à l’ intérieur de cette fonction et nulle part ailleurs. Par conséquent, il est possible d’utiliser plusieurs fois le même nom de variable à condition que ce soit dans des fonctions différentes. Exemple : somme et somme pondérée

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; } doubl e somme_ponder ee ( i nt nb, doubl e t [ ] , doubl e poi ds [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] * poi ds [ n] ; } r et ur n s ; }

2.3.9. Surcharge Remarque : surcharge

En C++ , les deux fonctions somme et somme_ponderee pourraient toutes deux détenir le même nom somme parce que leurs paramètres sont différents (en type ou en nombre). On dit que la fonction somme est surchargée. Exemple : surcharge

doubl e somme ( i nt nb, doubl e t [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] ; } r et ur n s ; } doubl e somme ( i nt nb, doubl e t [ ] , doubl e poi ds [ ] ) { doubl e s = 0 ; i nt n ; f or ( n = 0 ; n < nb ; n++) { s += t [ n] * poi ds [ n] ; } r et ur n s ; } voi d mai n ( ) { doubl e t [ 3] = { 10, 12, 14 } ; doubl e w [ 3] = { 2, 2, 4 } ; i nt s = somme ( 3, t ) ; / * pas d' ambi guï t é, appel de l a pr emi èr e f onct i on * / i nt sp = somme ( 3, t , w) ; / * pas d' ambi guï t é, appel de l a seconde f onct i on * / }

2.4. Passage des paramètres

2.4.1. Passage par valeur Définition : passage d’un paramètre par valeur Lors du passage d'un paramètre par valeur, la fonction reçoit une copie de la valeur envoyée lors de l’appel : toute modification à l’ intérieur de cette fonction n’a de répercutions que dans cette fonction. Les paramètres passés par valeur sont des variables locales et ont exactement le même comportement. Exemple : passage par valeur

voi d i ncr ement e ( i nt i )

{ i = i + 1 ; } voi d mai n ( ) { i nt k = 0 ; i ncr ement e ( k) ; pr i nt f ( “ %d” , k) ; / / af f i che 0 }

2.4.2. Passage par référence Définition : passage d’un paramètre par référence Lors du passage d'un paramètre par référence, le paramètre est associé à la variable qui lui correspond lors de l’appel à la fonction, si la valeur du paramètre est modifiée, la variable associée l’est aussi. Les paramètres passés par référence sont également des variables locales car le nom qui leur est donné n'est valable qu'à l'intérieur de la fonction. Toutefois, leur modification entraîne celle de la variable associée. Le nom est local mais pas son contenu. Exemple : passage par référence

voi d i ncr ement e ( i nt &i ) { i = i + 1 ; } voi d mai n ( ) { i nt k = 0 ; i ncr ement e ( k) ; pr i nt f ( “ %d” , k) ; / / af f i che 1 }

La définition d’un passage par référence implique qu’ il est impossible d’associer une constante à un paramètre passé par référence. Exemple : référence et constante

voi d i ncr ement e ( i nt &i ) { i = i + 1 ; } voi d mai n ( ) { i ncr ement e ( 0) ; / / pr ovoque une er r eur de compi l at i on }

Le compilateur répond :

er r or C2664: ' i ncr ement e' : cannot conver t par amet er 1 f r om ' const i nt ' t o ' i nt &' A r ef er ence t hat i s not t o ' const ' cannot be bound t o a non-l val ue

2.4.3. Programmes équivalents Comme pour les boucles, il est possible de transformer un programme utilisant des passages par référence en un programme utilisant des passages par valeur. Les deux programmes suivants sont équivalents :

Programme 1 Programme 2 voi d i ncr ement e ( i nt &i ) { i = i + 1 ; } voi d mai n ( ) { i nt k = 0 ; i ncr ement e ( k) ; pr i nt f ( “ %d” , k) ; }

i nt i ncr ement e ( i nt i ) { r et ur n i + 1 ; } voi d mai n ( ) { i nt k = 0 ; k = i ncr ement e ( k) ; pr i nt f ( “ %d” , k) ; }

Les passages par référence sont très utiles lorsque le résultat d’une fonction se compose de plusieurs valeurs. Les deux programmes suivants sont équivalents :

Programme 1 Programme 2 voi d i ncr ement e ( i nt &i , i nt &j ) { i ++ ; j ++ ; } voi d mai n ( ) { i nt k = 0 ; i nt l = 1 ;

t ypedef st r uct { i nt i ; i nt j ; } deux_ent i er s ; deux_ent i er s i ncr ement e

( deux_enti er s d)

{ d. i ++ ; d. j ++ ; r et ur n d ; } voi d mai n ( ) { deux_ent i er s k ;

i ncr ement e ( k, l ) ; pr i nt f ( “ %d %d” , k, l ) ; }

k. i = 0 ; k. j = 1 ; k = i ncr ement e ( k ) ; pr i nt f ( “ %d %d” , k. i , k . j ) ; }

2.4.4. Passage de tableaux Bien que l’écriture d’un passage de tableau soit similaire à celle d’un passage par valeur, c’est pourtant un passage par référence qui est effectué. Exemple : passage d’un tableau

voi d i ncr ement e ( i nt i [ 2] ) { i [ 0] ++ ; i [ 1] ++ ; } voi d mai n ( ) { i nt k [ 2] = { 0 , 1 } ; i ncr ement e ( k) ; pr i nt f ( “ %d %d” , k [ 0] , k [ 1] ) ; / / af f i che 1 et 2 }

En revanche, si le tableau est inclus dans une structure : Exemple : passage d’un tableau dans une structure

t ypedef st r uct { i nt i [ 2] ; } t abl eau ; voi d i ncr ement e ( t abl eau t ) { t . i [ 0] ++ ; t . i [ 1] ++ ; } voi d mai n ( ) { t abl eau k ; k . i [ 0] = 0 ; k . i [ 1] = 1 ; i ncr ement e ( k) ; pr i nt f ( “ %d %d” , k. i [ 0] , k . i [ 1] ) ; / / af f i che 0 et 1 }

Le tableau inclus dans la structure passée à la fonction incremente est recopié.

2.5. Por tée d’une var iable Définition : por tée d'une var iable La portée d'une variable est la partie du code dans laquelle elle est utilisable. Dans le cas d'une variable locale, c'est la fonction en elle-même. Plus généralement, une variable existe depuis sa définition jusqu'à la première l'accolade fermante.

Exemple : por tée d'une var iable

2.6. Bibliothèque de fonctions Il existe de nombreuses fonctions déjà programmées en langage C comme les fonctions mathématiques, sinus, cosinus, … ou des fonctions d'affichage que l'on verra plus tard (printf,…). Mais pour utiliser ces fonctions, il faut dire au compilateur où elles sont définies de sorte qu'il sache qu'elles existent. Dans le cas de la fonction rand () qui retourne un nombre au hasard, sans aucune précision, le compilateur retourne l'erreur :

er r or C2065: ' r and' : undecl ar ed i dent i f i er

Cette fonction est définie dans une librairie appelée "stdlib.h", il faut donc ajouter la ligne suivante au début du fichier contenant le programme :

#i ncl ude " st dl i b. h"

Le langage C offre la possibilité de construire ses propres librairies.

2.7. Exemple : un programme de tr i

l i gne 1 : {

l i gne 2 : i nt a = 2 ; déclare la variable a (bloc 1) l i gne 3 : i nt c = - 1 ; déclare la variable c (bloc 1) l i gne 4 : {

l i gne 5 : i nt a = 1 ; déclare la variable a (bloc 2) l i gne 6 : i nt b = 0 ; déclare la variable b (bloc 2) l i gne 7 : pr i nt f ( " a = %d" , a) ; affiche "a = 1" l i gne 8 : } détruit la variable a du bloc 2 l i gne 9 : pr i nt f ( " a = %d" , a) ; affiche "a = 2" l i gne 10 : } détruit la variable a du bloc 1

bloc

bloc

Comment passer du premier tableau non trié au dernier tableau trié ? Indice : le nombre placé en position n est le plus petit parmi tous ceux qui suivent.

à

Solution 1 :

i nt mi ni mum ( i nt nb, i nt t [ ] , i nt pos) { / / i nt r es = pos ; i nt n ; f or ( n = pos ; n < nb ; n++) { i f ( t [ n] < t [ pos] ) { pos = n ; } } r et ur n pos ; }

voi d echange ( i nt nb, i nt t [ ] , i nt pos1, i nt pos2) { i nt ech = t [ pos1] ; t [ pos1] = t [ pos2] ; t [ pos2] = ech ; } voi d t r i ( i nt nb, i nt t [ ] ) { i nt mi n ; i nt n ; f or ( n = 0 ; n < nb ; n++) { mi n = mi ni mum ( nb, t , n) ; echange ( nb, t , n, mi n) ; } } voi d mai n ( ) { i nt t [ 5] = { 4, 6, 3, 5, 1 } ; t r i ( 5, t ) ; i nt n ; f or ( n = 0 ; n < 5 ; n++) { pr i nt f ( " %d " , t [ n] ) ; } }

Solution 2 :

t ypedef st r uct { i nt nb ; doubl e r [ 100] ; } t abl eau ; voi d mai n ( ) { / / cr éat i on du t abl eau t abl eau t ; t . nb = 20 ; / / i ni t i al i sat i on i nt n ; f or ( n = 0 ; n < t . nb ; n++) { t . r [ n] = ( doubl e) r and ( ) / ( doubl e) RAND_MAX ; } / / t r i doubl e ech ;

i nt mi n ; i nt i , j ; f or ( i = 0 ; i < t . nb ; i ++) { / / r echer ché du mi ni mum mi n = i ; f or ( j = i +1 ; j < t . nb ; j ++) { i f ( t . r [ j ] < t . r [ mi n] ) { mi n = j ; } } / / échange ech = t . r [ mi n] ; t . r [ mi n] = t . r [ i ] ; t . r [ i ] = ech ; } }

III. Troisième séance : pointeurs

3.1. Définition et utilisation

3.1.1. pointeur et variable Définition : pointeur Un pointeur est une variable dont le contenu est une adresse mémoire. On déclare un pointeur de la manière suivante :

t ype_poi nt eur * nom_poi nt eur ;

nom_pointeur est le nom du pointeur et représente une variable de type pointeur

type_pointeur est une indication sur le type des informations stockées à l'adresse contenue par le pointeur, c'est ce type qui indique au programme comment interpréter ce que contient la mémoire

Utilisation : Après qu'un pointeur a été déclaré :

t ype_poi nt eur * nom_poi nt eur ;

* nom_poi nt eur permet d'accéder aux informations stockées à l'adresse contenue par le pointeur nom_poi nt eur Exemple : pointeur

doubl e * sd ; / / . . . doubl e d = * sd ; * sd = 5 ;

Les données sont souvent utilisées à plusieurs endroits dans un même programme. Les pointeurs permettent d'éviter la manipulation des informations sans les copier, seulement en copiant leur adresse ou emplacement.

3.1.2. Pointeur non typé Définition : pointeur non typé Il est possible que le programmeur ne dispose d'aucune information sur le type du contenu présent à une adresse mémoire. Dans ce cas, le pointeur se résume à une simple adresse dépourvue d'accès à la zone mémoire pointée par le pointeur. Le pointeur sera alors de type void.

voi d * nom_poi nt eur ; Exemple et remarque : pointeur non typé

voi d * p ; / / . . . * p = 5 ; cette seconde ligne n’est pas correcte

Le compilateur ne peut interpréter la seconde ligne car il ne sait pas comment écrire 5 en mémoire : le pointeur n'est accompagné d'aucune information de contenu, 5 est-il entier ou réel, doit-on le coder sur 4 ou 8 octets ? Les erreurs de compilation déclenchées sont les suivantes :

C: \ TEMP\ t r y\ t r y. cpp( 5) : er r or C2100: i l l egal i ndi r ect i on C: \ TEMP\ t r y\ t r y. cpp( 5) : er r or C2440: ' =' : cannot conver t f r om ' const i nt ' t o ' voi d * ' Conver si on f r om i nt egr al t ype t o poi nt er t ype r equi r es r ei nt er pr et _cast , C- st y l e cast or f onct i on- st y l e cast

Exemple de conversion :

doubl e * d ; i nt * i = ( i nt * ) d ; / / . . . * d = 5 ; / / ( 1) * i = 5 ; / / ( 2)

La ligne (1) écrit 5 en mémoire en respectant le format d'un nombre réel sur 8 octets. La ligne (2) écrit 5 en mémoire en respectant le format d'un nombre entier sur 4 octets. Ces deux lignes ne sont pas équivalentes bien qu'elles écrivent le même nombre à la même adresse mais sous des formats différents. La mémoire n'est qu'une suite ininterrompue de chiffres, leur interprétation dépend du format utilisé pour les déchiffrer.

3.1.3. Opérateur & L'opérateur & permet d’obtenir l'adresse du contenu d'une variable. La valeur obtenue est de type pointeur. Exemple : opérateur &

doubl e d ; doubl e * sd = & d ;

Les deux lignes suivantes sont alors équivalentes :

d = 5 ; * sd = 5 ;

Il n'est pas conseillé de mélanger les types comme dans l'exemple qui suit. Exemple : opérateur & et er reur de type

doubl e d ; i nt * sd = & d ;

Le compilateur génère l'erreur suivante :

C: \ TEMP\ t r y\ t r y. cpp( 6) : er r or C2440: ' =' : cannot conver t f r om ' doubl e * ' t o ' i nt * ' Types poi nt ed t o ar e unr el at ed; conver si on r equi r es r ei nt er pr et _cast , C- st y l e cast or f onct i on- st y l e cast

Toutefois, il est possible d'imposer la conversion d'un pointeur. Exemple : opérateur & et conversion de type

doubl e d ; i nt * sd = ( i nt * ) & d ;

Cette écriture permet de décrypter un réel comme un entier. Cette utilisation est rare.

3.1.4. Résumé graphique On considère les deux lignes suivantes :

i nt i = 5 ; i nt * p = &i ;

En mémoire, on obtient :

L'utilisation de pointeurs est délicate et souvent sujette aux erreurs. Un pointeur est l'association d'une adresse mémoire et un type de contenu.

3.2. Pointeurs et structures Les structures sont des variables d'un type défini par l'utilisateur. Le type pointeur existe aussi pour ces types. Exemple : pointeur de structure

t ypedef st r uct { i nt x ; doubl e y ; } St ;

St s ; ps est pointeur sur une structure St * ps = &s ;

s. x = 5 ; ps- >x = 5 ; ( * ps) . x = 5 ; ps [ 0] . x = 5 ;

quatre instructions équivalentes

La notation la plus couramment employée car la plus lisible est - >.

3.3. Pointeurs et tableaux Lorsqu’on déclare un tableau :

doubl e t [ 10] ;

La variable t est de type :

doubl e * t ;

Par conséquent, il est possible d’écrire la ligne suivante :

doubl e t [ 10] ; doubl e * t p = t ;

Mais l’utilisation la plus courante est le passage d’un tableau à une fonction : Exemple : passage d'un tableau à une fonction (équivalente à l'écr iture utilisant des crochets (doubl e moyenne ( i nt nb, doubl e * t ) )

doubl e moyenne ( i nt nb, doubl e * t ) { i nt n ; doubl e m = 0 ; f or ( n = 0 ; n < nb ; ++n) m += t [ n] ; r et ur n m / ( doubl e) nb ; } voi d mai n ( ) { doubl e t ab [ 5] = { 12, 10, 8, 9, 11 } ; doubl e moy = moyenne ( 5, t ab) ; }

3.4. Allocations dynamiques

Définition : allocation dynamique Une allocation dynamique correspond à la création d’un tableau dont la dimension n’est connue qu’au cours de l’exécution du programme, elle dépend des données que le programme aura à traiter.

Syntaxe :

Version C

t ype * nom_poi nt eur = ( t ype* ) cal l oc ( nb_el ement , t ai l l e_el ement ) ;

Version C++

t ype * nom_poi nt eur = new t ype [ nb_el ement ] ;

Exemple : allocation dynamique

Version C

doubl e * t = ( doubl e* ) cal l oc ( 10, s i zeof ( doubl e) ) ;

Version C++

doubl e * u = new doubl e [ 10] ;

Lorsque le tableau créé n’est plus nécessaire, il est indispensable de le détruire. C'est une désallocation dynamique.

Syntaxe :

Version C

f r ee ( nom_poi nt eur ) ;

Version C++

del et e [ ] nom_poi nt eur ;

Exemple : désallocation dynamique

Version C

doubl e * t = ( doubl e* ) cal l oc ( 10, s i zeof ( doubl e) ) ; f r ee ( t ) ;

Version C++

doubl e * u = new doubl e [ 10] ; del et e [ ] u ;

Oublier de libérer un pointeur encombre la mémoire inutilement, il est facile de ralentir l’ordinateur en exécutant le programme suivant :

Exemple : allocations dynamiques répétées

Version C++

voi d mai n ( ) { f or ( ; ; ) { doubl e * t = new doubl e [ 1000] ; } }

Une infinité de pointeurs est créée sans libération. Le programme remplit la mémoire jusqu’à ce qu’elle ne puisse plus, refuse et affiche la fenêtre suivante :

L'ordinateur devient très lent car ses ressources ont fortement diminué. Le gestionnaire des tâches montre le graphique suivant :

3.5. pointeurs multiples Définition : pointeur multiple Un pointeur multiple est un pointeur, la mémoire pointée par ce pointeur contient un autre pointeur.

doubl e d = 5 ; doubl e * sd = &d ; doubl e* * ssd = &sd ; . . .

d lit ou modifie le contenu de d

* sd lit ou modifie la mémoire pointée par sd soit le contenu de d * ssd lit ou modifie la mémoire pointée par ssd soit le contenu de sd * * ssd lit ou modifie la mémoire pointée par *ssd, donc lit ou modifie le

contenu de la mémoire pointée par *ssd, soit le contenu de d Exemple : allocation d’une matr ice

doubl e * * p = new doubl e* [ 3] ; i nt n ; f or ( n = 0 ; n < 3 ; n++) { p [ n] = new doubl e [ 5] ; }

En mémoire, la matrice correspond au schéma suivant :

Exemple : libération d’une matr ice

i nt n ; f or ( n = 0 ; n < 3 ; n++) { del et e [ ] p [ n] ; } del et e [ ] p ;

3.6. Exemple L’objectif est de calculer le temps nécessaire au tri d’un tableau de n entiers choisis aléatoirement.

à Solution :

voi d t r i ( i nt nb, i nt * t ) { i nt i , j ; i nt mi n ; i nt ech ; f or ( i = 0 ; i < nb ; ++i ) { mi n = i ; f or ( j = i +1 ; j < nb ; ++j ) { i f ( t [ j ] < t [ mi n] ) mi n = j ; } ech = t [ mi n] ; t [ mi n] = t [ i ] ; t [ i ] = ech ; } } voi d mai n ( ) { i nt n, k ; i nt t i ; char buf [ 1000] ; f or ( n = 1000 ; n <= 20000 ; n += 1000) { i nt * t = new i nt [ n] ;

f or ( k = 0 ; k < n ; k++) { t [ k ] = r and ( ) % 10000 ; } t i = c l ock ( ) ; t r i ( n, t ) ; t i = c l ock ( ) - t i ; del et e [ ] t ; pr i nt f ( " t emps pour n = %d : %d ms\ n" , n, t i ) ; } }

3.7. Ar ithmétique des pointeurs Un pointeur p peut être considéré comme un tableau de longueur infinie dont p indique l’origine. Ajouter ou retrancher un entier à ce pointeur déplace cette origine. Lorsque qu’on déclare un pointeur :

t ype * nom_poi nt eur ;

Pour ce pointeur, la mémoire est un tableau d’éléments de type type dont l’origine (la case d’ indice 0) est celle pointée par ce pointeur. Il est alors possible d’effectuer les opérations suivantes :

nom_poi nt eur + ent i er désigne l’élément situé entier cases après l’origine

nom_poi nt eur - ent i er désigne l’élément situé entier cases avant l’origine

ent i er + nom_poi nt eur erreur car le compilateur s’attend à une addition entre deux entiers

nom_poi nt eur += ent i er l’origine est décalée de entier cases en avant nom_poi nt eur - = ent i er l’origine est décalée de entier cases en arrière ent i er += nom_poi nt eur erreur car le compilateur s’attend à une

addition entre deux entiers On considère ces deux déclarations de variables.

doubl e t [ 10] ; doubl e * d = t ;

Le schéma suivant illustre plusieurs manières de désigner la même zone mémoire.

En règle générale, il est préférable d'éviter les opérations sur les pointeurs car elles sont susceptibles d'amener des erreurs d'exécutions. Néanmoins, elles sont utilisées pour améliorer la vitesse d'un programme car elles réduisent le nombre d'opérations à effectuer. Exemple : amélioration de la vitesse des programmes doubl e t [ 1000] ; i nt n ; f or ( n = 0 ; n < 1000 ; ++n) { t [ n] = r and ( ) ; / * l e code de cet t e l i gne est t r adui t par * ( t +n) = r and ( ) * / }

doubl e t [ 1000] ; i nt n ; doubl e * p ; f or ( n = 0, p = t ; n < 1000 ; ++n, ++p) { * p = r and ( ) ; }

programme 1 programme 2 Le programme 2 remplace l'opération ( t +n) effectuée à chaque itération par ++p. Incrémenter est plus rapide qu'ajouter n.

3.8. Er reurs courantes Lorsque le programme provoque l’affichage d’une fenêtre comme celle-ci :

ou :

Il est fréquent que l’apparition de cette fenêtre ait été provoquée par une des erreurs exposées dans les paragraphes suivants. En version « debug », cliquer sur « Retry » (1° fenêtre) ou « Cancel » (2° fenêtre) permet de retrouver la ligne du programme qui a provoquée cette erreur d’exécution.

3.8.1. Pointeur non initialisé

doubl e * p ; * p = 5 ;

Dans cet exemple, le pointer p est déclaré mais non initialisé, il pointe sur une zone de la mémoire inconnue. Or le contenu de cette zone est modifié, ceci peut provoquer un plantage du programme.

3.8.2. Dépassement de limites

doubl e * p = new doubl e [ 10] ; p [ 10] = 5 ;

Dans cet exemple, une zone de mémoire de 10 double est allouée mais p [10] représente le 11° élément du tableau et n'a pas été réservé. Cet exemple provoque les mêmes symptômes que le précédent.

3.8.3. Allocations successives

doubl e * p = new doubl e [ 5] ; doubl e * p = new doubl e [ 5] ;

Dans cet exemple, le pointeur p reçoit successivement les adresses de deux blocs de mémoire alloués dynamiquement. Par conséquent, la première adresse stockée par p est écrasée par la seconde et le premier bloc ne peut plus être libéré.

3.8.4. Libération d’un mauvais pointeur

doubl e * p = new doubl e [ 10] ; p++ ; del et e [ ] p ;

Le système d'exploitation ne peut libérer p car aucune zone mémoire réservée ne commence à l'adresse désignée par le pointeur p. Lors de la libération du pointeur, il faut impérativement donner au système d'exploitation (à delete [ ] ) l'adresse du début de la zone mémoire allouée.

3.8.5. Libérer deux fois le même pointeur

doubl e * p = new doubl e [ 10] ; del et e [ ] p ; del et e [ ] p ;

La première instruction delete [ ] p libère effectivement la zone mémoire allouée, la seconde provoque les mêmes symptômes que l'exemple précédent : plus aucune zone de mémoire allouée ne commence à l'adresse contenue par p. Afin d'éviter ce genre de désagrément, il est conseillé d'initialiser tous les pointeurs déclarés et non utilisés à 0 car 0 est une adresse mémoire qui n'est jamais utilisée. De même à chaque libération, le pointeur doit être remis à 0 afin d'indiquer qu'il a été libéré.

doubl e * p = 0 ; i f ( p == 0) p = new doubl e [ 5] ; i f ( p == 0) p = new doubl e [ 5] ; i f ( p ! = 0) { del et e [ ] p ; p = 0 ; } i f ( p ! = 0) { del et e [ ] p ; p = 0 ; }

3.8.6. Mauvais ordre dans les libérations L’exemple concerne la création et la destruction d’une matrice.

Création :

doubl e * * p = new doubl e* [ 3] ; i nt n ; f or ( n = 0 ; n < 3 ; n++) { p [ n] = new doubl e [ 5] ; }

Destruction :

del et e [ ] p ; i nt n ; f or ( n = 0 ; n < 3 ; n++) { del et e [ ] p [ n] ; }

Lors de la libération de la matrice, on libère d'abord le tableau de pointeurs avant de libérer chacun des pointeurs qu'il contient. Par conséquent, après la libération du tableau de pointeurs, cette zone de la mémoire n'est plus protégée et toutes les informations qui s'y trouvent sont susceptibles d'être modifiées par un autre programme. Il est donc impossible de libérer les tableaux de double dont les adresses étaient mémorisées dans le tableau libéré.

3.8.7. Désallocation oubliée Exemple :

voi d f ( ) { doubl e * d = new doubl e [ 5] ; } voi d mai n ( ) { f ( ) ; }

Lors de l'exécution de la fonction f, celle-ci alloue une zone mémoire de 5 double qui n'est pas libérée. Or, à la fin de l'exécution de f, le pointeur d est détruit, son contenu (l'adresse du bloc alloué) est perdu et il est alors impossible de libérer la zone mémoire dont lui seul connaissait le début.

3.8.8. Adresse de variables locales Exemple : adresse de var iable locale

doubl e * f ( ) {

doubl e t [ 10] ; r et ur n t ; } voi d mai n ( ) { doubl e * t ab = f ( ) ; }

La fonction f retourne un pointeur sur un tableau qui est une variable locale. Par conséquent, dans la fonction main, le pointeur tab est effectivement égal à l'adresse de t mais celui-ci est détruit après l'exécution de f. Par conséquent, tab pointe sur un tableau qui n'existe plus.

IV. Quatrième séance : les chaînes de caractères

4.1. Définition Définition : chaîne de caractères Une chaîne de caractères est un tableau de caractères dont le dernier est le caractère nul. Exemple : chaîne de caractères

char chai ne [ 8] = { ' b' , ' o' , ' n' , ' j ' , ' o' , ' u' , ' r ' , 0 } ; char * chai ne [ 8] = " bonj our " ; char * chai ne = " bonj our " ;

Les trois lignes précédentes sont équivalentes mais la dernière est de loin la plus pratique. Les caractères apparaissent entre apostrophes. Les chaînes de caractères apparaissent entre guillemets. Pour insérer des guillemets, il faut les faire précéder du caractère ‘ \’ . Exemple : « extra-caractère »

char * chai ne = " \ " bonj our \ " " ;

char * chai ne = " \ t \ n \ \ " ;

La dernière ligne montre trois autres « extra-caractères » :

- \t : la tabulation, insérée dans un fichier texte, elle permet de séparer deux colonnes et de formater le fichier afin que des logiciels comme Excel puissent le lire.

- \n : le passage à la ligne - \\ : l’anti-slash, utile pour les noms de fichiers

Il est possible d'écrire une chaîne de caractères sur plusieurs lignes de texte en insérant entre chaque tronçon le caractère \.

" chaî ne de car act èr es de t r oi s t r onçons" \ " écr i t sur t r oi s l i gnes" \ " r el i és par l e car act èr es \ \ "

4.2. Traitement des chaînes de caractères Toutes les fonctions présentées dans la suite sont définis par la librairie « string ». Il faut donc inclure au début du fichier qui contient le programme qui les utilise :

#i ncl ude " st r i ng. h"

4.2.1. Comparaison Exemple : ce qui ne marche pas

char * c1 = " bonj our " ; char * c2 = " bonj our " ; i f ( c1 == c2) { / / début de conver sat i on }

Bien que ch1 et ch2 soient deux chaînes de caractères égales, le test retournera une valeur fausse car le test porte sur la valeur des pointeurs et non les tableaux pointés par eux. Il faut utiliser la fonction strcmp :

i nt s t r cmp ( char * c1, char * c2) ;

Cette fonction retourne -1 si c1 est placée avant c2 dans l'ordre alphabétique, 0 si elles sont égales, 1 sinon. Précaution d'emploi : les pointeurs c1 et c2 ne doivent pas être nuls.

Exemple : ce qui marche

char * c1 = " bonj our " ; char * c2 = " bonj our " ; i f ( s t r cmp ( c1, c2) == 0) { / / début de conver sat i on }

A titre d’exemple, voici deux exemples d’ implémentations de la fonction strcmp : Exemple 1 : strcmp

i nt s t r cmp ( char * c1, char * c2) { i nt i = 0 ; whi l e ( ( c1 [ i ] == c2 [ i ] ) && ( c1 [ i ] ! = 0) && ( c2 [ i ] ! = 0) ) i ++ ; / * on r echer che l e pr emi er car act èr e di f f ér ent dans l es deux chaî nes * / i f ( c1 [ i ] < c2 [ i ] ) r et ur n - 1 ; el se i f ( c1 [ i ] == c2 [ i ] ) r et ur n 0 ; el se r et ur n 1 ; }

Exemple 2 : strcmp

i nt s t r cmp ( char * c1, char * c2) { whi l e ( ( * c1 == * c2) && ( * c1 ! = 0) && ( * c2 ! = 0) ) { c1++ ; c2++ ; } i f ( * c1 < * c2) r et ur n - 1 ; el se i f ( * c1 == * c2) r et ur n 0 ; el se r et ur n 1 ; }

4.2.2. Copie Exemple : ce qui ne marche pas

char * quest i on = " bonj our " ; char * r eponse = quest i on ;

Cette affection fonctionne et reponse sera bien égale à question étant donné que ces deux chaînes de caractères correspondront au même espace mémoire. Cet exemple mène au schéma suivant :

Deux pointeurs désignant le même tableau Le résultat souhaité était :

Deux pointeurs désignant deux tableaux différents. Il faut utiliser la fonction strcpy :

char * st r cpy ( char * dest , char * sour ce) ; Cette fonction copie source dans le tableau dest qui doit être suffisamment grand pour recevoir le contenu de source. La fonction retourne dest. Précaution d'emploi : les pointeurs source et dest ne doivent pas être nuls.

Exemple : ce qui marche

char * quest i on = " bonj our " ; char r eponse [ 20] ; s t r cpy ( r eponse, quest i on) ;

Exemple : plantage

char * quest i on = " bonj our " ; char r eponse [ 2] ; s t r cpy ( r eponse, quest i on) ;

Le tableau reponse n’est pas assez grand pour contenir la chaîne copiée. Le programme est correct mais le résultat obtenu n'est pas le résultat souhaité. Le programme plante de manière aléatoire.

4.2.3. Longueur

Il faut utiliser la fonction strlen :

i nt s t r l en ( char * ch) ; Cette fonction retourne la longueur de la chaîne de caractères sans tenir compte du caractère nul de fin de chaîne. Précaution d'emploi : le pointeur ch ne doit pas être nul.

Exemple : copie avec tableau dynamique

char * quest i on = " bonj our " ; char * r eponse ; r eponse = new char [ st r l en ( quest i on) +1] ; s t r cpy ( r eponse, quest i on) ;

4.3. Conversion

4.3.1. Du numérique vers l’alphanumérique Il existe plusieurs fonctions différentes mais la plus intéressante est la fonction sprintf qui permet de fusionner dans une même chaîne plusieurs informations de types différents.

i nt spr i nt f ( char * t ampon, char * f or mat , . . . )

Cette fonction prend un nombre indéterminé de paramètres : tampon le tableau de caractères qui recevra la concaténation de toutes

les informations format c'est également une chaîne de caractères qui contient les

informations nécessaires pour les conversions .... liste des variables à fusionner résultat retourné : le nombre de caractères inscrits dans tampon Exemple : sprintf

char t ampon [ 500] ; spr i nt f ( t ampon, " ent i er %d r éel %f r éel exponent i el %e " \ " r éel 2 chi f f r e avant , 3 déci mal es %2. 3g " \ " car act èr e %c " \ " chaî ne de car act èr es %s " , 5, 5. 6, 1e- 10, 3. 1416e- 45, ' A' , " exempl e" ) ;

Résultat :

ent i er 5 r éel 5. 600000 r éel exponent i el 1. 000000e- 010 r éel 2 chi f f r e avant , 3 déci mal es 3. 14e- 045 car act èr e A chaî ne de car act èr es exempl e

La fonction sprintf réalise une fusion dans tampon en remplaçant chaque code (% ...) par l'information qui lui correspond écrite grâce au format donné Exemple : concaténation de deux chaînes

char * c1 = " chaî ne1" ; char * c2 = " chaî ne2" ; char r esul t at [ 100] ; spr i nt f ( r esul t at , " %s%s" , c1, c2) ;

4.3.2. De l’alphanumérique vers le numérique La fonction sscanf est la réciproque de sprintf.

i nt sscanf ( char * t ampon, char * f or mat , . . . ) ;

tampon la chaîne de caractères contenant les informations séparées par d'autres caractères

format c'est également une chaîne de caractères qui contient les informations nécessaires pour les conversions.

... liste des variables à fusionner résultat retourné

le nombre de champs lus

Exemple : sscanf

char t ampon[ 500] = " 5 5. 600000 1. 00000e- 10 3. 14e- 045 A exempl e" ; i nt i ; doubl e d1, d2, d3 ; char c ; char chai ne [ 100] ; sscanf ( t ampon, " %d %l f %l f %l f %c %s" , &i , &d1, &d2, &d3, &c, chai ne) ;

La fonction sscanf place aux adresses qui lui sont fournies chaque information convertie grâce aux formats indiqués. Exemple : extraction d’une partie entière et décimale

char t ampon [ 500] = " 5. 6" ; i nt ent i er , deci m ; doubl e nombr e ; sscanf ( t ampon, " %l f " , &nombr e) ; sscanf ( t ampon, " %d. %d" , &ent i er , &deci m) ; pr i nt f ( " %g a pour par t i e ent i èr e %d et pour par t i e" \ " déci mal e %d" , nombr e, ent i er , deci m) ;

Résulat :

5. 6 a pour par t i e ent i èr e 5 et pour par t i e déci mal e 6

4.4. Exemple A partir d’une liste de personnages, il faut tirer aléatoirement des couples.

à Solution :

t ypedef st r uct { char * adv1 ; char * adv2 ; } Duel ; voi d mai n ( ) {

sr and ( c l ock ( ) ) ; i nt nb_gent i l = 15 ; i nt nb_mechant = 6 ; char * gent i l [ 15] = { " Cendr i l l on" ,

" Pet er Pan" , " Mi ckey" , " Har r y Pot t er " , " Bat man" , " Super man" , " Pl ut o" , " Spi der man" , " Amél i e Poul ai n" , " Bugs Bunny" , " Speedy Gonzal es" , " Robi n des boi s" , " Mer l i n" , " Mr Magoo" , " Dr oopy"

} ; char * mechant [ 10] = { " Le pr i nce Jean" ,

" Al i en" , " Gr osmi net " , " Vol demor t " , " Capi t ai ne Cr ochet " , " Bar be bl eue"

} ; i nt n ; f or ( n = 0 ; n < nb_gent i l ; ++n) { pr i nt f ( “ %d - %s\ n” , n, gent i l [ n] ) ; } pr i nt f ( “ \ n” ) ; f or ( n = 0 ; n < nb_mechant ; ++n) { pr i nt f ( “ %d - %s\ n” , n, mechant [ n] ) ; } pr i nt f ( “ \ n” ) ; i nt hasar d ; do { hasar d = r and ( ) + 1 ; } whi l e ( ( hasar d > nb_gent i l ) | | ( hasar d > nb_mechant ) ) ; Duel * duel = new Duel [ hasar d] ; i nt h1, h2 ; f or ( n = 0 ; n < hasar d ; ++n) { h1 = r and ( ) % nb_gent i l ; h2 = r and ( ) % nb_mechant ; duel [ n] . adv1 = new char [ st r l en ( gent i l [ h1] ) + 1] ; duel [ n] . adv2 = new char [ st r l en ( mechant [ h2] ) + 1] ; s t r cpy ( duel [ n] . adv1, gent i l [ h1] ) ; s t r cpy ( duel [ n] . adv2, mechant [ h2] ) ;

} i nt n ; f or ( n = 0 ; n < hazar d ; ++n) { pr i nt f ( “ %d - %s - %s\ n” , n, duel [ n] . adv1, duel [ n] . adv2) ; } f or ( n = 0 ; n < hasar d ; ++n) { del et e [ ] duel [ n] . adv1 ; del et e [ ] duel [ n] . adv2 ; } del et e [ ] duel ; }

V. Cinquième séance : les fichiers

fichier : "C:\Documents and Settings\Dupré\Mes documents\site\site_web\programmation\coursi.pdf"

5.1. Type de fichiers On distingue deux formats de fichiers : Les fichiers « texte » : ce sont des fichiers composés de caractères et qui sont lisibles par la plupart des applications. Les pages HTML sont des fichiers texte.

Les fichiers binaires : seul celui qui les a créés peut les lire, c’est le cas des fichiers "* .doc" créés par Word, seul Word peut en afficher le contenu. Pour s'en servir, une autre application aura besoin de convertir ce fichier au préalable. L’utilisation de ces fichiers évite de trop nombreuses conversions de données numériques en chaîne de caractères.

5.2. Accès aux fichiers Contrairement à la mémoire :

- les informations stockées dans les fichiers ne disparaissent pas lorsque l’ordinateur s’éteint

- leur capacité de stockage est aussi beaucoup plus grande En contrepartie :

- lire et écrire dans un fichier est beaucoup plus lent - il est difficile d’écrire et de lire en même temps

Pour écrire un fichier, il faut suivre le schéma suivant :

Ouvr ir

Si d’autres applications sont en train de modifier le fichier, cette étape ne peut aboutir. Si le fichier n’existe pas, il est créé. L’opération d’ouverture consiste à empêcher tout autre programme d’ intervenir lors du transfert d’ information de la mémoire vers le fichier.

Ecr ire

Les informations devant être écrites dans le fichier sont enregistrées les unes à la suite des autres.

Fermer

Le fichier est fermé, en d’autres termes, il est parvenu à sa forme définitive et peut dorénavant être lu ou modifié par d’autres applications ou celle qui l’a créé.

Pour lire un fichier, il faut suivre le schéma suivant :

Ouvr ir

Si le fichier n’existe pas, cette étape ne peut aboutir. Il est possible d’ouvrir plusieurs fois simultanément un même fichier en mode lecture.

Lire

Le format des fichiers fait qu’ il est plus commode de lire les informations les unes après les autres mais ce n’est obligatoire.

Fermer

Le fichier est fermé.

Il est important de fermer un fichier même en mode lecture car le système d’exploitation (Windows) ne peut ouvrir simultanément qu’un petit nombre de fichiers (quelques milliers).

5.3. Fonctionnement

5.3.1. Principe de la lecture La lecture dans un fichier est nettement plus lente que la lecture dans la mémoire. Il n'y a pas d'adresse disque mais une position courante (P) de la lecture dans le fichier.

L'accès à un fichier s'effectue séquentiellement contrairement à celui de la mémoire.

5.3.2. Principe de l’écriture

L'écriture dans un fichier fonctionne comme l'écriture d'un texte manuscrit : les informations s'ajoutent les unes à la suite des autres, la position courante (P) du fichier est toujours placée à la fin de celui-ci et se déplace avec elle.

5.4. Fonctions Toutes les fonctions qui suivent sont définies dans la librairie "stdio.h". Il faut donc inclure la ligne suivante au début du fichier source :

#i ncl ude " st di o. h"

5.4.1. Ouvrir La même fonction sert à ouvrir un fichier en mode lecture et en mode écriture.

FI LE * f open ( char * nom, char * acces) ;

nom nom physique du fichier (celui affiché par l'explorateur Windows)

(exemple : c:\windows\win.ini) acces chaîne de caractères précisant le type d'accès (voir ci-

dessous) résultat Un pointeur sur une structure qu'il n'est pas utile de

décrire. Cette structure sert d'intermédiaire entre le programme et le fichier tant que le fichier reste ouvert. Si le résultat est nul, le fichier n'a pu être ouvert.

access lecture écriture écriture ajout fichier "texte" " r " " w" " a" fichier binaire " r b" " wb" " ab"

Le mode « écriture ajout » consiste à continuer l’écriture d'un fichier déjà existant ou à la commencer si celui-ci n’existe pas.

5.4.2. Fermer La même fonction ferme un fichier quelque soit la manière dont il a été ouvert.

i nt f c l ose ( FI LE * f ) ;

f pointeur sur un fichier ouvert résultat retourné

0 si aucune erreur, une autre valeur sinon

Exemple : ouverture et fermeture d’un fichier

FI LE * f ; char f i chi er [ 100] = " c: \ \ pr emi er \ \ f i chi er . t x t " ; f = f open ( f i chi er , " r " ) ; i f ( f == 0) pr i nt f ( " l e f i chi er %s n' exi st e pas. " , f i chi er ) ; el se { / / . . . on peut l i r e f c l ose ( f ) ; }

5.4.3. Ecrire

5.4.3.1. Ecr ire dans un fichier binaire : fwrite L'écriture sous format binaire fait abstraction du type des données à écrire, elle se contente d'inscrire des octets par l'intermédiaire de la fonction fwrite.

t ypedef unsi gned i nt s i ze_t ; s i ze_t f wr i t e ( voi d * buf f er , s i ze_t s i ze, s i ze_t count , FI LE * st r eam ) ;

buffer adresse où se trouve les informations size taille d'un élément count nombre d'éléments à écrire stream pointeur sur fichier résultat le nombre d'éléments écrits, en principe égal à count sauf en

cas d'erreur (disque plein par exemple) Exemple : écr iture de 10 double sous format binaire (voir exemple lecture)

FI LE * f = f open ( " essai . bi n" , " wb" ) ; i f ( f ! = 0) { doubl e t [ 10] ; i nt n ; f or ( n = 0 ; n < 10 ; n++) { t [ n] = doubl e ( 1) / ( doubl e) ( n+1) ; } f wr i t e ( t , s i zeof ( doubl e) , 10, f ) ; f c l ose ( f ) ; }

Exemple : écr iture d’une structure (voir exemple lecture)

t ypedef st r uct { doubl e x ; i nt n ; } St ; FI LE * f = f open ( " essai . bi n" , " wb" ) ; i f ( f ! = 0) { St s ; s . x = 5. 5 ; s . n = - 1 ; f wr i t e ( &s, s i zeof ( St ) , 1, f ) ; f c l ose ( f ) ; }

5.4.3.2. Ecr ire dans un fichier texte : fprintf

i nt f pr i nt f ( FI LE * f , char * f or mat , . . . ) ;

Cette fonction prend un nombre indéterminé de paramètres : f le fichier qui recevra la concaténation de toutes les informations format c'est également une chaîne de caractères qui contient les

informations nécessaires pour les conversions. ... liste des variables à fusionner. résultat retourné

le nombre de caractères inscrit dans tampon

Cette fonction fonctionne exactement de la même manière que sprintf. Dans le fichier, les informations s'écrivent les unes à la suite des autres. Exemple : transfer t d’ information vers Excel, (voir aussi exemple lecture)

voi d mai n ( ) { FI LE * f ; f = f open ( " essai . t x t " , " w" ) ; i f ( f ! = 0) { i nt n ; f or ( n = 0 ; n < 10 ; n++) { f pr i nt f ( f , " %d\ t " , n) ; f pr i nt f ( f , " %f \ n" , doubl e ( 1) / ( ( doubl e) n+1) ) ; } f c l ose ( f ) ; } }

Résultat :

0 1. 000000 1 0. 500000 2 0. 333333 3 0. 250000 4 0. 200000 5 0. 166667 6 0. 142857 7 0. 125000 8 0. 111111 9 0. 100000

5.4.4. Lire

5.4.4.1. L ire dans un fichier binaire : fread La lecture est similaire à l'écriture.

t ypedef unsi gned i nt s i ze_t ; s i ze_t f r ead ( voi d * buf f er , s i ze_t s i ze, s i ze_t count , FI LE * st r eam ) ;

buffer adresse où doivent être stockées les informations size taille d'un élément count nombre d'éléments à lire stream pointeur sur fichier résultat le nombre d'élément écrit, en principe égal à count sauf en

cas d'erreur (le fichier ne contient plus assez d'éléments) Exemple : lecture de 10 double sous format binaire (voir exemple écriture)

FI LE * f = f open ( " essai . bi n" , " r b" ) ; i f ( f ! = 0) { doubl e t [ 10] ; f r ead ( t , s i zeof ( doubl e) , 10, f ) ; f c l ose ( f ) ; }

Exemple : lecture d’une structure (voir exemple écriture)

t ypedef st r uct { doubl e x ; i nt n ; } St ; FI LE * f = f open ( " essai . bi n" , " r b" ) ; i f ( f ! = 0) { St s ; f r ead ( &s, s i zeof ( St ) , 1, f ) ; f c l ose ( f ) ; }

5.4.4.2. L ire dans un fichier " texte"

a. lire un caractère

i nt f get c ( FI LE * f ) ;

Cette fonction retourne le caractère suivant dans le fichier pointé par f.

b. lire une ligne

char * f get s ( char * st r i ng, i nt n, FI LE * st r eam) ;

string tableau de caractères où doit être stockée la ligne n taille de ce tableau stream pointeur sur le fichier résultat string si aucune erreur, 0 sinon (fin de fichier)

Cette fonction lit une ligne de texte dans un fichier "texte" à condition que la longueur de cette ligne ne dépasse pas la capacité du tableau string. (une ligne se termine par le caractère '\n'). Exemple : affichage d’un fichier ligne par ligne

FI LE * f = f open ( " essai . t x t ” , “ r ” ) ; char l i ne [ 1000] ; char * r = f get s ( l i ne, 999, f ) ; whi l e ( r ! = NULL) { pr i nt f ( “ %s\ n” , r ) ; r = f get s ( l i ne, 999, f ) ; } f c l ose ( f ) ;

c. lire d’autres formats

i nt f scanf ( FI LE * f , char * f or mat , . . . ) ;

f le fichier contenant les informations format c'est également une chaîne de caractères qui contient les

informations nécessaires pour les conversions ... liste des variables à fusionner.

résultat retourné

le nombre de champs lus

Cette fonction fonctionne exactement de la même manière que sscanf. Néanmoins, il est difficile avec cette fonction de gérer les passages à la ligne dans les fichiers texte, on préfère utiliser conjointement fgets et sscanf. Les deux exemples qui suivent montreront l'écriture d'un fichier texte puis sa lecture. Exemple : lecture du fichier écr it lors d’un exemple précédent

voi d mai n ( ) { FI LE * f ; f = f open ( " essai . t x t " , " r " ) ; i f ( f ! = 0) { i nt i , n ; doubl e d ; char t [ 100] ; f get s ( t , 99, f ) ; n = sscanf ( t , " %d\ t %l f " , &i , &d) ; whi l e ( ( n > 0) && ( ! f eof ( f ) ) ) { pr i nt f ( " l us : %d\ t " , n) ; pr i nt f ( " i =%d\ t d=%d\ n" , i , d) ; f get s ( t , 99, f ) ; n = sscanf ( t , " %d\ t %l f " , &i , &d) ; } f c l ose ( f ) ; } }

Résultat :

5.5. Modifier la position courante Les fonctions présentées jusqu'à présent gèrent seules la position courante du fichier qui se déplace vers la fin du fichier au fur et à mesure que des octets y sont lus. Les fonctions suivantes permettent de gérer soi-même cette position.

l ong f t el l ( FI LE * st r eam) ;

Retourne la valeur de la position courante du fichier stream

i nt f seek ( FI LE * st r eam, l ong of f set , i nt or i gi n ) ;

Modifie la valeur de la position courante du fichier stream

offset nouvelle position courante origin origine à partir de laquelle est exprimé offset après l'appel de cette fonction la nouvelle position courante

devient : offset si origin == SEEK_SET position courante + offset si origin == SEEK_CUR fin du fichier + offset si origin == SEEK_END

Exemple : enregistrement de vecteurs de taille fixe dans un fichier

#i ncl ude " st di o. h" #i ncl ude " mat h. h" #i ncl ude " st dl i b. h" voi d mai n ( ) { FI LE * f = f open ( " essai . bi n" , " wb" ) ; doubl e x ; i nt n ; f or ( n = 0 ; n < 20 ; ++n) { x = cos ( n) ; f wr i t e ( &x, s i zeof ( doubl e) , 1, f ) ; } f c l ose ( f ) ; f = f open ( " essai . bi n" , " r b" ) ; i nt pos ; f or ( n = 0 ; n < 20 ; ++n) { pos = r and ( ) % 20 ; f seek ( f , pos * s i zeof ( doubl e) , SEEK_SET) ; f r ead ( &x, 8, 1, f ) ;

pr i nt f ( " pos = %d \ t cos ( pos) = %f \ t x = %f \ n" , pos, cos( pos) , x) ; } f c l ose ( f ) ; }

Résultat :

5.6. Er reurs fréquentes

5.6.1. Ecriture de structures en mode binaire contenant des chaînes de caractères Exemple : ce qui ne marche pas

t ypedef st r uct { doubl e x ; char * message ; } St ; FI LE * f = f open ( " essai . bi n" , " wb" ) ; i f ( f ! = 0) { St s ; s . x = 5. 5 ; s . message = new char [ 20] ; s t r cpy ( s. message, " er r eur " ) ; f wr i t e ( &s, s i zeof ( St ) , 1, f ) ; f c l ose ( f ) ; }

Dans cet exemple, la fonction fread écrit dans le fichier x tel qu'il est écrit en mémoire et la valeur du pointeur message qui n'a rien à voir avec son contenu. Le fichier "essai.bin" contient donc un réel et une adresse qui est différente à chaque exécution du programme. Exemple : ce qui marche

t ypedef st r uct { doubl e x ; char message [ 20] ; } St ; FI LE * f = f open ( " essai . bi n" , " wb" ) ; i f ( f ! = 0) { St s ; s . x = 5. 5 ; s t r cpy ( s. message, " er r eur " ) ; f wr i t e ( &s, s i zeof ( St ) , 1, f ) ; f c l ose ( f ) ; }

La taille de la structure est maintenant de :

1 * 8 + 20 * 1 = 28

5.7. Exemple : dessin d'un histogramme avec Excel L'objectif de cet exemple est :

1. créer sous Excel un tableau d'une seule colonne contenant 1000 réels obtenus par la formule :

( ) ( )()*()cos pialeaxf =

2. enregistrer ce tableau sous format "texte" 3. écrire un programme en C qui récupère les informations de ce fichier

"texte" dans un tableau et écrire dans un autre fichier les informations suivantes :

-1 nombre de réels compris entre -1.0 (inclus) et -0.9 (exclu)

-0.9 nombre de réels compris entre -0.9 (inclus) et -0.8 (exclu) -0.8 nombre de réels compris entre -0.8 (inclus) et -0.7 (exclu) -0.7 nombre de réels compris entre -0.7 (inclus) et -0.6 (exclu)

…

…

0.7 nombre de réels compris entre 0.7 (inclus) et 0.8 (exclu) 0.8 nombre de réels compris entre 0.6 (inclus) et 0.9 (exclu) 0.9 nombre de réels compris entre 0.5 (inclus) et 1.0 (exclu)

En récupérant le fichier sous Excel, une graphique X-Y doit donner le résultat suivant :

à Solution :

#i ncl ude " st di o. h" #i ncl ude " mat h. h" #i ncl ude " st dl i b. h" #i ncl ude " st r i ng. h" t ypedef st r uct { i nt nb ; doubl e * t ; } t abl eau ; t ypedef st r uct { i nt nb ; doubl e * x ;

doubl e * n ; } hi st ogr amme ; i nt nombr e_l i gne ( char * f i l e) { FI LE * f = f open ( f i l e, " r " ) ; i nt l i ne = 0 ; char buf f er [ 1000] ; char * b ; b = f get s ( buf f er , 999, f ) ; whi l e ( b ! = NULL) { l i ne++ ; b = f get s ( buf f er , 999, f ) ; } f c l ose ( f ) ; r et ur n l i ne ; } voi d l ect ur e ( char * f i l e, t abl eau &t ) { i nt nb_l i ne = nombr e_l i gne ( f i l e) ; t . nb = nb_l i ne ; t . t = new doubl e [ t . nb] ; FI LE * f = f open ( f i l e, " r " ) ; char buf f er [ 1000] ; char * c ; i nt n ; f or ( n = 0 ; n < t . nb ; ++n) { f get s ( buf f er , 999, f ) ; c = buf f er ; whi l e ( ( * c ! = 0) && ( * c ! = ' , ' ) ) ++c ; i f ( * c == ' , ' ) * c = ' . ' ; sscanf ( buf f er , " %l f " , &( t . t [ n] ) ) ; } f c l ose ( f ) ; } voi d ecr i t ur e ( char * f i l e, hi st ogr amme &h) { FI LE * f = f open ( f i l e, " w" ) ; i nt n ; f or ( n = 0 ; n < h. nb ; ++n) { f pr i nt f ( f , " %f \ t %f \ n" , h. x [ n] , h. n [ n] ) ; } f c l ose ( f ) ; } voi d hi st o ( t abl eau &t , hi st ogr amme &h, doubl e x1, doubl e x2, i nt nb) { h. nb = nb ; h. n = new doubl e [ nb] ; h. x = new doubl e [ nb] ; i nt n ; f or ( n = 0 ; n < nb ; ++n) {

h. n [ n] = 0 ; h. x [ n] = x1 + ( x2 - x1) * n / nb ; } i nt i nd ; f or ( n = 0 ; n < t . nb ; ++n) { i nd = ( i nt ) ( ( t . t [ n] - x1) * nb / ( x2 - x1) ) ; i f ( ( i nd >= 0) && ( i nd < h. nb) ) { h. n [ i nd] ++ ; } } } voi d mai n ( ) { t abl eau t ; hi st ogr amme h ; l ect ur e ( " essai . t x t " , t ) ; hi st o ( t , h, - 1, 1, 10) ; ecr i t ur e ( " hi st o. t xt " , h) ; }

6. Algorithme du plus court chemin

à Solution :

t ypedef st r uct { doubl e x ; doubl e y ; } Vi l l e ; / * * cet t e f onct i on const r ui t un t abl eau de bool éen à deux di mensi ons * per met t ant de savoi r s i deux v i l l es sont r el i ées ent r e el l es * bool * t = Ar et e_Const r ui t ( i nt nb_vi l l e) * t [ i ] [ j ] : l a v i l l e i est connect ée à l a v i l l e j * i ni t i al i se ce t abl eau de mani èr e à ce qu' aucune v i l l e * ne soi t connect ée à une aut r e * * ce t abl eau est à une di mensi on mai s est maqui l l é en un t abl eau * à une di mensi on * i l cont i ent nb_vi l l e* nb_vi l l e él ément s * t [ nb_vi l l e * i + j ] est l ' él ément t [ i ] [ j ] * * / bool * Ar et e_Const r ui t ( i nt nb_vi l l e)

{ bool * t = new bool [ nb_vi l l e * nb_vi l l e] ; i nt n ; f or ( n = 0 ; n < nb_vi l l e * nb_vi l l e ; ++n) { t [ n] = f al se ; } r et ur n t ; } / * * dét r ui t l e t abl eau des ar êt es * / voi d Ar et e_Det r ui t ( bool * t ) { del et e [ ] t ; } / * * r et our ne t r ue s i deux v i l l es sont r el i ées ent r e el l es * f al se s i non * l e t abl eau mat s i mul e une mat r i ce de bool éen * / bool Ar et e_Get ( i nt v1, i nt v2, i nt nb, bool * mat ) { r et ur n mat [ v1 * nb + v2] ; } / * * per met de modi f i er l e f ai t que deux v i l l es soi ent * connect ées ent r e el l es * f onct i on i nver se de l a pr écédent e, l a mat r i ce mat * doi t êt r e s i mét r i que pui squ' on par t du pr i nci pe * que deux v i l l es connect ées ent r e el l es l e sont * dans l es deux sens * / voi d Ar et e_Set ( i nt v1, i nt v2, i nt nb, bool * mat , bool ar et e) { mat [ v1 * nb + v2] = ar et e ; mat [ v2 * nb + v1] = ar et e ; } / * * r et our ne l a di st ance à vol d' oi seau ent r e deux v i l l es v1 et v2 du * t abl eau v * / doubl e Di st ance_Vi l l e ( i nt v1, i nt v2, Vi l l e * v) { doubl e x = v [ v1] . x - v [ v2] . x ; doubl e y = v [ v1] . y - v [ v2] . y ; r et ur n sqr t ( x* x + y* y) ; } / * * dessi ne l es v i l l es à l ' écr an * f onct i on ut i l i sée pour af f i cher t out es l es v i l l es * el l e r eçoi t comme par amèt r e l a di mensi on du t abl eau * et l e t abl eau des v i l l es * / voi d Dessi nVi l l eTout e ( i nt nb, Vi l l e * v) { / / l a coul eur de l ' écr i t ur e ne mar che pas encor e ChangeCoul eur ( 0) ; ChangeCoul eur Text e ( 0) ; char s [ 10] ; i nt n, a, b, c, d ; f or ( n = 0 ; n < nb ; ++n) {

/ / ( a, b) ( c, d) r epr ésent e l es coor données d' un r ect angl e / / dans l equel ser a dessi né un cer c l e symbol i sant une v i l l e a = ( i nt ) v [ n] . x - 5 ; b = ( i nt ) v [ n] . y - 5 ; c = ( i nt ) v [ n] . x + 5 ; d = ( i nt ) v [ n] . y + 5 ; / * on af f i che égal ement l e numér o de l a v i l l e au- dessus du cer c l e * / spr i nt f ( St r i ngS ( s) . Char ( ) , " %d" , n) ; Dessi nText e ( a, d, s, 3) ; / / on dessi ne une el l i pse pour l a v i l l e Dessi nFi l l El l i pse ( a, b, c, d) ; } } / * * af f i che une v i l l e et sa di st ance par r appor t * à l a v i l l e de dépar t * cet t e f onct i on est ut i l i sée au cour s de l ' al gor i t hme * af i n d' af f i cher l es s i t uat i ons i nt er médi ai r es * * n numér o de l a v i l l e * v t abl eau des v i l l es * di st di st ance à l a v i l l e de dépar t * coul coul d' af f i chage * / voi d Dessi nVi l l e ( i nt n, Vi l l e * v, doubl e di st , i nt coul ) { ChangeCoul eur ( coul ) ; ChangeCoul eur Text e ( coul ) ; char s [ 20] ; i nt a, b, c, d ; / / r ect angl e cont enant l ' el l i pse a = ( i nt ) v [ n] . x - 5 ; b = ( i nt ) v [ n] . y - 5 ; c = ( i nt ) v [ n] . x + 5 ; d = ( i nt ) v [ n] . y + 5 ; / / écr i r e l e numér o de l a v i l l e spr i nt f ( St r i ngS ( s) . Char ( ) , " %d" , n) ; Dessi nText e ( a, d, s) ; / / écr i r e l a di st ance de cet t e v i l l e à l a v i l l e de dépar t spr i nt f ( St r i ngS ( s) . Char ( ) , " %4. 0f " , di st ) ; Dessi nText e ( a, b- 10, s) ; Dessi nFi l l El l i pse ( a, b, c, d) ; } / * * dessi ne l ' ar êt e ent r e l a v i l l e v1 et l a v i l l e v2 * avec l a coul eur c * écr i t l a di st ance égal ement au mi l i eu de l ' ar êt e * / voi d Dessi nAr et e ( i nt v1, i nt v2, Vi l l e * v, i nt c) { ChangeCoul eur ( c) ; ChangeCoul eur Text e ( c) ; doubl e d = Di st ance_Vi l l e ( v1, v2, v) ; i nt x = ( i nt ) ( ( v [ v1] . x + v [ v2] . x) / 2) ; i nt y = ( i nt ) ( ( v [ v1] . y + v [ v2] . y) / 2) ; char s [ 50] ; spr i nt f ( St r i ngS ( s) . Char ( ) , " %4. 0f " , d) ;

Dessi nText e ( x, y, s, 3) ; Dessi nLi gne ( ( i nt ) v [ v1] . x, ( i nt ) v [ v1] . y, ( i nt ) v [ v2] . x, ( i nt ) v [ v2] . y) ; } / * * dessi ne t out es l es ar êt es à l ' écr an * / voi d Dessi nAr et eTout e ( i nt nb, Vi l l e * v, bool * ar et e) { i nt i , j ; f or ( i = 0 ; i < nb ; ++i ) { f or ( j = 0 ; j < nb ; ++j ) { i f ( Ar et e_Get ( i , j , nb, ar et e) ) Dessi nAr et e ( i , j , v , 5) ; } } } / * * af f i che l e t abl eau act uel avec pour chaque v i l l e * l a di st ance depui s l e poi nt de dépar t ( d) , * l a v i l l e pr écédent e dans l ' i t i nér ai r e * qui a per mi s un t r aj et aussi cour t * / voi d Af f i cheResul t at ( i nt nb, doubl e * d, i nt * pr ec, Vi l l e * v) { ChangeCoul eur ( 15) ; / / on ef f ace l ' af f i chage des r ésul t at s pr écédent s Dessi nFi l l Rect ( 0, 400, nb* 40+100, 500) ; char s [ 20] ; i nt n ; f or ( n = 0 ; n < nb ; ++n) { ChangeCoul eur ( 0) ; ChangeCoul eur Text e ( 0) ; / / on dessi ne l es t r oi s cases r el at i ves à l a v i l l e n Dessi nRect angl e ( n* 40+5, 395, n* 40+45, 425) ; Dessi nRect angl e ( n* 40+5, 425, n* 40+45, 455) ; Dessi nRect angl e ( n* 40+5, 455, n* 40+45, 485) ; / / on af f i che son numér o dans l a pr emi èr e case spr i nt f ( St r i ngS ( s) . Char ( ) , " %d" , n) ; Dessi nText e ( n* 40+10, 400, s, 3) ; / / on af f i che l a v i l l e pr écédent e dans l a seconde case spr i nt f ( St r i ngS ( s) . Char ( ) , " %d" , pr ec [ n] ) ; Dessi nText e ( n* 40+10, 430, s, 3) ; / / on af f i che l a di st ance de l a v i l l e n à l a v i l l e de dépar t / / dans l a t r oi s i ème case spr i nt f ( St r i ngS ( s) . Char ( ) , " %4. 0f " , d [ n] ) ; Dessi nText e ( n* 40+10, 460, s, 3) ; / / s i l a v i l l e a déj à ét é v i s i t é par l ' al gor i t hme / / on l a dessi ne d' une aut r e coul eur / / avec l a di st ance qui l a sépar e de l ' or i gi ne i f ( d [ n] ! = - 1) { Dessi nVi l l e ( n, v, d [ n] , 7) ; }

} } / * * r et our ne sous f or me de t abl eau l es numér os des v i l l es * qui f or ment l e pl us cour t chemi n * * v i s i t e r ecevr a l e nombr e de v i l l e de ce pl us cour t chemi n * ( c ' est pour quoi ce par amèt r e est passé par r éf ér ence) * * depar t v i l l e de dépar t * ar r i vee v i l l e d' ar r i vée * nb nombr e de v i l l e * v t abl eau des v i l l es * ar et e t abl eau des ar êt es ou connexi ons ent r e v i l l es * / i nt * Chemi nCour t ( i nt &vi s i t e, i nt depar t , i nt ar r i vee, i nt nb, Vi l l e * v, bool * ar et e) { / / cr éat i on du t abl eau des pr édécesseur s / / ce t abl eau conser ve pour chaque v i l l e / / l a v i l l e pr écédent e dans l ' i t i nér ai r e l e pl us cour t / / al l ant de l a v i l l e de dépar t j usqu' à cet t e v i l l e i nt * pr ec = new i nt [ nb] ; / / cr éat i on du t abl eau des di st ances depui s l a v i l l e de depar t / / ce t abl eau conser ve pour chaque v i l l e l a di st ance / / du pl us cour t chemi n l a r el i ant l a v i l l e de dépar t doubl e * di st = new doubl e [ nb] ; / / cr éat i on d' un t abl eau de bool éens per met t ant de savoi r / / s i une v i l l e a déj à ét é v i s i t ée à l ' i t ér at i on pr écédent e / / auquel cas el l e peut ser v i r de poi nt de dépar t pour l ' i t ér at i on / / sui vant e bool * per mi se = new bool [ nb] ; / / i ni t i al i sat i on i nt n ; f or ( n = 0 ; n < nb ; ++n) { pr ec [ n] = - 1 ; / / aucun pr édécesseur pour t out es l es v i l l es di st [ n] = - 1 ; / / donc aucune di st ance égal ement per mi se [ n] = f al se ; / / et aucune v i l l e n' a encor e ét é v i s i t ée / / par l ' al gor i t hme } / / except i on : l a v i l l e de dépar t di st [ depar t ] = 0 ; / / l a di st ance de v [ depar t ] / / à v [ depar t ] = 0 per mi se [ depar t ] = t r ue ; / / l a v i l l e a déj à ét é v i s i t ée pui sque / / c ' est l e poi nt de dépar t / / pr emi er af f i chage des t abl eaux à l ' écr an Af f i cheResul t at ( nb, di st , pr ec, v) ; / / on f ai t une pause Pause ( ) ; / / var i abl es i nt er médi ai r es, boucl e, messages char message [ 100] ; v i s i t e = 1 ; i nt i , j ; doubl e d ;

/ / boucl e : t ant qu' on n' est pas ar r i vé à l a v i l l e v [ ar r i vee] / / on cont i nue bool f i n = f al se ; / / condi t i on d' ar r êt whi l e ( ! f i n) { / / on suppose que cet t e i t ér at i on ser a l a der ni èr e f i n = t r ue ; / / à chaque i t ér at i on, on avance d' une v i l l e f or ( i = 0 ; i < nb ; ++i ) { / / on peut avancer d' une v i l l e depui s l a v i l l e i / / à condi t i on que l a v i l l e i ai t déj à ét é v i s i t ée / / et qu' el l e ne soi t pas l a v i l l e d' ar r i vée i f ( ( per mi se [ i ] ) && ( i ! = ar r i vee) ) { / / pour chaque v i l l e i / / on r egar de s i une aut r e v i l l e j l i ée à i / / a déj à ét é v i s i t ée, auquel cas, / / on compar e l e chemi n venant de i à cel ui déj à exi st ant / / s i ce n' est pas l e cas, ça l e devi ent f or ( j = 0 ; j < nb ; ++j ) {

i f ( ( i ! = j ) / / s i l a v i l l e i est aussi l a v i l l e j / / ce qui sui t n' a pas d' i nt ér êt && ( Ar et e_Get ( i , j , nb, ar et e) ) ) { / * s i l es v i l l es i et j sont connect ées * /

Dessi nAr et e ( i , j , v , 7) ; / / on dessi ne l ' ar êt e / / on cal cul e l a di st ance / / ent r e l es v i l l es i et j / / et on l ' aj out e à l a di st ance par cour ue / / j usqu' à / / j usqu' à l a v i l l e i depui s l a v i l l e de dépar t d = Di st ance_Vi l l e ( i , j , v) + di st [ i ] ; / / s i l a v i l l e j n' a pas encor e ét é v i s i t ée / / ou s i l a di st ance t r ouvée est i nf ér i eur e / / à cel l e / / dédui t es des i t ér at i ons pr écédent es i f ( ( d < di st [ j ] ) | | ( di st [ j ] == - 1) ) { / / l a di st ance du pl us cour t chemi n devi ent / / cel l e / / cal cul ée j ust e avant di st [ j ] = d ; / / l e nouveau pr édécesseur change égal ement pr ec [ j ] = i ; / / cet t e i t ér at i on n' est pas l a der ni èr e / / pui sque un i t i nér ai r e pl us cour t a ét é / / t r ouvé f i n = f al se ; } } } }

} / / r emi se à j our du t abl eau qui mémor i se l es v i l l es / / v i s i t ées / / l es v i l l es v i s i t ées sont cel l es de l ' i t ér at i on / / pr écédent e / / pl us t out es cel l es at t ei nt es en une connexi on à / / par t i r de cel l e / / de l ' i t ér at i on pr écédent e f or ( i = 0 ; i < nb ; ++i ) { per mi se [ i ] = di st [ i ] >= 0 ; } / / on af f i che l es r ésul t at s mi s à j our Af f i cheResul t at ( nb, di st , pr ec, v) ; Pause ( ) ; / / on i ncr ément e l e nombr e d' i t ér at i ons ++vi s i t e ; } / / r écupér at i on du r ésul t at / / l e chemi n l e pl us cour t cont i ent un nombr e de v i l l e / / f or cément i nf ér i eur ou égal à v i s i t e / / pr évoi r pl us un pour aj out er l a v i l l e de dépar t / / comme on ne connaî t que l es pr édécesseur s, / / on obt i ent l e bon chemi n dans l e sens i nver se i nt * r es = new i nt [ v i s i t e+1] ; i = 0 ; / / l e pr emi èr e v i l l e est l ' ar r i vée r es [ i ] = ar r i vee ; whi l e ( r es [ i ] ! = depar t ) { ++i ; / / on r emont e de v i l l e en v i l l e j usqu' à l a v i l l e / / de dépar t r es [ i ] = pr ec [ r es [ i - 1] ] ; } / / on r et our ne l e chemi n / / pour l ' obt eni r dans l e bon sens v i s i t e = i +1 ; f or ( i = 0, j = v i s i t e- 1 ; i < j ; ++i , - - j ) { n = r es [ i ] ; r es [ i ] = r es [ j ] ; r es [ j ] = n ; } / / l i bér at i on des t abl eaux i nt er médi ai r es del et e [ ] di st ; del et e [ ] pr ec ; del et e [ ] per mi se ; / / r et our ne l e r ésul t at r et ur n r es ; } voi d Hal Test Ensae_cour t _chemi n ( )

{ / / i ni t i al i sat i on Vi l l e v [ 15] ; i nt nb = 15 ; v [ 0] . x = 10 ; v [ 0] . y = 10 ; v [ 1] . x = 100 ; v [ 1] . y = 20 ; v [ 2] . x = 20 ; v [ 2] . y = 100 ; v [ 3] . x = 80 ; v [ 3] . y = 90 ; v [ 4] . x = 490 ; v [ 4] . y = 320 ; v [ 5] . x = 400 ; v [ 5] . y = 250 ; v [ 6] . x = 420 ; v [ 6] . y = 60 ; v [ 7] . x = 170 ; v [ 7] . y = 180 ; v [ 8] . x = 5 ; v [ 8] . y = 260 ; v [ 9] . x = 250 ; v [ 9] . y = 300 ; v [ 10] . x = 260 ; v [ 10] . y = 50 ; v [ 11] . x = 300 ; v [ 11] . y = 100 ; v [ 12] . x = 320 ; v [ 12] . y = 270 ; v [ 13] . x = 480 ; v [ 13] . y = 75 ; v [ 14] . x = 400 ; v [ 14] . y = 187 ; bool * ar et e = Ar et e_Const r ui t ( nb) ; Ar et e_Set ( 0, 1, nb, ar et e, t r ue) ; Ar et e_Set ( 0, 8, nb, ar et e, t r ue) ; Ar et e_Set ( 1, 2, nb, ar et e, t r ue) ; Ar et e_Set ( 2, 1, nb, ar et e, t r ue) ; Ar et e_Set ( 11, 12, nb, ar et e, t r ue) ; Ar et e_Set ( 0, 2, nb, ar et e, t r ue) ; Ar et e_Set ( 2, 3, nb, ar et e, t r ue) ; Ar et e_Set ( 1, 3, nb, ar et e, t r ue) ; Ar et e_Set ( 3, 8, nb, ar et e, t r ue) ; Ar et e_Set ( 7, 8, nb, ar et e, t r ue) ; Ar et e_Set ( 3, 10, nb, ar et e, t r ue) ; Ar et e_Set ( 10, 7, nb, ar et e, t r ue) ; Ar et e_Set ( 7, 11, nb, ar et e, t r ue) ; Ar et e_Set ( 8, 9, nb, ar et e, t r ue) ; Ar et e_Set ( 10, 6, nb, ar et e, t r ue) ; Ar et e_Set ( 5, 4, nb, ar et e, t r ue) ; Ar et e_Set ( 12, 4, nb, ar et e, t r ue) ; Ar et e_Set ( 14, 5, nb, ar et e, t r ue) ; Ar et e_Set ( 13, 4, nb, ar et e, t r ue) ; Ar et e_Set ( 13, 4, nb, ar et e, t r ue) ; Ar et e_Set ( 11, 6, nb, ar et e, t r ue) ; Ar et e_Set ( 9, 12, nb, ar et e, t r ue) ; Ar et e_Set ( 11, 14, nb, ar et e, t r ue) ; Ar et e_Set ( 14, 6, nb, ar et e, t r ue) ; Ar et e_Set ( 6, 13, nb, ar et e, t r ue) ; Ar et e_Set ( 3, 7, nb, ar et e, t r ue) ; / / dessi n des v i l l es Dessi nVi l l eTout e ( nb, v) ; / / dessi n des ar êt es Dessi nAr et eTout e ( nb, v, ar et e) ; / / on cher che à al l er de l a v i l l e 0 à l a v i l l e 4 i nt v i s i t e ; i nt * r es = Chemi nCour t ( v i s i t e, 0, 4,

nb, v, ar et e) ; / / on net t oi e l ' écr an des af f i chages i nt er médi ai r es Ef f acer ( ) ; Dessi nVi l l eTout e ( nb, v) ; Dessi nAr et eTout e ( nb, v, ar et e) ; / / on af f i che l e chemi n doubl e d = 0 ; Dessi nVi l l e ( 0, v, d, 9) ; i nt n ; f or ( n = 1 ; n < v i s i t e ; ++n) { Dessi nAr et e ( r es [ n- 1] , r es [ n] , v , 9) ; d += Di st ance_Vi l l e ( r es [ n- 1] , r es [ n] , v) ; Dessi nVi l l e ( r es [ n] , v , d, 9) ; } / / on dét r ui t t out ce qu' on a cr éé Ar et e_Det r ui t ( ar et e) ; del et e [ ] r es ; }

7. Index Basic.......................... 3 bibliothèque de fonctions................................................................................................32 conversion................. 7 définition

algorithme ..................................................................................................................3 allocation dynamique...............................................................................................39 boucle.......................................................................................................................13 chaîne de caractères..................................................................................................49 compilation.................................................................................................................3 édition de liens...........................................................................................................3 fonction ....................................................................................................................20

récursive.............................................................................................................25 indentation..................................................................................................................8 indice........................................................................................................................18 mot clé........................................................................................................................3 passage

référence............................................................................................................29 valeur .................................................................................................................29

pointeur multiple..............................................................................................................41

pointeur non typé......................................................................................................36 programme.................................................................................................................3 sous-programme.......................................................................................................20 structure....................................................................................................................19 surcharge..................................................................................................................28 tableau ......................................................................................................................17 test ..............................................................................................................................7

tests enchaînés..........................................................................................................11 variable.......................................................................................................................4

portée.................................................................................................................32 variable locale..........................................................................................................27

disque dur.................. 2 écran.......................... 2 erreur

C1004...................................................................................................................9, 25 C1071.........................................................................................................................4 C2057.......................................................................................................................18 C2059.....................................................................................................................5, 6 C2065.............................................................................................................5, 22, 32 C2100.......................................................................................................................36 C2143...................................................................................................................5, 14 C2146.........................................................................................................................5 C2181.........................................................................................................................9 C2440.................................................................................................................36, 37 C2447.......................................................................................................................24 C2466.......................................................................................................................18 C2601...................................................................................................................9, 25 C2660.......................................................................................................................23 C2664.................................................................................................................24, 30 C4138.........................................................................................................................5 LNK2001............................................................................................................25, 27

exemple adresse de variables locales......................................................................................48 affichage d’un fichier ligne par ligne.......................................................................63 allocation d'une matrice............................................................................................42 allocation dynamique...............................................................................................39 amélioration de la vitesse des programmes..............................................................45 arrondi ........................................................................................................................8 boucle infinie............................................................................................................14 calcul d'intégrale...................................................................................................2, 16 chaîne de caractères..................................................................................................49

comparaison.................................................................................................49, 50 copie...................................................................................................................51 copie...................................................................................................................52 copie, plantage...................................................................................................51 strcmp ................................................................................................................50

concaténation de deux chaînes.................................................................................53 conversion de pointeur .............................................................................................36 désallocation dynamique..........................................................................................40 désallocation dynamique répétées............................................................................40 écriture de 10 double................................................................................................60 écriture de structure contenant des chaînes de caractères..................................66, 67 écriture d'une structure.............................................................................................60 erreur dans les paramètres

nombre...............................................................................................................23 type....................................................................................................................23

erreur d'exécution (tableau)......................................................................................18

extra-caractère..........................................................................................................49 extraction partie entière et décimale ........................................................................54 factorielle..................................................................................................................25

pas d'arrêt...........................................................................................................26 fichier

ouverture, fermeture..........................................................................................59 fonction

déclarée mais pas définie...................................................................................25 imbrication impossible......................................................................................21 main ...................................................................................................................27 moyenne.............................................................................................................21 ordre de définition .............................................................................................23 oubli d'une accolade fermante...........................................................................24 point-virgule en trop..........................................................................................24 résultat non utilisé..............................................................................................22 sans résultat........................................................................................................26 somme................................................................................................................20

fonction locale..........................................................................................................21 lecture de 10 double.................................................................................................62 lecture du fichier texte..............................................................................................64 lecture d'une structure ..............................................................................................62 libération d'une matrice............................................................................................42 opérateur & ...............................................................................................................37 opérateur & et conversion de type ...........................................................................37 opérateur & et erreur de type....................................................................................37 opérateur XOR.........................................................................................................10 partie entière...............................................................................................................8 passage

erreur..................................................................................................................30 référence............................................................................................................29 tableau..........................................................................................................31, 39 tableau (structure) ..............................................................................................31 valeur .................................................................................................................29

pointeur ....................................................................................................................35 pointeur non typé......................................................................................................36 printf .........................................................................................................................16 signe d'un nombre..............................................................................................11, 13 somme de 1 à n.............................................................................................13, 14, 15 somme et somme pondérée......................................................................................27 sprintf .......................................................................................................................52 sscanf ........................................................................................................................53 structure

accès...................................................................................................................19 déclaration .........................................................................................................19

surcharge..................................................................................................................28 switch…case ............................................................................................................12 tableau ......................................................................................................................17

indice.................................................................................................................18 initialisation.......................................................................................................18

transfert d’ information vers Excel ...........................................................................61

variable.......................................................................................................................4 portée.................................................................................................................32

fichier binaire......................................................................................................................56 écrire.........................................................................................................................57 lire ............................................................................................................................57 position courante................................................................................................58, 65 texte..........................................................................................................................56

fonction fclose........................................................................................................................59 fgetc..........................................................................................................................63 fgets..........................................................................................................................63 fopen.........................................................................................................................59 fprintf........................................................................................................................61 fread..........................................................................................................................62 fscanf ........................................................................................................................63 fseek .........................................................................................................................65 ftell ...........................................................................................................................65 fwrite........................................................................................................................60 printf .........................................................................................................................16 sprintf .......................................................................................................................52 sscanf ........................................................................................................................53 strcmp.......................................................................................................................50 strcpy ........................................................................................................................51 strlen.........................................................................................................................52

imprimante................ 2 include..................... 32 inclusion de bibliothèques...............................................................................................32 instruction ................. 3 mémoire.................... 2 microprocesseur ........ 2 Microsoft Visual C++3 mot clé

case...........................................................................................................................12 char .............................................................................................................................7 default.......................................................................................................................12 do..............................................................................................................................15 double.........................................................................................................................7 else..............................................................................................................................7 else if ........................................................................................................................11 enum...........................................................................................................................7 false..........................................................................................................................10 for .............................................................................................................................13 if .................................................................................................................................7 int................................................................................................................................7 long.............................................................................................................................7 short............................................................................................................................7 struct .........................................................................................................................19 switch .......................................................................................................................12 true............................................................................................................................10

typedef ......................................................................................................................19 unsigned .....................................................................................................................7 void...........................................................................................................................26 while.........................................................................................................................14

opérateur ! 10 != ................................................................................................................................9 % ................................................................................................................................5 %= ..............................................................................................................................6 &&............................................................................................................................10 *=................................................................................................................................6 / 5, 6 ? 13 || 10 + 5 ++ ...............................................................................................................................5 += ...............................................................................................................................6 < 9 <= ...............................................................................................................................9 = 5 -= ................................................................................................................................6 == ...............................................................................................................................9 > 9 >= ...............................................................................................................................9 comparaison ...............................................................................................................9 double.........................................................................................................................6 logique......................................................................................................................10

outil ........................... 2 Pascal ........................ 3 périphériques............. 2 point d’entrée du programme..........................................................................................27 pointeur

arithmétique..............................................................................................................44 résumé graphique.....................................................................................................37 structure....................................................................................................................38

procédure................. 26 processeur ................. 2 règle........................... 3 remarque

boucle vide...............................................................................................................14 commentaire...............................................................................................................4 opérateurs...................................................................................................................6 opérateurs et affectation.............................................................................................6 point virgule...............................................................................................................5 surcharge..................................................................................................................28 variable et initialisation..............................................................................................5

table logique............ 10 tri ............................. 33 types numériques ...... 7 warning ..................... 7

C4244.........................................................................................................................7

8. Tables des matières détaillées I. Première séance : Variables, tests, boucles, fonctions ...............................................2

1.0. Quelques définitions utiles pour la suite.............................................................3 1.1. Variables.............................................................................................................3

1.1.1. Définition d’une variable.............................................................................3 1.1.2. Utilisation des variables...............................................................................6

1.2. Les tests...............................................................................................................8 1.2.1. Principe des tests..........................................................................................8 1.2.2. Opérateurs....................................................................................................9

1.2.2.1. Opérateurs de comparaison...........................................................9 1.2.2.2. Opérateurs logiques ....................................................................10

1.2.3. Tests enchaînés et autres écritures possibles .............................................11 1.2.3.1. Tests enchaînés...........................................................................11 Exemple : obtenir le signe d’un nombre..................................................12 1.2.3.2. test switch… case …...................................................................12 1.2.3.3. écriture abrégée...........................................................................13

1.3. Les boucles........................................................................................................14 1.3.1. Boucles for .................................................................................................14 1.3.2. Boucle while..............................................................................................15 1.3.3. Boucle do … while....................................................................................15

1.4. Exemple : écriture d'un programme calculant l'intégrale d'une fonction..........16 II. Seconde séance : tableaux, structures, fonction, passage des paramètres...............18

2.1. Tableaux............................................................................................................18 2.1.1. Définition et utilisation..............................................................................18 2.1.2. Indices........................................................................................................19 2.1.3. Initialisation ...............................................................................................19

2.2. Structures..........................................................................................................20 2.2.1. Définition...................................................................................................20 2.2.2. Utilisation...................................................................................................20

2.3. Fonction ............................................................................................................21 2.3.1. Définition...................................................................................................21 2.3.2. Appel d’une fonction .................................................................................22 2.3.3. Erreurs courantes .......................................................................................24

2.3.3.1. Erreur dans les paramètres..........................................................24 2.3.3.2. Point virgule après la déclaration d'une fonction........................25 2.3.3.3. Oubli d'une accolade fermante....................................................26 2.3.3.4. Fonction déclarée mais pas définie.............................................26

2.3.4. Fonctions récursives...................................................................................27 2.3.5. Fonction sans résultat.................................................................................27 2.3.6. Fonction main ............................................................................................28 2.3.7. Nom des fonctions.....................................................................................29

2.3.8. Variables locales........................................................................................29 2.3.9. Surcharge...................................................................................................29

2.4. Passage des paramètres.....................................................................................30 2.4.1. Passage par valeur......................................................................................30 2.4.2. Passage par référence.................................................................................31 2.4.3. Programmes équivalents............................................................................32 2.4.4. Passage de tableaux....................................................................................33

2.5. Portée d’une variable........................................................................................34 2.6. Bibliothèque de fonctions.................................................................................34 2.7. Exemple : un programme de tri ........................................................................34

III. Troisième séance : pointeurs..................................................................................37 3.1. Définition et utilisation.....................................................................................37

3.1.1. pointeur et variable ....................................................................................37 3.1.2. Pointeur non typé.......................................................................................38 3.1.3. Opérateur & ...............................................................................................39 3.1.4. Résumé graphique......................................................................................40

3.2. Pointeurs et structures.......................................................................................40 3.3. Pointeurs et tableaux .........................................................................................41 3.4. Allocations dynamiques....................................................................................41 3.5. pointeurs multiples............................................................................................44 3.6. Exemple............................................................................................................45 3.7. Arithmétique des pointeurs...............................................................................47 3.8. Erreurs courantes ..............................................................................................48

3.8.1. Pointeur non initialisé................................................................................49 3.8.2. Dépassement de limites..............................................................................49 3.8.3. Allocations successives..............................................................................50 3.8.4. Libération d’un mauvais pointeur..............................................................50 3.8.5. Libérer deux fois le même pointeur ...........................................................50 3.8.6. Mauvais ordre dans les libérations.............................................................50 3.8.7. Désallocation oubliée.................................................................................51 3.8.8. Adresse de variables locales......................................................................51

IV. Quatrième séance : les chaînes de caractères ........................................................52 4.1. Définition..........................................................................................................52 4.2. Traitement des chaînes de caractères................................................................53

4.2.1. Comparaison..............................................................................................53 4.2.2. Copie..........................................................................................................54 4.2.3. Longueur ....................................................................................................55

4.3. Conversion........................................................................................................56 4.3.1. Du numérique vers l’alphanumérique........................................................56 4.3.2. De l’alphanumérique vers le numérique....................................................57

4.4. Exemple............................................................................................................58 V. Cinquième séance : les fichiers...............................................................................60

5.1. Type de fichiers.................................................................................................60 5.2. Accès aux fichiers.............................................................................................61 5.3. Fonctionnement.................................................................................................62

5.3.1. Principe de la lecture..................................................................................62 5.3.2. Principe de l’écriture..................................................................................62

5.4. Fonctions...........................................................................................................63 5.4.1. Ouvrir.........................................................................................................63 5.4.2. Fermer ........................................................................................................64

5.4.3. Ecrire..........................................................................................................64 5.4.3.1. Ecrire dans un fichier binaire : fwrite .........................................64 5.4.3.2. Ecrire dans un fichier texte : fprintf ............................................65

5.4.4. Lire.............................................................................................................66 5.4.4.1. Lire dans un fichier binaire : fread .............................................67 5.4.4.2. Lire dans un fichier "texte" .........................................................68

5.5. Modifier la position courante............................................................................70 5.6. Erreurs fréquentes.............................................................................................71

5.6.1. Ecriture de structures en mode binaire contenant des chaînes de caractères..............................................................................................................................71

5.7. Exemple : dessin d'un histogramme avec Excel ...............................................72 6. Algorithme du plus court chemin ............................................................................75 7. Index ........................................................................................................................84 8. Tables des matières détaillées..................................................................................89