Vous êtes sur la page 1sur 70

Cours 

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

2A
2A : Langage C++ à Bordeaux
: Langage C++ à Bordeaux

3A : Palaiseau : Python

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

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

 Préciser (un peu) ce qu’est l’informatique
 Bases d’un langage informatique : le langage C
B d’ l i f ti l l C
 Bases du raisonnement informatique q
 Prise en main d’un environnement de 
développement : Code::Blocks
développement : Code::Blocks
 Essais de 1ers programmes

4
L L
Le Langage C
C

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

 Langage évolué / langage de bas niveau
 Évolué : «
Évolué : « relativement » proche de l
» proche de l’humain
humain
 Bas niveau : proche de la machine

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

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

 Manipulation de données
 Calculs, entrées, sorties 
Calculs, entrées, sorties – saisies, affichages 
saisies, affichages – écriture 
é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) la donnée à traiter 
q )
 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 de l’informatique
A h d l’i f ti

 Traitements de base sur les mémoires
 Initialisation d
Initialisation d’une
une mémoire
mémoire
 Affectation du résultat d’un calcul ou d’un 
traitement à une mémoire
à é

 Et aussi
 Saisie d
Saisie d’une
une valeur au clavier et stockage dans une 
valeur au clavier et stockage dans une
mémoire
 Affichage sur l’écran du contenu de la mémoire 
Affi h l’é d d l é i
8
1ère Approche de l’informatique
A h d 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 de l’informatique
A h d l’i f ti

 Processus de développement :
 A partir d
A partir d’un
un problème donné
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 d C d Bl k
Présentation de Code::Blocks

 Code::Blocks est un IDE (Integrated 
p
Development Environment) : )
 Il permet 
 d'éditer le code (taper le programme)
d'édi l d ( l )
 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 
de corriger les erreurs (déboguer) et de mettre au
point le programme grâce aux outils de debug. 12
P é t ti d C d Bl k
Présentation de Code::Blocks

 Code::Blocks est téléchargeable gratuitement à: 
http://www.codeblocks.org/downloads/binaries

 Lancer Code::Blocks par exemple avec le 
raccourci sur le bureau
raccourci sur le bureau 

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

 Créer un nouveau projet

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

 Créer une Application Console 

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

Cliquer sur Next

Sélectionner comme
langage le C

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

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

 Exemple :  
U:\jean.michel\Mes documents\ProgrammesEnC\td1
\j \ \ g \

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

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

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

 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 CTRL –
 ou avec
 Pour exécuter le programme : 
 avec Build > Run
avec Build > Run
 ou avec CTRL – F10
 ou avec  
19
P é t ti d C d Bl k
Présentation de Code::Blocks

 Nb : on peut tout faire en une fois :
 avec Build 
avec Build > Build and run
Build and run
 ou avec F9
 ou 

 Nb : pour mettre en forme le programme
 Plugin > Source code formatter
Plugin > Source code formatter

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

 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 d C d Bl k
Présentation de Code::Blocks

 Règles à respecter absolument :
 Un seul main () par projet.  
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
l’extension .c
 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 par ;
i

main()
{

mem3 = mem1 + mem2;

}

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

 Ne permet pas de tester l’égalité 
mathématique !
mathématique !
 Affecte l’expression de droite à la variable de 
gauche
 Expressions non autorisées :
xpressions non autorisées :
b + c = 50 ;
3 = a ;
 Instructions autorisées :
