Types de donn

1
Types de données et représentation
B. Rouzeyre, Polytech'ERII
Langage C
2
Représentation des algorithmes
Organigramme façon graphique de représenter le
déroulement d'un calcul

• 1. Action de base
• 2. Séquencement
• 3. Bloc et niveau de détail

Action 1
Action 1
Action 2
Action 11
Action 1
Action 12
Action 2
3
Organigramme

• 4. Sélection

S Evi 1 et Evi.Evj 0

• Non structuré

Structuré
Action 1
Action 1
Ev.1
Action 21
Critère ?
Critère ?
Ev.2
Action 22
Ev.1
Ev.2
Ev.3
Ev.3
Action 23
Action 22
Action 21
Action 23
Action 3
Action 3
Se lit de haut en bas et de droite à gauche
Se lit en suivant les fils
4
Organigramme

• 4. Cas particulier alternative

• Non structuré

Structuré
Action 1
Action 1
Vrai
Action 21
Critère ?
Critère ?
Vrai
Faux
Faux
Action 22
Action 21
Action 22
Action 3
Action 3
5
Organigramme

• 5. Itérations exprime le fait que l'on répète
  une action

5.1 "Tant que"
Action 1
Action 1
Tant que critère vrai
Vrai
Faux
Critère
Action 2
Action 2
Action 3
Action 3
1 On évalue le critère 2 s'il est vrai on
effectue l'action 2, retour en 1 2 bis s'il est
faux on passe à la suite Remarque
éventuellement l'action 2 n'est pas exécutée
6
Organigramme

• 5. Itérations

5.2 "Jusqu'à ce que"
Action 1
Action 1
Jusqu'à ce que critère soit vrai
Action 2
Action 2
Faux
Vrai
Critère
Action 3
Action 3
1 On exécute l'action 2 s'il est faux, retour
en 1 2 bis s'il est vrai, on passe à la
suite Remarque l'action 2 est exécutée au
moins une fois
7
Organigramme

• 5. Itérations

5.3 "Pour tout e e E"
Action 1
Action 1
Pour chaque e de E
Vrai
Faux
e e E ?
Action 2
Action 2
Action 3
Action 3
e lt- valeur suivante de E
l'action 2 est exécutée autant de fois qu'il y
a d'éléments dans E
8
Organigramme conseil

• utiliser que les primitives précédentes
• intérêt traduction (presque) directe en C
• ne pas faire de spaghetti
• traduction difficile
• debug impossible
• résultat incompréhensible
• gt 0 à l'examen

Action 1
Vrai
Faux
e e E ?
Action 2
Action 3
e lt- valeur suivante de E
9
Organigramme exemple
x premier
S0
x premier
S0
x pair ?
fin faux
Tant que x pair et fin faux
S S x
S S x
fin v
x dernier ?
Vrai
x dernier ?
Faux
x suivant
x suivant
Imprimer S
Imprimer S
OK
KO
10
Codage d'un algorithme en C

• Les actions ou "instructions" en langage C ne
  sont en fait que des opérations élémentaires
  (,-, etc) sur des données unitaires.
• Chaque instruction est suivie d'un
• Le début d'un bloc est signalé par un , la fin
  d'un bloc par . Un bloc devient l'équivalent
  syntaxique d'une instruction.
• Ex

x1 y2 zxy printf("d",z)
x 1
y 2
Calcul
z xy
imprimer z
optionnel
11
Codage d'un algorithme en C

• Alternative
• if (expression) action1
• else action2

