Cours d’informatique

en Langage C
è
ère
1 année 2014‐2015
L’i
L’informatique
f ti à l’IOGS
1A : Langage C : apprentissage d’un langage de
programmation
p g structuré
3 séances Matlab : analyse numérique

2A : Langage C++ à Bordeaux

3A : Palaiseau : Python

2
Dé l
Déroulement
tdde l’
l’année
é
 U session
Une i ded cours‐td
td au 1S
11 séances de 2h
Dont 2 synthèses (2h  note), un mini‐projet
+ un examen individuel
i di id l sur machine
hi

 Un projet au 2S
3 séances de 4h
+ une présentation orale du projet
3
But d 1ères séances
B t des é

 Préciser (un peu) ce qu’est l’informatique

 Bases
B d’
d’un llangage iinformatique
f ti : lle langage
l C
 Bases du raisonnement informatique q
 Prise en main d’un environnement de
développement : Code::Blocks
 Essais de 1ers programmes

4
L LLangage C
Le

 Créé au début des années 70 par Dennis

Ritchie et Brian Kernighan
 Langage multi plate‐forme : Windows, Mac,
Linux, nombreux micro‐processeurs
 En
n respectant la norme ANSI/ISO, le même code
va pouvoir être recompilé par plusieurs systèmes
 Reste encore aujourd'hui
aujourd hui un langage très
utilisé dans le monde (perfectionné depuis : la
norme a évolué)
é l é)
5
L LLangage C
Le

 Langage évolué / langage de bas niveau

 Évolué : « relativement » proche de ll’humain
humain
 Bas niveau : proche de la machine

 Langage C :
 Langage évolué
 Mais aussi assez proche de la machine
 Permettra
P par exemple
l de
d programmer des
d
microprocesseurs.

6
1ère Approche
A h de
d l’informatique
l’i f ti

 Manipulation de données
 Calculs, entrées, sorties – saisies, affichages – écriture
et lecture dans des fichiers, …
 Données : stockées dans des cases mémoires
 Case mémoire : emplacement physique où est stockée
(
(sous forme électrique)
q ) la donnée à traiter
 La case mémoire élémentaire : c’est l’octet (on y
reviendra)
 Une case mémoire : connue par la machine grâce à
son adresse = son emplacement physique
 Connue par le programmeur par un nom (à choisir)
7
1ère Approche
A h de
d l’informatique
l’i f ti

 Traitements de base sur les mémoires

 Initialisation d’une
d une mémoire
 Affectation du résultat d’un calcul ou d’un
traitement à une mémoire
é

 Et aussi
 Saisie d
d’une
une valeur au clavier et stockage dans une
mémoire
 Affichage
Affi h sur l’é
l’écran d
du contenu d
de lla mémoire
é i
8
1ère Approche
A h de
d l’informatique
l’i f ti
 Un exemple d’algorithme : Résolution d’une équation du 1er
degré à coefficients réels : a.x + b = 0
Saisir a p
puis b
si a=0 faire
si b=0 faire
Affi h « Tout
Afficher T t réel
é l estt solution
l ti »
sinon Faire
Afficher « Pas de solution réelle »
sinon Faire
Calculer –b/a  Solution
Afficher Solution

9
1ère Approche
A h de
d l’informatique
l’i f ti

 Processus de développement :
 A partir d’un
d un problème donné
Méthode Traduction
à mettre Langage en Micro
Humain
en œuvre : informatique informations -processeur
algorithme exécutables

Le développeur Code::Blocks Le PC

10
Les bases du Langage C

 Le programme main

main()
{
}

11
 P é t ti de
Présentation d Code::Blocks
C d Bl k

 Code::Blocks est un IDE (Integrated

p
Development Environment)) :
 Il permet
 d'éditer lle code
d'édi d ((taper lle programme))
 de compiler pour traduire le code en langage
machine
 faire l’édition de liens et réaliser un exécutable
 d’exécuter le programme
 de corriger les erreurs (déboguer) et de mettre au
point le programme grâce aux outils de debug. 12
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Code::Blocks est téléchargeable gratuitement à:

[Link]

 Lancer Code::Blocks par exemple avec le

raccourci sur le bureau

13
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Créer un nouveau projet

14
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Créer une Application Console

15
P é t ti de
Présentation d Code::Blocks
C d Bl k