b = a + c ;
b = c + 77 ;
a = b = 44; 24
E
Exemple 1
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 1 (variantes)
l 1( 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 du code
t i d d
 Un code doit être commenté
 Afin d
Afin d’être
être lisible par d
lisible par d’autres
autres (vos enseignants, 
(vos enseignants,
votre binôme, vos futurs collègues, les personnes 
qui vont modifier votre code, …)
qui vont modifier votre code, …)
 Les commentaires sont compris entre /* et */ 
avec d’éventuels
avec d éventuels sauts de lignes  
sauts de lignes
 Ou encore // uniquement pour le reste de la ligne

27
Li ibilité d
Lisibilité du code
d
 Un code doit être lisible
 Grâce aux commentaires
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 variables 
d i bl
 Identificateur = nom permettant de désigner 
( )
une variable (ou une fonction)
 Caractères autorisés
 a, …,z,A, …,Z et 0, …, 9 et _
A Z 0 9
 Un identificateur commence par une lettre ou par 
le caractère _
 Attention : Le C différencie majuscules et 
j
minuscules  

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

 Les noms explicites de variables permettent 
p p
de ne pas surcommenter

30
Dé l ti d
Déclaration des variables en C
i bl 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 
On effectue les déclarations de variables en
début de bloc, c‐à‐d juste après {
 Pas d
Pas d’importance
importance dans l
dans l’ordre
ordre des 
des
déclarations
 Attention
A i : ne pas mélanger ligne exécutables 
él li é bl
et déclarations 31
Q l
Quelques types de variables en C
t d i bl 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
Variables en C
C
 On va rencontrer les variables à 3 occasions :
 Déclaration  traité ici
 Initialisation  Souvent indispensable … pour éviter 
p g ( p
des programmes faux (même s’ils compilent))
 Utilisation  traité à plusieurs reprises

 Initialisation : de 2 façons
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
ti d’ ffi h (1ère approche)
FFonctions d’affichage (1 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’ têt h
Fichiers d’en tête : .h
 Stdio : standard input output
 Fichier .h (comme header) ou fichier d
Fichier h (comme header) ou fichier d’en‐tête
en tête
 Contient la déclaration de la fonction utilisée
 Permet de s’en servir en sachant :
 Ce qu
Ce qu’elle
elle fait
fait
 La syntaxe à utiliser
 Mais sans connaître le code de la fonction
M i î l d d l f i
 Il en existe de nombreux autres :
 math.h, stdlib.h, string.h, ctype.h, time.h 
35
( ère
Fonctions de saisie au clavier (1
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 programme simple
d’ 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
Les structures de contrôle
t t d 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 
Nécessitent des tests ou des boucles : ce sont
les structures de contrôle

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

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

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

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

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

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

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

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

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

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

41
L b l
Les boucles
 Les boucles do … while :
 Syntaxe proche des 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 
une fois (même si la condition est fausse
d’emblée)
do {
i++;
}
while (i<100) ;

42
L
Les conditions d’arrêt des boucles
diti d’ êt d 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 à
>= Supérieur ou égal à
== Égal (ne pas confondre avec  = 
qui correspond à l’affectation)
Priorité
!= Différent de inférieure

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

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


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

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

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

 Les if … else
if else
if (Condition) instruction1;

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

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

45
L t t l if imbriqués
Les tests : les if 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 …
 … mais sur la lisibilité: Pensez  donc à indenter !
i l li ibilité P d ài d t !
 Code::Blocks propose d’ailleurs une mise en forme via    
gg > Source code formatter
Pluggins f

46
L t t l if successifs
Les tests : les if 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 t t
Les tests
 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 default n’est exécuté que si aucun des autres cas 
e default n 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 dimension en Langage C
à 1 di i L 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
La numérotation des composantes commence à 0 et se 
é t ti d t à0 t
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 dimension en Langage C
à 1 di i L C
 Attention :
Si on dépasse la taille du tableau : le programme compile mais 
l’ é i
l’exécution « plantera
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 dimensions en Langage C
à 2 di i L 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
2
 EEn informatique, les informations sont stockées 
i f i l i f i ké
dans des dispositifs électroniques ne prenant que 
2 états électriques : un état correspond à 0 et
2 états électriques : un état correspond à 0 et 
l’autre à 1.
 On parle alors de bits (« binary digit
On parle alors de bits (« binary digit »)
 Ca impose de représenter les nombres en base 2 
(ou binaire)
(ou binaire)
 On peut presque s’en affranchir pour 
programmer en Langage évolué.
programmer en Langage évolué.
 Voyons en cependant le principe

52
L b
La base 2
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: on a seulement 2 chiffres 0 et 1
2 l t 2 hiff 0 t 1
1011 = 1.23 + 0.22 + 1.21 + 1.20
soit 11

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

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


Emplacement physique  Rôle de la chaîne de
développement (Code::Blocks)
La taille occupée  le programmeur le fait en 
 La taille occupée  le programmeur le fait en
indiquant le type
55
T
Types des variables en C
d i bl C
 Types entiers :
c
char
a : 1 octet  
 short: 2 octets 
 long:
l 4 octets 
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 les entiers
l ti
 5 opérations :
 + (addition), 
+ (addition) ‐ (soustraction), 
(soustraction) * (produit),          
(produit)
/ (division), % (reste de la division entière).
 ÉÉvaluation de la gauche vers la droite
l i d l h l d i
 / et * : même niveau de priorité et priorité sur +   
et ‐

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

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

59
E é
En résumé 
é
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 
p
évaluée puis stockée dans la variable 
immédiatement à gauche du =
 Dans une expression, la règle d’associativité  
Dans une 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 t
Choix des types
 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 de types
i d t
 Attention
Att ti : les opérateurs sont conçus pour 2 opérandes de même 
l é t t 2 é d d ê
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 de type :
ç g 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 de types
i d 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 de types
i d t
 Attention : 
 Le compilateur fait une conversion de type sans 
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 !
D’où perte d’informations !

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

66
C t t
Constantes symboliques
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 avec printf
l i tf
 Affichage de variables
int x;
printf("x =%d\n" ,x);
Affiche ll’int
Affiche int x et saute à la ligne suivante
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 avec printf
l 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 ii l i
Saisie clavier avec scanf et printf
f t 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
p
pas de \n dans le scanf
\
70

Vous aimerez peut-être aussi