fin de l'instruction if
if (z 3) printf("calcul
juste") zz10 else printf
("problème") printf ("d",z)
calcul
"calcul juste"
Vrai
z3 ?
z z10
Faux
"problème"
Imprimer z
12
Codage d'un algorithme en C

• Cas particuliers de alternative

if (z 3) else printf("problème) printf
("d",z)
calcul
Vrai
z3 ?
"problème"
Faux
Imprimer z
13
Codage d'un algorithme en C

• Cas particuliers de alternative

if (z 3) printf("calcul
juste") zz10 else printf ("d",z) ou
bien if (z 3) printf("calcul
juste") zz10 printf ("d",z)
calcul
"calcul juste"
Vrai
z3 ?
z z10
Faux
Imprimer z
14
Codage d'un algorithme en C

• Sélection multiple en C, la sélection ne peut
  être qu'une comparaison à des valeurs de
  constante (si besoin passer à plusieurs if
  imbriqués)

Action 1
z3
"ok"
z ?
z4
"PB1"
autres
"PB2"
Action 3
switch (z) case 3 printf("ok")
break case 4 printf("PB1") break default
"printf ("PB2")
15
Codage d'un algorithme en C

• Structures itératives. Exemple, on veut imprimer
  tous les nombres de 1 à 10
• TANT QUE while (condition) action

x1 while (x lt10) printf("d\n",x) xx1

x1
Tant que x 10
imprimer x
xx1

• JUSQU'À CE QUE do action while (condition)

x1 do printf("d\n",x) xx1 while (x
lt 11)
Jusqu'à ce que x gt11
x1
imprimer x
xx1
16
Codage d'un algorithme en C

• POUR

Pour x E 1,2,,10
for(x1 x10 xx1) printf("d\n",x)
imprimer x

• équivalent TANT QUE

x1 while (x lt10) printf("d\n",x) xx1

x1
Tant que x 10
imprimer x
xx1
17
Compîlteurs

• Sur le web
• ideone.com (pour le début)

• En TP
• Visual C

18
Types de données

• 3 types de base
• caractères
• ex 'a', '1', '\n'
• entier relatifs
• ex 0 , -12, 328
• réel
• 3.14, 2.3 e4
• Remarques
• Pas de booléen (vrai, faux)
• Pas de type chaînes de caractères prédéfini

19
Type caractère

• Caractère Symboles alphanumériques (a,z,!,1,9)
  caractères spéciaux (retour à la ligne, beep,
  etc..)
• Un caractère est représenté sur un octet (8 bits)
  suivant la table ASCII (American Standard Code
  for Information Interchange)
• ex 'a' 9710 6116 0110 00012
• Table ASCII
• ex code ASCII du 'A' 65
• 'A'lt'B'lt..lt 'Z'
• '0'lt'1'lt'2'lt..lt'9'
• 'a'lt'b'lt.lt'z'
• Déclaration de variable de type caractère
• char c
• c 'a'
• Constante de type caractère
• define caractère_a 'a'

20
(No Transcript)
21
Table ASCII
char

• Remarques
• les chiffres sont codés suivant un ordre
  croissant (48 à 57)
• idem pour les lettres (65 à 90, 97 à 122)
• code des majuscules est inférieur au code des
  majuscules (différence constante 32)
• les codes supérieurs à 128 dépendent de la langue
  
• é, ö , ä, æ, œ etc
• Déclaration d'une variable caractère
• char c
• c'a'
• ..

22
Type caractère

• Caractères spéciaux (retour à la ligne,
  tabulation etc..)
• Exemple
• retour à la ligne CR code ASCII 13
• char retour
• retour 13 ou bien retour '\n'
• Conventions
• \n retour à la ligne
• \t tabulation
• \f nouvelle page
• \' apostrophe
• \0 caractère nul (indique la fin d'une chaîne
  de caractères)

23
Les entiers entiers naturels

• Codage sur 2 ou 4 octets suivant le calculateur
• Sur deux octets on peut coder les nombres de 0 à
  216-1 (0 à 65535)
• Nombre représenté en base 2, les bits sont rangés
  dans des cellules correspondant à leur poids, on
  complète à gauche par des 0
• Exemple
• 13 8 4 1 123122021120
• 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1
• Déclaration d'une variable entier naturel x
• unsigned int x
• short unsigned int x (on force sur 16 bits)
• long unsigned int x (on force sur 32 bits)

24
Type entier relatif

• Implantation sur 2 ou 4 octets suivant le
  compilateur
• Représentation sur n bits codage complément à 2
• Déclarations
• int a,b
• .
• a 1
• .
• b 3

25
Type entier relatif

• Codage complément à 2
• Si xn-1 0 nombre positif, xn-1 1 nombre
  négatif
• Exemple sur 16 bits
• 5 1 22 0 21 1 20 0000 0000 0000
  0101
• -3 -32768 32765
• -215 214 213 212 211 210 29 28
  27 26 25 24 23 1.22 0. 21 1.20
• 1111 1111 1111 1101
• Sur 16 bits (2 octets)
• -32768 ? x ? 32767
• Sur 32 bits
• -2147483648 ? x ? 2147483647

26
Complément à 2

• Représentation non symétrique le plus petit
  nombre n'a pas d'opposé sur n bits
• le plus grand entier positif est 2n-1-1
• le plus petit entier négatif est -2n-1
• sur 3 bits

000
001
111
0
1
-1
110
010
2
-2
3
-3
-4
011
101
100
27
Codage complément à 2

• Remarques
• 1/ Complément à 2 de x Complément à 1 de x 1
• représentation de 3 ?
• 3 0000 0000 0000 0011
• c1(3) 1111 1111 1111 1100
• 1 0000 0000 0000 0001
• c1(3) 1 1111 1111 1111 1101
• 2/ Représentation 16 bits gt 32 bits
• x gt0 0000 0000 0000 0011 gt x 0000 0000 0000
  0000 0000 0000 0000 0011
• x lt0 1111 1111 1111 1101 gt x 1111 1111 1111
  1111 1111 1111 1111 1101
• Extensions
• int 2 ou 4 octets ? problème de portabilité
• short int x 2 octets
• long int x 4 octets
• unsigned int x bit de signe utilisé pour la
  valeur
• unsigned short int x
• unsigned long int x

28
Type réel

• Déclaration
• float x,y
• x 3.14
• y 2.0 e3
• Implantation sur 4 octets
• Représentation suivant le compilateur
• en général mantisse exposant (norme IEEE)
• 10-38 lt x lt 1038
• Extension
• double x x est codé sur 8 octets

29
Nombre réels

• Codage des réels virgule flottante, Norme IEEE
• flottant stocké sous la forme M BE
• M Mantisse B Base E Exposant
• exemple 123 . 103 123 000
• Représentation IEEE 754 (signe 1 bit, mantisse
  et exposant sur 32 ou 64 bits pour simple et
  double précision)
• SM signe de la mantisse 1 bit
• Eb exposant biaisé 8 ou 11 bits
• M Mantisse 23 ou 52 bits

SM
Eb
M
30
Mantisse et exposant

• Signe bit de poids fort (0 1 -)
• Exposant
• placé avant la mantisse pour simplifier les
  comparaisons (pour ceci il ne doit pas être
  représenté en complément à deux -1 gt 2)
• sur 8 bits 0..256
• sans signe mais biaisé de 127 (simple précision)
  
• Eb 1 ? E 1 127 -126
• Eb 254 ? E 254 127 127
• les exposants 255 (erreur) et 0 (nb dénormalisé)
  sont interdits
• Mantisse
• normalisée bit de poids fort nest pas 0 et un
  seul chiffre avant la virgule
• ex 11,012 1,101 21

31
Virgule Flottante

• Comme le bit de poids fort de la mantisse est
  nécessairement 1 on ne lindique pas
  (gaspillage de place), il est implicite
• Mantisse
• partie fractionnaire f1f2 fn ? m 1,f1f2fn
• nombre x (-1)SM 1,M 2Eb-127
• Exemple
• x (-2,5)10 -1,01212
• SM 1
• E 1 gt Eb 128 1000 0000
• m1,01 gt M 010.0
• Déclaration de variables réelles
• float x
• double y

32
Variables

• Variable élément de mémorisation élémentaire
• Toutes les variables doivent être déclarées
  suivant un type
• int a, b ou bien int a
• int b
• float x
• char caractere
• Identificateur de variables (noms)
• Le premier caractères doit être une lettre
• Les autres caractères sont les lettres
  (majuscules et minuscules), les chiffres et le
  caractère _
• Majuscule / minuscule significatifs
• Exemples
• Pi, pi3_14, a2B3 corrects
• 2x,i-E incorrects
• A1 ? a1

33
Variables

• Exemple
• char a
• int un
• a 'a'
• un 1
• a '1'
• Initialisation des variables
• à l'exécution
• int i
• .
• i 0
• à la compilation
• int i 0

34
Conversion de type

• Conversion explicite ( type ) expression
• Exemple
• int a float x char c
• a2
• x(float) a
• x2.3
• a (int) (x1)
• a 98
• c (char) a -gt c'b'
• Conversion implicite
• Exemple
• int a float x char c
• a2
• x a
• x2.3
• a x1
• a 98
• c a -gt c'b'

35
Conversion de types

• Exemples
• char c int i float f
• // conversion entier vers char.
• c98 // implicite c prend le code ASCII 98
  c-à-d b'
• c (char) 98 // explicite plus propre
• // char vers entier
• i 'a' // i prend la valeur 97
• i (int) 'a' //plus propre
• // entier vers réel
• f3 // f prend la valeur 3.0
• f(float) 3 // propre
• //réel vers entier, attention troncature
• i 3.4 // i prend la valeur 3
• i -3.3 // i prend la valeur -3
• i (int) 3.4 // propre

36
Conversion de types application

• Passer au caractère suivant
• char c
• c 'a'
• c c1 // calcul fait en entier puis résultat
  converti en char
• c (char) ((int) c1) // propre
• Conversions majusculelt-gt minuscule
• char c
• c't'
• // conversion en Majuscule
• cc-32 // c contient 'T'
• ou mieux
• cc-('a'-'A')
• cc1 // c contient 'U'
• // conversion en minuscule
• cc32
• ou cc('a'-'A')
• // conversion en Majuscule

37
Tableaux

• Lorsque on veut mémoriser plusieurs données de
  même type, on peut utiliser un tableau c-à-d on
  regroupe sous un même nom plusieurs informations
• Exemple de déclaration d'un tableau d'entiers
• int tab100
• int type des éléments du tableau
• tab identificateur (nom du tableau)
• 100 nombre d'éléments du tableau (dimension)
• tab peut recevoir 100 entiers identifiés de 0 à
  99 (attention !)
• le premier est tab0
• le second tab1
• ..
• le dernier tab 99

38
Tableaux

• Utilisation
• chaque élément du tableau est accessible par un
  indice qui doit être de type entier, quelque soit
  le type des éléments du tableau
• exemples
• int i
• tab2 3eme élément du tableau
• tab23 6eme élément du tableau
• tabi i1eme élément du tableau
• Exemples
• stocker les 100 premiers nombres pairs
  0,2,4,...,196,198
• int i, t100
• for (i0 i lt 100 ii1)
• ti 2i

39
Tableaux

• Remarques
• 1/ chaque élément du tableau s'utilise comme une
  variable
• tab3 2
• 2/ le nombre maximum d'éléments du tableau
  (dimension)
• 1/ doit être fixé à la compilation
• 2/ ne peut être modifié pendant l'exécution
• 3/ Pas d'opérations sur les tableaux en tant que
  tels

40
Parcours des éléments dun tableau

• Parcours du premier au dernier
• int i / lindice de balayage doit être un
  entier /
• float t100 / le type du tableau est
  quelconque, ici réel /
• for (i0 i lt 100 ii1) // ou bien for (i0 i
  lt 99 ii1)
• ti .
• Parcours du dernier au premier
• int i / lindice de balayge doit être un
  entier /
• float t100 / le type du tableau est
  quelconque /
• for (i99 i gt 0 ii-1)
• ti .

41
La dimension

• Bonne pratique de programmation
• int i
• int t100
• for (i0 i lt 100 ii1)
• ti 100
• Pb modification du pgm, changement de la taille
  du tableau malaisée
• define TAILLE 100
• int i
• int tTAILLE
• for (i0 i lt TAILLE ii1)
• ti 100
• Il suffit de changer TAILLE

42
Exemples
Point de l'espace 1ere solution float
x,y,z 2eme solution float pt3 pt0 pour
x, pt1 pour y, pt2 pour z Mémorisation des
100 premiers nombres pairs et impairs int
pairs100, impairs100 int i for (i0
ilt100ii1) pairsi2i impairsi2i1

43
Chaînes de caractères

• En c, pas de type prédéfini chaîne de caractères.
  En pratique on utilise des tableaux de
  caractères.
• Convention le dernier caractère utile est suivi
  du caractère \0 (de code ascii 0)
• Exemples
• char t10 (9 caractères max, puisque une case
  réservée pour \0
• strcpy(t,"abcdefghi")
• chaque lettre est accessible par l'indice
• char t12
• strcpy(t,"abcdefghi")
• Initialisation char t12 "abcdefghi" ou char
  t "abcdefghi"
• Constante chaîne de caractères
• define ceciestuntexte "azssddqsdqsd"

44
Définitions de type utilisateur

• typedef int entier (entier est maintenant un
  type)
• entier i
• typedef int tableaude2020
• tableaude20 t ? int t20

45
Les expressions en langage C
46
Expressions introduction

• Remarque expression ? instruction
• une instruction indique à l'ordinateur de mener
  une action
• expression élément syntaxique
• Expressions
• variable ou constante, ex x, 3
• constituées à l'aide d'opérateurs x y
• conversion de type, opérateurs arithmétiques, de
  taille, relationnels et logiques, affectation,
  bit-à-bit, conditionnels, adresse

47
Expressions

• Une expression représente une donnée élémentaire
  constante, variable, un élément de tableau, la
  référence à une fonction ou à une valeur, le
  résultat d'un calcul etc .
• Exemples
• 3
• ab
• xy
• c ab
• x lt y
• x y
• i
• sin(3.14)
• Toute expression a une valeur

48
Opérateurs arithmétiques

• Opérateurs bi-opérandes
• , -
• , / , (modulo)
• Les opérandes doivent être des valeurs
  numériques.
• entier opérateur entier -gt résultat entier
• réel opérateur réel -gt résultat réel
• entier opérateur réel -gt résultat réel
• Exemples

int a,b a10 b 3 ab 13 a-b 7 ab 30 a/b 3
(division euclidienne) ab 1
float a,b a12.6 b 3.0 ab 13.6 a-b 9.6 ab
37.8 a/b 4.2 (division réelle) ab erreur de
syntaxe
49
Opérateurs arithmétiques

• Opérateur
• - int a flloat x
• (ax) 4 incorrect. ((int) (ax))4 correct
• - si l'un des opérandes est négatif, le résultat
  est négatif.
• Si l'un des opérandes est de type caractère,
  c'est la valeur du code ASCII qui est prise
  (conversion implicite char vers int ou float)
• Conversion majuscule ? minuscule

Exemple char c 'a' c c1 gt c
'b' mécanisme c1 98 1 99 c code
ascii 99 'c'
Exemple char c if (c gt 'a' c lt'z') c
c-32 (ou bien c c 'A' 'a') if (c gt 'A' c
lt'Z') c c32 (ou bien c c - 'A' 'a')
50
opérateurs arithmétiques

• Opérateurs unaires (un opérande)
• a/ signe , -
• exemple a -a
• b/ incrémentation, décrémentation (1) , --
  (-1)
• exemple
• int i 1
• i
• printf("d",i) -gt 2
• Syntaxes i ou i
• i la valeur de i est d'abord incrémenté, la
  valeur résultat est utilisée dans l'expression
  courante
• i la valeur courante de i est utilisée dans
  l'expression courante, puis i est incrémenté

51
et --

• Exemples
• i1 i1
• printf("i d\n",i) -gt i1 printf("i
  d\n",i) -gt i1
• printf("i d\n",i) -gt i2 printf("i
  d\n",i) -gt i1
• printf("i d\n",i) -gt i2 printf("i
  d\n",i) -gt i2
• Conclusions
• 1/ appendre la règle (pour comprendre des
  programmes)
• 2/ à n'utiliser que lorsque il n'y a pas
  d'ambiguïté
• xyz // à éviter
• x // pas de risque

52
Opérateurs d'affectation

• Affectation simple
• syntaxe variable expression
• la valeur de l'expression est stockée dans la
  mémoire à l'endroit réservé pour la variable
• Exemples
• a 2 b1 c0
• a bc
• a b c
• la valeur de l'expression vaut la valeur affectée
• Attention affectation et test d'égalité
• if (a 1) instruction1 else instruction2
• L'instruction1 est toujours déclenchée.
• a b 3 (évaluation de droite à gauche)

53
Opérateurs d'affectation

• Affectation et opération , -, , /, ,ltlt
  , gtgt, , ,
• Syntaxe variable opérateur expression
• équivalent à variable variable opérateur
  expression
• Exemple
• int i
• i 3
• i2 (ii2)
• printf("d\n",i) -gt 5

54
Opérateurs relationnels et logiques

• Valeur logique
• 0 faux
• ? 0 vrai
• exemple if (3) traitement1 else traitement 2
  
• équivalent à traitement1
• Relationnels gt , gt , , lt, lt , !
• La valeur de l'expression est 1 si l'expression
  est vraie , 0 si elle est fausse
• Exemple 2 lt 3 vaut 1 , 2 gt 3 vaut 0
• Attention à la confusion test d'égalité et
  l'affectation
• ex if (x0) traitement 1 // au lieu de x0
• else traitement 2
• Conséquence non seulement le traitement 1 ne
  sera jamais exécuté mais en plus x vaudra 0
  quelle que soit sa valeur initiale
• Logiques "et" logique , "ou" logique, !
  "non" logique
• Dans l'évaluation de l'expression, 0 est
  considéré comme la valeur logique "faux", toute
  valeur ? 0 comme la valeur logique "vraie"
• La valeur de l'expression est 1 ou 0
• Exemples

55
Opérateurs bit à bit

• Opèrent sur les représentations des valeurs
• et , ou, ou-exclusif, complément à 1 ,
• ltlt décalage à gauche, gtgt décalage à droite,
• Attention ?
• Exemples
• 5 0000 0000 0000 0101
• 20 0000 0000 0001 0100
• 5 20 0000 0000 0000 0100 gt 5 20 gt 4
• 5 20 0000 0000 0001 0101 gt 5 20 gt 21
• 5 20 0000 0000 0001 0001 gt 5 20 gt 17
• 5 1111 1111 1111 1010 gt -6
• Affectation/bit-à-bit , , ,

56
Décalages

• Décalages
• à gauche a ltlt b a est décalé à gauche de b bits
  (les bits ajoutés valent 0)
• 5 ltlt 2 0000 0000 0001 0100 20
• un décalage d'une position à gauche correspond à
  une multiplication par 2
• à droite a gtgtb a est décalé à droite de b bits
  (les bits insérés valent le bit de poids fort)
• 14 0000 0000 0000 1110
• 14 gtgt 2 0000 0000 0000 0011 3
• -6 1111 1111 1111 1010
• -6 gtgt 1 1111 1111 1111 1101 -3
• un décalage d'une position à droite correspond à
  une division par 2 (en respectant le signe)

57
Opérateur conditionnel

• Syntaxe
• expression1 ? expression2 expression3
• à peu près équivalent à
• if (expression1) expression2 else expression3
• Exemple
• maximum (xgty) ? x y
• if (xgty) maximum x else maximum y
• Conseil ne pas utiliser (peu clair)

58
Opérateurs d'adressage

• Adresse de
• Syntaxe variable , donne l'adresse mémoire de
  la variable
• Exemple
• int i,adr
• adr i
• ne pas confondre avec le "et" bit à bit
• Dont l'adresse est
• Syntaxe expression donne le mot mémoire dont
  l'adresse est donnée par l'expression
• Exemple
• int i,adr
• i1
• adr i
• printf("d", adr) -gt 1

59
Opérateur de taille sizeof

• Donne la taille de l'implantation
• 2 syntaxes
• 1/ sizeof expression
• exemple
• int i,j
• j sizeof i -gt 2 ou 4 (octets)
• 2/ sizeof (type)
• exmples
• typedef char tab100
• tab t
• int n
• n sizeof(int), -gt 2 ou 4 (octets)
• n sizeof(tab) -gt 100 (char)

60
Opérateurs divers

• ( ) force l'ordre des calculs
• ex 1 2 3 -gt 7
• (12) 3 -gt 9
• pour les tableaux
• t2 équivalent à (t2)
• -gt et . (opérateurs sur structures, tard)

61
Priorité des opérateurs
 
62
Priorité des opérateurs

• a b /c d
• (a-b) / (c-d)
• i j k 0
• a1 b4
• ! --a !b
• !0 0
• 1 1
• 1

63
Priorité des opérateurs (exercices)

• main()
• int x, y , z
• x 2
• x 3 2 printf("d\n",x)
• x - y z 4 printf("ddd\n",x,y,z)
• x y z printf("ddd\n",x,y,z)
• x (y z) printf("ddd\n",x,y,z)
• x 3 y 2 z 1
• x x y z printf("d\n", x)
• printf ("d\n", x ! y z)
• x y 0
• z x -1 printf ("d, d\n", x, z)
• z -x y printf ("d, d\n", x, z)
• x 1 y 1
• printf("d\n", ! x x)
• printf("d\n", x x)

64
Priorité des opérateurs (exercices)

• x 0 y 0 z0
• xyz
• printf("d\n", x lt y ? y x)
• printf("d\n", x lt y ? x y)
• printf("d, d\n", x , y)
• printf("d\n", z x lt y ? x y)
• printf("d, d\n", y , z)
• x 3 y z 4
• printf("d\n",( z gt y gt x) ? 1 0)
• printf("d\n", z gt y y gt x )
• x y z 0

65

• ENTREES / SORTIES

66
Les entrées/sorties (lecture/écriture)

• Lecture clavier
• 2 fonctions de base getchar () et scanf()
• Elles peuvent être appelées soit indépendamment
  soit au sein d'expressions
• Exemples
• getchar()
• while (cgetchar()) ..

67
getchar()

• getchar() sert à la lecture de caractères
  isolés
• la valeur de getchar() est le code ascii du
  caractère lu
• utilisation
• char c
• c getchar()
• Exemple on veut lire et mémoriser 2 caractères
  donnés sur 2 lignes différentes
• char c1,c2
• c1 getchar() // acquiert le 1er caractère
• getchar () // filtre le ltcrgt, on ne mémorise
  pas la valeur lue
• c2 getchar () // acquiert le 2ème caractère

68
scanf ()

• Sert à la lecture de données et convertit la
  succession de caractères donnés en entiers,
  flottants, caractères, chaîne de caractères
• Syntaxe
• scanf (format,arg1,arg2,,argn)
• le nombre d'arguments est quelconque
• arg1, arg2,, argn sont les adresses des
  variables dans lesquelles on stocke les valeurs
  lues
• variable simple (entier, caractère, flottant)
  v
• chaîne de caractères tableau v
• le format est une chaîne de caractères précisant
  le type des arguments afin de convertir la suite
  de caractères lus dans les arguments

69
Scanf format

• Format
• chaîne de caractères composée de caractères
  suivis d'une lettre et éventuellement séparés par
  des blancs
• la lettre indique le type de conversion à
  effectuer
• exemple
• int i float x
• scanf("d f", i,x)
• le d indique que le premier argument est un
  entier
• le f indique que le second est un réel
• réponse 23?12.6
• 23 est converti en entier et stocké dans i
• 12.6 est stocké en flottant et stocké dans x

70
Scanf format

• caractères de conversion
• c donnée de type caractère simple
• d donnée de type entier relatif
• f donnée de type flottant
• e donnée de type flottant en notation
  exponentielle
• x donnée de type entier hexadécimal
• s donnée de type chaîne de caractères (tabl. de
  char terminé par \0)
• Exemple
• char t20
• int i float x
• scanf ("s d f", t,i,x)
• réponses
• 1/ abcde 123 0.05?
• 2/ abcde 123 ?
• 0.05?
• 3/ abcde?
• 123 ?

71
Scanf rôle des caractères ?, ?, tabulation,
dans les réponses

• Dans les réponses
• ?, ?, tabulation servent de délimiteurs pour les
  valeurs numériques et les chaînes de caractères
  (pas pour les caractères)
• Exemples
• scanf ("df",i,x)
• rep1 123 ????456 ? i 123 , x 456.0
• rep2 123456 ? i 123456 , x pas encore lu
  (en attente)
• scanf("sd",ch,i)
• rep abc 12 ch "abc" , i12
• scanf ("cc",c1,c2)
• rep1 ab? c1 'a' , c2 'b'
• rep2 a?b? c1 'a' , c2 ?
• scanf ("ccc",c1,c2,c3)
• rep1 ab? c1 'a' , c2 'b', c3 ?
• rep2 ab? c1 'a' , c2 'b'
• c? c3 ?

72
Scanf rôle des caractères ? et tabulation, dans
la chaîne de format

• Lecture de valeurs numériques aucun rôle
• scanf ("df",i,x) ? scanf ("d?f",i,x)
• Lecture de caractères indique de sauter les ?,
  tab et ?
• Exemples
• scanf ("ccc",c1,c2,c3)
• rep1 abc c1 'a' , c2 'b', c3 'c'
• rep2 a?b?c c1 'a' , c2 '?', c3 'b'
• scanf ("c?c?c",c1,c2,c3)
• rep1 abc c1 'a' , c2 'b', c3 'c'
• rep2 a?b?c c1 'a' , c2 'b', c3 'c'
• rep2 a?b ?
• c c1 'a' , c2 'b', c3 'c'

73
Scanf compléments

• Nombre de caractères lus
• faire précéder le caractère de format du nombre
  de caractères (max) désiré
• Exemples
• int i,j,k
• scanf("3d 3d 3d",i,j,k)
• rep1 1?2?3 i1 j2 k3
• rep2 123?456?789 i123 j456 k789
• rep3 123456789 i123 j456 k789
• rep4 1234?5678?9 i123 j4 k567
• int i float xchar c
• scanf("3d?5f?c,i,x,c)
• rep 10?234.567?t i10 x234.5 c'6'

74
Scanf compléments

• Lecture d'une chaîne de caractères
• char ch50
• scanf("s",ch) // pas de
• rep abcdefghi
• Le caractère 0 de fin de chaîne est ajouté
  automatiquement
• Exercice faire l'équivalent de scanf("s",ch) à
  l'aide de getchar()
• Saut conditionnel de caractères d, f
• permet de sauter des données correspondantes dans
  la réponse
• exemple
• int i,j char c
• scanf("d ? d ? c",i,c)
• rep1 12?34x i12 c'x'
• rep2 12?x i12 c'x'

75
scanf compléments

• Filtre sur chaînes de caractères
• caractères admissibles ou caractères non
  admissibles
• exemples
• char ch100
• scanf("0123456789",ch)
• rep 32a48 ch"32"
• scanf("0123456789",ch)
• rep 32a48 ch"a"
• raccourcis 0123456789 ou 0-9
• abcdefg ou a-g

76
Ecriture

• 2 fonctions de base putchar() et printf()
• putchar(caractère)
• Exemple
• char c
• c'a'
• putchar ( c )
• putchar ('\n')
• putchar('b')
• Affichage
• a
• b

77
Printf()

• Format
• printf(format,arg1,arg2,..,argn)
• les arguments sont des valeurs d'expression à
  imprimer
• le format donne le texte mort et le mode de
  décodage des arguments
• le format est une chaîne de caractères
• Exemples
• printf("bon") printf("jour")printf("\n") bonjou
  r
• ij1
• printf("id\n",i) i1
• printf("ddd\n",i,j,ij) 112
• printf("d?d?d?d\n",i,j,ij,sqrt(i)) 1?1?2?1
• x3.0
• printf("f?d\n",x,i) 3.000000?1
• printf("d\nd\n",i,ij) 1
• 2

78
Printf

• Caractères spéciaux de format
• d imprime les entiers sur le nombre de
  caractères nécessaires
• f imprime les réels avec 6 chiffres de partie
  décimale
• e imprime les réels en notation exponentielle
• c imprime un caractère
• s imprime une chaîne de caractères jusqu'à
  rencontrer le caractère de fin de chaine 0
  (erreur si absent)
• ..
• \n saut à la ligne
• \t tabulation
• \p saut à la page
• .

79
Printf mises en forme

• Forçage du nombre de caractères
• entiers
• 5d l'entier est imprimé sur 5 caractères au
  moins (blancs) avec cadrage à droite
• -5d l'entier est imprimé sur 5 caractères au
  moins (blancs) avec cadrage à gauche
• réels
• 10f le réel est imprimé sur 10 caractères (en
  tout) avec 6 chiffres en partie décimale
  (cadrage à droite)
• -10f idem cadrage à gauche
• limitation de la partie décimale
• 20.3f le réel est imprimé sur 20 caractères
  (en tout) avec 3 chiffres en partie décimale

80
Printf format variable

• ("d",n,i)
• n donne le nombre de caractères pour i
• (".3f,n,x)
• n donne le nombre total de caractères pour x
• (".f,n,m,x)
• n donne le nombre de total caractères
• m donne le nombre de caractères pour la partie
  décimale
• Exemples

81
Printf

• La valeur de retour du printf est le nombre de
  caractères écrits et une valeur négative si il y
  a eu un pb.
• Exemple
• int a,x
• a32
• x printf ("d\n",a)
• printf ("d\n",x) -gt 3

82
Autres fonctions d'E/S

• Beaucoup d'autre fonctions d'E/S
• voir "stdio.h"
• gets, puts permettent de lire et d'écrire des
  chaînes de caractères
• exemple
• include "stdioh"
• main()
• char ligne80
• gets(ligne)
• puts(ligne)

83
Lecture/Ecriture dans fichiers

• Principe identique aux lecture/écriture sur
  clavier/écran
• En fait, le clavier et l'écran sont des fichiers
  particuliers
• Il faut simplement en plus "ouvrir" le fichier
  c-à-d
• l'associer à un fichier physique (sur disque)
• l'associer à un variable interne du pgm
• Un fichier peut être
• soit lu (read)
• soit (ré-)écrit (write) bande magnétique
• soit écrit à la fin (append)
• Déclaration
• FILE variable-interne
• ex FILE f // f est une variable spéciale
  de type "fichier"

84
Ouverture de fichier fopen

• variable fopen("nom du fichier sur disque",mode
  d'ouverture)
• mode d'ouverture
• syntaxe chaîne de caractères
• 1er caractère
• 'r' read lecture
• 'w' write écriture
• 'a' append écriture à la fin
• fopen renvoie la valeur NULL (0) si le pb sur le
  fichier physique
• Exemple
• FILE f
• f fopen ("c\texte.txt","r1234")
• if (fNULL) printf ("le fichier est absent\n")
• else printf ("ok\n")

variable interne
fichier physique
85
Fermeture du fichier fclose

• Supprime l'association fichier physique-variable
  interne
• La variable interne peut être associée à un autre
  fichier physique
• Syntaxe
• fclose (variable interne)
• Exemple
• FILE f
• f fopen (fichier1, "r")
• .
• fclose (f)
• f fopen (fichier2,"w")

86
Lecture dans fichier

• Lecture
• fgetc() et getc() ? getchar()
• exemple
• cfgetc(f)
• fscanf() ? scanf()
• exemple
• fscanf(f,"d",i) le 1er argument est le
  variable interne fichier
• le caractère EOF indique la fin de fichier
• Ecriture
• fputc () ? putchar()
• fprintf() ? printf()

87
Exercice

• Afficher à l'écran le contenu d'un fichier (idem
  commande type)
• main()
• FILE monfichier
• char sur_disque100 char c
• / acquisition du nom /
• scanf("s",sur_disque)
• /ouverture/
• monfichierfopen(sur_disque,"r")
• if (monfichierNULL) printf("erreur\n")
• else // lecture affichage
• while ((cgetc(monfichier))!EOF)
  printf("c",c)
• fclose (monfichier)

88
Lecture/ecriture dans chaines de caractères

• sprintf (char s, format, paramètres)
  écriture dans la chaine s
• sscanf (char s, format, paramètres) lecture
  dans la chaine s
• exemple
• char tokenstring "15 12 14... " 
• char s81 char c int i float fp
• /lecture de différentes valeurs /
• sscanf( tokenstring, "s", s )
• sscanf( tokenstring, "c", c )
• sscanf( tokenstring, "d", i )
• sscanf( tokenstring, "f", fp )
• / Sortie/
• printf( "String s\n", s )
• printf( "Character c\n", c )
• printf( "Integer d\n", i )
• printf( "Real f\n", fp )
• Sortie String 15 Character 1 Integer 15
  Real 15.000000

89
Lecture/écriture dans chaines de caractères

• Exercice
• 1/ reporter dans une chaine de caractères un
  tableau dentiers. Dans la chaine, les nombres
  sont séparés par une virgule.
• 2/ Convertir un entier en une chaîne de
  caractères
• exemple
• int i 135,
• char s1000
• / à faire /
• ..
• printf("s",s) ? 135

90
Compléments sur les instructions de contrôle

• Instruction if imbrication

s1
s1
e2
ex1 if(e1) if(e2) s1 else s2 else if
(e3) s3 else s4
s2
e1
s3
e3
s4
s1
ex2 if(e1) s1 else if (e2) s2
e1
s2
e2
s1
ex3 if(e1) s1 else if (e2) s2 else
s3
e1
s2
e2
s3
s1
s1
s1
s1
e2
e2
ex4 if(e1) if(e2) s1 else s2
s2
e1
e1
s2
91
Compléments sur les instructions de contrôle

• Règle le else se rapporte au if le imbriqué

if(e1) if(e2) s1 else s2
s1
s1
e2
e1
if(e1) if(e2) s1 else else s2
s2
92
Compléments sur les instructions de contrôle
continue

• Dans une structure itérative l'instruction
  continue permet d'arrêter l'itération courante
  sans sortie de la boucle
• Exemple Calculer la moyenne des valeurs
  positives d'un tableau d'entiers relatifs.
• nb_valeurs0
• somme 0
• for (i0iltdimi)
• if (Tilt0) continue
• somme somme Ti
• nb_valeurs
• moyenne somme / nb_valeurs

93
Instruction break

• L'instruction break fait sortir de la structure
  de contrôle dans laquelle elle est imbriquée
• Utilisation dans les boucles permet de faire
  une boucle avec une condition de type "et"
  logique
• ex while (c1 c2) traitement
• while (c1)
• if (!c2) break
• else traitement
• Application typique gestion d'exception

94
break
On veut afficher tous les éléments d'un tableau
d'entiers jusqu'à rencontrer un nombre lt0 (si il
y en a un)
for (i0tigt0 iltdimi) ou bien
i0 printf("d", ti) while(tigt0
iltdim) printf("d",
ti)i Pb lorsque idim, il y a
évaluation de tdim qui n'existe pas gt
erreur Solution 1 avec un "drapeau  positif1
// positif indique que lon a eu que des
valeurs positives jusquà maintenant for (i0
(positif1) (iltdim) i) if(tilt0)
positif0 else printf("d", ti) Solution
2 for (i0 iltdimi) if(tilt0)
break else printf("d", ti)
95
Instruction switch

• syntaxe switch (expression) instructions où
  expression a une valeur entière ou caractère
• L'instruction est une expression composée
  d'alternatives. Chaque alternative commence par
  une énumération de cas
• switch (expression)
• case valeur 1 instruction1 instruction 2 .
• case valeur 2 instruction1 instruction 2 .
• case valeur n instruction1 instruction 2 .
• default instruction1 instruction 2 . //
  optionnel

96
switch
Rouge
Exemple char c printf("donner un e
couleur\n") cgetchar()if (cgt'a' clt'z')
cc'A'-'a' switch (c) case 'R'
printf("Rouge \n") case 'V'
printf("Vert\n") case 'B' printf("Bleu\n") d
efault printf ("Autre")
Vert
Bleu
Autre
R
Vert
Bleu
Autre
V
Bleu
Autre
B
Autre
97
switch break
Exemple char c printf("donner un e
couleur\n") cgetchar()if (cgt'a' clt'z')
cc'A'-'a' switch (c) case 'R'
printf("Rouge \n")break case 'V'
printf("Vert\n")break case 'B'
printf("Bleu\n")break default printf
("Autre")
98
switch break
Exemple char c printf("donner un e
couleur\n") cgetchar() switch (c) case
'r','R' printf("rouge \n")break case 'v',
'V' printf("Vert\n")break case 'b','B'
printf("Bleu\n")break default printf
("Autre")
Rouge
r ou R
Vert
v ou V
Bleu
b ou B
Autre
99
Les tableaux

• Rappel tableau regroupement de données de même
  type sous un même nom, accessibles par un indice
  (0,..,dim-1)
• Déclaration et implantation mémoire
• int t50 gt réservation dans la mémoire de 50
  cases contiguës d'entiers.
• L'adresse de la première case est t
• t0 ? t
• t ? t0

t0
t
t1
t2
t48
t49
100
Tableaux

• Initialisation à la compilation
• int t10 1,2,3,4,5,6,7,8,9,10
• float x4 0.,0.25,3.14,2.57
• char couleur4 'r','v','b','j'
• char texte10"abcd"
• int t110 1,2,3
• Dimension par défaut
• int t 0,0,0 gt dimension 3
• char t 'r','v','b','j' gt dimension4
• char t "abcd" gt dimension5
• par contre int t sans initialisation est
  incorrect

1
2
3
4
5
6
7
8
9
10
0.
0.25
3.14
2.57
r
v
b
j
a
b
c
d
\0
?
?
?
?
?
101
Tableaux

• Accès aux éléments d'un tableau
• int t50
• syntaxe 1
• // accès à la (i1)ème case avec i compris entre
  0 et 49
• ti
• syntaxe 2
• puisque t est l'adresse de la iere case
• t0 ? t // mot d'adresse t,
  opérateur mot dont l'adresse est)
• t1 ? (t1) // rem priorité des opérateurs)
• ti ? (ti) // ti ? t0i

102
Tableaux à plusieurs dimensions

• Tableau dont chaque case est elle-même un tableau
• ex typedef int t100 // t est un type
• t matrice 20
• matrice est un tableau de 20 cases, chacune est
  un tableau de 100 entiers gt matrice est un
  tableau de 20100 entiers
• autre déclaration
• int matrice 20100 // tableau de 20 "lignes"
  et 100 "colonnes"
• Accès aux éléments
• par un 1er indice allant de 0 à 19 et par un 2eme
  indice allant de 0 à 99
• matrice3 est la 4eme case de tableau. C'est un
  tableau de 100 cases (entiers)
• matrice348 est un entier.
• matrice ij avec i de 0 à 19 et j de 0 à 99
• matrice est un tableau à 2 dimensions

103
Tableaux à plusieurs dimensions

• Pas de limitations sur le nombre de dimensions
• Ex à 3 dimensions tableau de coord. de pts de
  l'espace
• typedef float point3 // x indice 0, y
  indice 1, z indice 2
• point tab100100 // tab matrice de 100
  points
• ou bien
• tab1001003
• tab251 représente le "y" du point rangé en
  ligne 2 et colonne 5
• Implantation mémoire
• int t32

t00
t0
t01
t10
t1
t11
t20
t2
t21
104
Tableaux à plusieurs dimensions

• Initialisation (à la compilation)
• int t32 1,2,3,4,5,6
• ou bien ( clair)
• int t32 1,2,3,4,5,6
• int t32 1,2,4,5,6 gt t11 non
  initialisé
• Initialisation grâce à des boucles
• for (i0ilt3i)
• for (j0jlt2j)
• tij0

t00 1
t0
t01 2
t10 3
t1
t11 4
t20 5
t2
t21 6
105
Tableaux à plusieurs dimensions

• Accés aux éléments
• int tdim1dim2
• tij ? (tidim2j)
• int tdim1dim2dim3
• tijk ? (tidim2dim3jdim3k)
• int tdim1dim2.dimn
• ti1i2.in ? (t
• i1dim2dim3dim4.. dimn
• i2 dim3dim4.. dimn
• ..
• in-1 dimn
• in) )
• gt la première dimension n'est pas utilisée dans
  le calcul

106
Les fonctions

• Une fonction permet de
• Remplacer une partie qui se répète
• Découper un programme en parties isolées -gt
  débogage, lisibilité, etc..
• Exemples fonctions d'E/S (scanf, printf, ),
  mathématiques (sin, cos, )
• Organisation d'un programme
• type fonction1 (arguments)
• Déclarations de variables et de types locaux à la
  fonction
• Instructions
• type fonction2 (arguments)
• Déclarations de variables et de types locaux à la
  fonction
• Instructions
• ...
• void main (arguments)
• Déclarations de variables et de types locaux à la
  fonction
• Instructions

107
Exemple
Type de la valeur de retour
Argument

• char minus_majus (char c1)
• char c2 / déclarations locales /
• if (c1 gt 'a' c1 lt 'z')
• c2 c1'A'-'a'
• else c2c1
• return (c2)
• void main()
• char c,majuscule
• printf("Donner un caractere\n")
• c getchar() getchar()
• majuscule minus_majus(c)
• printf ("La majuscule de c est
  c\n",c,majuscule)

Instructions
Valeur renvoyée
Appel de la fonction
108
Définition de fonction syntaxe

• type_fonction nom_fonction (type_arg1 arg1, ,
  type_argn argn)
• return (valeur retournée)
• Dans l'exemple précédent
• type_fonction char, c'est le type de la valeur
  renvoyée par return
• nom_fonction minus_majus
• Le nombre d'arguments est quelconque,
  éventuellement aucun, les parenthèses doivent
  toujours figurer (ex main () )

109
Type de la fonction

• Une fonction peut ne pas renvoyer de valeur.
• Exemple
• void print_majus (char c1)
• char c2
• if (c1 gt 'a' c1 lt 'z')
• c2 c1'A'-'a'
• else c2c1
• printf("la majuscule de est c, c1, c2)
• return / ou bien return () /
• Dans ce cas, le type de la fonction est void
• Le type de la fonction ne peut être que
• int, float, char, ou adresse de
• ni tableau, ni autre type complexe

110
Instruction return

• 1/ Indique la valeur de retour de la fonction.
• 2/ Arrête l'exécution de la fonction
• char minus_majus (char c1)
• if (c1 gt 'a' c1 lt 'z')
• return (c1'A'-'a')
• else return (c1)
• printf("c",c1) // jamais executée
• Pour les fonction de type void, return est
  optionnel
• void print_majus (char c1)
• char c2
• if (c1 gt 'a' c1 lt 'z')
• c2 c1'A'-'a'
• else c2c1
• printf("la majuscule de est c, c1, c2)

111
Appel des fonctions

• L'appel d'une fonction se fait en donnant son
  nom, suivi de la liste des paramètres entre
  parenthèses. L'ordre des paramètres correspond à
  celui des arguments.
• Exemple
• float puiss (float x, int n)
• float y1.0
• if (ngt0) for (i1iltni) y yx
• else for (i1iltni) y y/x
• return (y)
• void main ()
• float z,t
• z puiss(10.7,2)
• t puiss (z, -6)
• ...

112
Appel des fonctions

• Un appel de fonction peut se faire comme opérande
  d'une expression, soit comme paramètre d'un autre
  appel de fonction.
• Exemple
• int maximum (int x, int y)
• return((xgty)?x,y))
• void main ()
• int v1,v2,v3,m1
• scanf("d d d , v1,v2,v3)
• m1 maximum(v1,v2)
• m1 maximum(m1,v3)
• printf("valeur maximale d\n", m1)
• ou bien
• m1 maximum(v1,v2)
• printf("valeur maximale d\n", maximum(m1,v3))
• ou bien
• printf("valeur maximale d\n",
  maximum(maximum(v1,v2),v3))

113
Règles de déclaration et d'appel

• Toute fonction ne peut appeler que des fonctions
  déclarées avant elle ou elle-même (la fonction
  main ne peut pas s'appeler).
• ... f1 (..)
• ...
• ... f2 (...)
• ...
• ... f3 (...)
• ...
• void main (...)
• ...
• la fonction main peut appeler f1,f2,f3
• la fonction f3 peut appeler f1,f2,f3
• la fonction f2 peut appeler f1, f2
• la fonction f1 peut appeler f1
• Lorsqu'une fonction s'appelle elle-même, on dit
  qu'elle est "récursive".

114
Déclarations en "avance"

• Règle précédente contraignante
• Solution Prototype
• En début de programme on donne le type de chaque
  fonction , son nom, le nombre et les types des
  arguments
• Information suffisante pour le compilateur.
• float puiss (float,int)
• void main()
• puiss (