Cliquer sur Next

Sélectionner comme
langage le C

Info C – IOGS 1A
2012-2013 16
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Renseigner les noms et les chemins

 Par exemple en créant un dossier spécifique pour
la session de C et un dossier par séance
 en remplaçant
l si b
besoin \\hera
\\h par U:\\

 Exemple :
U:\[Link]\Mes
\j \ documents\ProgrammesEnC\td1
\ g \

17
P é t ti de
Présentation d Code::Blocks
C d Bl k

L’espace projet
tel qu’il apparaît
Incluant un
programme de
base

Info C – IOGS 1A
2012-2013 18
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Une fois le code écrit, il faut générer un

p
exécutable en compilant :
 avec Build > Build
 ou avec CTRL – F9
 ou avec
 Pour exécuter le programme :
 avec Build > Run
 ou avec CTRL – F10
 ou avec
19
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Nb : on peut tout faire en une fois :

 avec Build > Build and run
 ou avec F9
 ou

 Nb : pour mettre en forme le programme

 Plugin > Source code formatter

20
P é t ti de
Présentation d Code::Blocks
C d Bl k

 En cas d’erreurs, aller lire la fenêtre suivante puis

cliquer sur l’erreur

 Et toujours commencer par corriger la 1ère erreur

de la liste avant de relancer la compilation
21
P é t ti de
Présentation d Code::Blocks
C d Bl k

 Règles à respecter absolument :

 Un seul main () par projet.
 Et donc un seul fichier comprenant la fonction
main
 Tous les fichiers de code source devront avoir
l’ t i .c
l’extension
 Attention aux extensions en .cpp (erreur dans la
création du projet) qui ne fonctionneront pas ici

22
Les bases du Langage C

 Une ligne de code se

termine
i par ;

main()
{
…
mem3 = mem1 + mem2;
…
}

23
Aff t ti : avec le
Affectation l signe
i =

 Ne permet pas de tester l’égalité

mathématique !
 Affecte l’expression de droite à la variable de
gauche
 Expressions
xpressions non autorisées :
b + c = 50 ;
3 = a ;
 Instructions autorisées :
b = a + c ;
b = c + 77 ;
a = b = 44; 24
E
Exemple
l 1

 En pseudo‐code  En Langage C
20  mem1 main()
250  mem2 {
mem1 + mem2  mem3 int mem1;
int mem2;
int mem3;
mem1 = 20;
Pour utiliser une mem2 = 250;
variable,, il faut
d’abord l’avoir mem3
3 = mem11 + mem2;
2
déclarée en précisant }
son type

25
E
Exemple
l 1 ((variantes)
i t )
 main()
{
/* Utilisation de la , */
int mem1,mem2,mem3;
1 2 3
mem1 = 20;
mem2 = 250;
mem3 = mem1 + mem2;
}

 main()
{
// Déclaration et Initialisation
int mem1=20 , mem2=250 , mem3;
mem3 = mem1 + mem2;
}
26
C
Commentaires
t i du d code
d
 Un code doit être commenté
 Afin d
d’être
être lisible par d
d’autres
autres (vos enseignants,
votre binôme, vos futurs collègues, les personnes
qui vont modifier votre code, …)
 Les commentaires sont compris entre /* et */
avec d’éventuels
d éventuels sauts de lignes
 Ou encore // uniquement pour le reste de la ligne

27
Li ibilité du
Lisibilité d code
d
 Un code doit être lisible
 Grâce aux commentaires
 Avec des noms de variables ou de fonctions
explicites
 Avec une mise en forme des différents blocs

28
Id tifi t
Identificateurs des
d variables
i bl
 Identificateur = nom permettant de désigner
une variable ((ou une fonction))
 Caractères autorisés
 a, …,z,A,
A …,ZZ et 0
0, …, 9 et _
 Un identificateur commence par une lettre ou par
le caractère _
 Attention : Le C différencie majuscules
j et
minuscules

29
Id tifi t
Identificateurs des
d variables
i bl
 Choix de nom explicite
 Améliore la lisibilité du code
 Exemples :
 Ma_Variable
Ma Variable
 TemperatureFarenheit

 Les noms explicites

p de variables permettent
p
de ne pas surcommenter

30
Dé l ti des
Déclaration d variables
i bl en C
 Déclarer une variable c’est définir son nom et
son type
int mem1; /* mem1 est de type int */
 En Langage C, on doit déclarer une variable
avant de l’utiliser
 On effectue les déclarations de variables en
début de bloc, c‐à‐d juste après {
 Pas d’importance
d importance dans l’ordre
l ordre des
déclarations
 Attention
A i : ne pas mélanger
él liligne exécutables
é bl
et déclarations 31
Q l
Quelques ttypes de
d variables
i bl en C
 Type entier : int
 Exemple : int MaVariable ;

 Type réel : float

 Exemples : float Discriminant ;
float Eps = 1e-6 ;
float Tempe= 23.5 ;

32
V i bl en C
Variables
 On va rencontrer les variables à 3 occasions :
 Déclaration  traité ici
 Initialisation  Souvent indispensable … pour éviter
des pprogrammes
g faux (même
( s’ils compilent)
p )
 Utilisation  traité à plusieurs reprises

 Initialisation : de 2 façons
int MaVariable ; int MaVariable = 2 ;
…//déclaration
//déclaration ou code // Déclaration & Init
MaVariable = 2 ; // Init simultanées

Au choix du développeur 33
F ti
Fonctions d’affichage
d’ ffi h (1ère approche)
h )
 Affichage d’une phrase, d’un entier, d’un réel :
Nécessaire en début de code
 #include <stdio.h>
<stdio h> pour utiliser la fonction
main() d’affichage
{
int mem1 = 10 ;
3 appels à la fonction
float mem2 = 20.0 ; d’affichage

printf("Bonjour, ça va bien?\n");
printf("%d\t"
printf( %d\t , mem1);
printf("%f\n", mem2);
}

34
Fi hi d’
Fichiers d’en tête
têt : .h
h
 Stdio : standard input output
 Fichier .h
h (comme header) ou fichier d’en‐tête
d en tête
 Contient la déclaration de la fonction utilisée
 Permet de s’en servir en sachant :
 Ce qu’elle
qu elle fait
 La syntaxe à utiliser
 Mais
M i sans connaître
î le l code
d de
d la
l fonction
f i
 Il en existe de nombreux autres :
 math.h, stdlib.h, string.h, ctype.h, time.h
35
Fonctions de saisie au clavier ((1ère
approche)
 Saisie d’un entier ou d’un réel :
 #include <stdio.h>
<stdio h>
main()
{
int mem1 ;
float mem2 ;
…
scanf("%d",&mem1); Attention à bien
mettre le & avant le
scanf("%f"
scanf( %f ,&mem2);
&mem2); nom de la variable
… (mem1 ici)
} Attention :pas de
\n du type :
‘scanf(’%d\n ’’) ;
36
St t
Structure d’un
d’ programme simple
i l
 #include <stdio.h> En-tête
Corps du programme :
main() main()
{ Accolade de début
int mem1 ;
Dé l
Déclarations
ti des
d variables
i bl
float mem2 ;
…
scanf("%d",&mem1);
Instructions du programme
scanf("%f",&mem2);
…
} Accolade de fin

37
L structures
Les t t d
de contrôle
t ôl
 Quelques problèmes simples :
 Convertir les Fahrenheit en Celsius et afficher un
message si la température (en °C) est négative
 Déterminer le min et le max parmi 2 nombres
 Afficher les nombres impairs entre 0 et 100
(inclus)

 Nécessitent des tests ou des boucles : ce sont

les structures de contrôle

38
St t
Structure de
d contrôle
t ôl : LLes b
boucles
l
 3 types de boucles
 Boucles for
 De i = 0 à N, faire instructions

 Boucles while
 Tant que (condition vraie),
vraie) faire instructions

 Boucles
B l do d while
hil
 faire instructions Tant que (condition vraie)

39
L b
Les boucles
l
 E
Exemples
l d de b
boucles
l for
f :
for (i=0;i<100;i++)
Nombre = Nombre *2; /* Fin de la boucle for : i s’incrémente s’il
n’est
’ pas éégall à 100 et la
l ligne
l d’instruction
d’ est ré‐exécutée
é é é */

for (i=0;i<=100;i=i+10)
{
Nombre = Nombre *2; /* Plusieurs instructions : donc on met des
accolades */
Nombre2 = Nombre2 *3;
} /* Fin de l a boucle for : i s’incrémente etc… */

for (i=0;;i++) {…} /* La condition de terminaison est

facultative mais pas le ; */

for (;;) {…} //* Une boucle for particulière !! *//

40
L b
Les boucles
l
 E
Exemples
l d de b
boucles
l while
hil :
while (i<100)
ii++;; //* Fin de la boucle while: i s’incrémente
s incrémente ss’ilil n
n’est
est pas égal
à 100 et la ligne d’instruction est ré‐éxécutée*/

while (i<100)
( )
{
i++;
Nombre = Nombre *i;i; //* Plusieurs instructions : donc on met
des accolades */
Nombre2 = Nombre2 *2*i;
} ; //* Fin de la boucle while*/
while /

while (1) { … } /* Une boucle while particulière !! */

41
L b
Les boucles
l
 Les boucles do … while :
 Syntaxe proche des while
 Mais ce type de boucle sera exécutée au moins
une fois (même si la condition est fausse
d’emblée)
do {
i++;
}
while (i<100) ;

42
L conditions
Les diti d’arrêt
d’ êt des
d boucles
b l
 Condition d’arrêt : expression logiques
 Opérateurs :
Opérateurs Signification
< I fé i
Inférieur à
<= Inférieur ou égal à Même
priorité
> Supérieur ou égal à
>= Supérieur ou égal à
== Égal (ne pas confondre avec =
qui correspond à l’affectation)
Priorité
!= Différent de inférieure

43
L conditions
Les diti d’arrêt
d’ êt
 Condition d’arrêt : expression logique
 Évaluation d d’expression
expression logique :
 A l’aide de : || (Ou) && (Et) ! (négation logique)

 Exemple l : (i>= 100) || (j==10) && !(k>0)

 && pprioritaire sur ||
 0 correspond à Faux

 Toute
To te valeur
ale r non nulle
n lle correspond à Vrai
 Exemple : if (correct) ou bien if(!correct)

44
St t
Structure de
d contrôle
t ôl : LLes ttests
t
 2 types d
de tests
 Les if … else
 Les
L switch
it h

 Les if … else
if (Condition) instruction1;

if (Condition)
(C diti ) i instruction1;
t ti 1
else instruction2;

if (Condition)
{ instruction1; instruction2; }
else { instruction2 ;}

45
L ttests
Les t : lles if imbriqués
i bi é
 E
Exemple
l
if (choix1< 0)
if (choix2>0)
instruction1;
else
instruction2;
 Le else se rapporte toujours au dernier if sans else
 L’indentation n’a pas de conséquence sur la
compilation …
 … maisi sur lla lilisibilité:
ibilité PPensez donc
d à iindenter
d t !
 Code::Blocks propose d’ailleurs une mise en forme via
gg > Source code fformatter
Pluggins

46
L ttests
Les t : lles if successifs
if
 Application : choix successifs
if (
(choix1< 0)
) instruction1;
;
else if (choix2>0) instruction2;
else if (choix3>0)
( h i 3>0) i
instruction3;
t ti 3
else if (choix4>0) instruction4;
[ else instruction5; ]

47
L ttests
Les t
 Les switch
Switch (Choix)
{
case 1 : instruction1 ; break;
case 2 : instruction2 ; break;
case 3 : instruction3 ; break;
…
default : instruction_default ; break;
}

 Le break permet de sortir de la boucle lorsque la

condition est vérifiée
 La variable de choix doit être de type entier (ou
caractère)
 Le
e default nn’est
est exécuté que si aucun des autres cas
n’est vrai : il est facultatif.
 Le break après default est facultatif mais est une bonne
convention d’écriture

48
T bl
Tableau à 1 di
dimension
i en LLangage C
 Comme pour les variables, on va rencontrer les tableaux dans
3 types de circonstance : Déclaration – Initialisation –
Utilisation
 Déclaration :
int tab[10] ;
Attention : int tab[n] est interdit en C
 L numérotation
La é t ti d des composantest commence à 0 ett se
termine à N‐1 ; ex : tab[0] à tab[9]
 Utilisation :
x = tab[2] + tab[4];
tab[2] = tab[4]*2 ;
tab[i] = i + j ; 49
T bl
Tableau à 1 di
dimension
i en LLangage C
 Attention :
Si on dépasse la taille du tableau : le programme compile mais
l’ é i « plantera
l’exécution l »
 Initialisation :
 Fortement conseillé
 2 façons : soit à la déclaration, soit dans le code
int Montab[5] = {1,3,17,-54,2} ;
__________________________________
int Montab[5] ;
… bout de code
// boucle remplissant les cases tab[i]
50
T bl
Tableau à 2 di
dimensions
i en LLangage C
 Pratiquement comme pour les tableaux 1D.
 Déclaration :
int tab[10][2] ; // 10 lignes, 2 col.

 Utilisation :
x = tab[2][3] + tab[2][4];
tab[2][4] = tab[1][4]*2 ;
tab[i][j] = i + j ;

51
L b
La base 2
 EEn iinformatique,
f i l iinformations
les f i sont stockées
ké
dans des dispositifs électroniques ne prenant que
2 états électriques : un état correspond à 0 et
l’autre à 1.
 On parle alors de bits (« binary digit »)
 Ca impose de représenter les nombres en base 2
(ou binaire)
 On peut presque s’en affranchir pour
programmer en Langage évolué.
 Voyons en cependant le principe

52
L b
La base 2
 En base 10 : on exprime les nombres avec 10
chiffres de 0 à 9 :
1984 = 1.103 + 9.102 + 8.101 + 4.100
 E b
En base 2:
2 on a seulement
l t 2 chiffres
hiff 0 ett 1
1011 = 1.23 + 0.22 + 1.21 + 1.20
soit 11

53
L b
La base 2
 En informatique : la « case mémoire »
élémentaire est l’octet (g
(groupement
p de 8 bits))
ou byte en anglais
 Une donnée peut être mémorisée sur
plusieurs octets (voir juste après)
 Un octet permet de coder :
De 0000 0000 à 1111 1111
Soit de 0 à 255 en non‐signé
ou de – 128 à +127 en signé
54
T
Types des
d variables
i bl en C
 Pourquoi déclarer le type des variables ?
 Pour que ll’ordinateur
ordinateur puisse traiter une mémoire
il doit connaître :
 Son emplacement physique
 La taille occupée par cette mémoire (en nombre
d’octets))

 Emplacement physique  Rôle de la chaîne de

développement (Code::Blocks)
 La taille occupée  le programmeur le fait en
indiquant le type
55
T
Types des
d variables
i bl en C
 Types entiers :
c
char
a : 1 octet
 short: 2 octets
 long:
l 4 octets
 int: 2 ou 4 octets car ça dépend du
compilateur : type le plus employé. Ici 4 octets.
 Et aussi
 Types « unsigned » : unsigned short int,
unsigned long int int.
56
O é ti
Opérations sur lles entiers
ti
 5 opérations :
 + (addition),
(addition) ‐ (soustraction),
(soustraction) * (produit),
(produit)
/ (division), % (reste de la division entière).
 ÉÉvaluation
l i d de lla gauche
h vers lla d
droite
i
 / et * : même niveau de priorité et priorité sur +
et ‐

57
O é ti
Opérations sur lles entiers
ti
 Opérations unaires :
 i++
 ++i
 i--
i
 --i
 i+=5 signifie i = i+5
 Idem avec i*=a etc.

58
T
Types des
d variables
i bl en C
 Types réels :
 float:
oat réel en simple
p précision
p codé sur 4
octets
 double: réel en double précision codé sur 8
octets
 4 opérations
é ti :
 Les mêmes que pour les entiers, mais sans le
modulo (%)

59
E résumé
En é é
Type en C
T Nom F
N Françaisi T ill (octets)
Taille ( t t) V l
Valeurs permises
i
unsigned short int entier court non signé 2 0 à 65 536
short entier court 2 -32 768 à 32 767
unsigned long int entier long non signé 4 0 à 4 294 967 295
long int entier long 4 -2 147 483 648 à 2 147 483 647
int entier (16 bits) 2 -32 768 à 32 767
int entier (32 bits) 4 -2 147 483 648 à 2 147 483 647
unsigned int entier non signé (16 2
0 à 65 536
bits)
unsigned int entier non signé (32 4
0 à 4 294 967 295
bits)
char texte 1 256 caractères (0 à 255)
float nombre décimal 4 1.2e-38 à 3.4e38
double nombre double 8 de 2.2e-308
2 2e 308 à 1.8e308
1 8e308

60
P i ité d
Priorité des opérateurs
é t
 L’expression la plus à droite est d’abord
évaluée p
puis stockée dans la variable
immédiatement à gauche du =
 Dans une expression
expression, la règle d’associativité
est de gauche à droite
 Avec certaines règles de priorité :
(du plus au moins prioritaire)

++ ‐‐
* / %
+ ‐
61
Ch i d
Choix des ttypes
 Attention : Le compilateur ne fait pas le
traitement des dépassements de capacité.
 C’est au développeur de typer ses variables de
façon correcte
 Exemple :
char a,b,c;
…
a = b + c ;
Ce programme va être compilé, s’exécuter
(apparemment) normalement, mais est faux !
62
C
Conversion
i ded types
t
 Attention
Att ti : les
l opérateurs
é t sontt conçus pour 2 opérandes
é d de d même
ê
type et produisent un résultat du même type.
int a,b;
a+b est de type int
5/2 est donc int et vaut 2 !!
32/100*100
32/100 100 vaut 0
 Quand 2 opérandes de types différents, le compilateur convertit
dans le type dominant avec la convention :
Ch
Char < short
h t i intt < long
l int
i t < float
fl t < d double
bl

 Forçage
ç g de type
yp :
5/2.0 Le résultat est un float valant 2.5
32/100.0*100
Le résultat est un float valant 32.0
32 0
63
C
Conversion
i ded types
t
 Exemples :
int a=64,b=2;
float x=1,y=2;

b=7/b;
b 7/b;
/* En premier : calcul de l'argument à droite du = donc 7 (entier) /
2 (entier) donne 3 (entier, reste 1, que l'on obtiendrait par 5%2).
donc b=3 */

x=7/b;
/* 7 et b entiers => passage en réel inutile, calcul de 7/2 donne 3
( ti
(entier, reste
t 1) puis
i opérateur
é t = (t
(transformation
f ti d
du 3 en 3
3.0
0 puis
i
transfert dans X qui vaut donc 3.0) */

x=7/y;
x 7/y;
/* un int et un float autour de / : transformation implicite de 7 en
réel (7.0), division des deux réel (3.5), puis transfert dans x */

x=7.0/b;
/* un int et un float autour de / : transformation implicite de b en
réel, division des deux réel (3.5), puis transfert dans x */ 64
C
Conversion
i ded types
t
 Attention :
 Le compilateur fait une conversion de type sans
tenir compte du membre de gauche de
l affectation
l’affectation
 Le résultat peut donc dépasser le type prévu
 D’où perte d’informations !

65
C t t symboliques
Constantes b li
 Définies
Défi i en début
déb de d programme (au
( même
ê
niveau que les #include) par :
#define PI 3
3.14159
14159
#define TAUX_TVA 0.196
 Règle de style : constantes symboliques en
majuscules
 Règle
g de syntaxe
y :p
pas de signe
g = et p
pas de ;
 Intérêt :
 Lisibilité du code
 1 seule modification de la valeur même s’il y a
plusieurs occurrences

66
C t t symboliques
Constantes b li
 Exemples d’utilisation
x = sin(2*PI*Omega*t) ;
Prix = Cout* (1 + TAUX_TVA) ;

 Les constantes symboliques sont très utilisées

67
Affi h
Affichage console
l avec printf
i tf
 Affichage de variables
int x;
printf("x =%d\n" ,x);
Affiche ll’int
int x et saute à la ligne suivante
Les codes de format d’affichage sont :
%d int
%c char
%f fl t
float
%lf double …

68
Affi h
Affichage console
l avec printf
i tf
 Affichage de variables et de chaînes de
caractères
int x = 2 ;
double y = 2.5 ;
printf(‘‘le produit de %d par %lf vaut
%lf \n’’ , x , yy, x*y);
y
Affiche : le produit de 2 par 2.5 vaut 5

69
S i i clavier
Saisie l i avec scanff ett printf
i tf
 Saisies de valeur de variables
int x ;
printf(‘‘Entrez x = \n’’);
scanf(‘‘%d ’’,&x);

 Stocke nombre tapé au clavier dans la variable x

Attention :
au signe & devant la variable x
pas de \\n dans le scanf
p
70