02/02/2023

INTRODUCTION AU C ET
MÉTHODES NUMÉRIQUES

Chaker LARABI
[email protected]

PLAN DU COURS

►Représentation des données numériques

◆Nombres entiers
◆Nombres à virgule flottante
◆Pointeurs et chaînes de caractères
►Programme C et fonctions
◆Structure d’un programme
◆Entrées/Sorties
◆Fonctions
◆Librairies standards

1
 02/02/2023

INTRODUCTION

POURQUOI LE LANGAGE C ?

Parce que c'est un langage puissant, rapide et beaucoup

utilisé :
►Rapide car langage compilé (= compilé entièrement
en une seule fois avant l'exécution) et non pas
interprété (= compilé ligne par ligne pendant
l'exécution, comme le Python par exemple).
Compilation = traduction d'un programme écrit dans
un langage de programmation (compréhensible par
les humains) en langage machine (exécutable par
l'ordinateur).
►Beaucoup utilisé, non seulement dans la recherche
scientifique, mais aussi dans d'autres domaines. Par
exemple, le système d'exploitation Windows et le
compilateur du langage Python ont été écrits en C.
►Puissant car on peut tout faire et tout contrôler.

2
 02/02/2023

CLASSEMENT DES LANGAGES DE PROGRAMMATION

Source : www.tiobe.com
5

HISTOIRE DU C

►Développé en 1972 par Dennis Ritchie (Bell Labs) avec

comme but principal le développement du système
d'exploitation Unix.
►Devient populaire en 1978 quand le livre « The C
Programming Language » de Kernighan et Ritchie est publié (et
est resté populaire depuis).
►Origine du nom : le 'C' n'est pas une abréviation, il s'appelle
comme ça parce qu'il est basé sur un langage B (développé
par Ken Thompson, Bell Labs, en 1969), qui lui était une
version simplifée du BCPL (Basic Combined Programming
Language, développé par Martin Richards, Université de
Cambridge, en 1966).

3
 02/02/2023

AVANT PROPOS (1)

►On peut rajouter du commentaire à un programme de deux façons :

◆ // et tout ce qui suit sur une ligne est ignoré par le (pré-)compilateur,
◆ ainsi que tout ce qui se trouve entre /* et */

►Les lignes commençant par # sont des instructions pour le pré-compilateur.

◆ #include<iostream> dit au pré-compilateur de mettre les définitions de la bibliothèque
iostream à cet endroit, afin que le compilateur qui vient après connaisse la commande utilisée.
►Tout programme en C doit avoir une fonction du type int qui s'appelle main et n'a
pas d'arguments (parenthèses vides), qui contient le programme principal.
►Les accolades délimitent un bloc de commandes qui appartiennent ensemble à ce qui
précède.
◆ Le contenu d'une fonction se trouve obligatoirement entre accolades.

AVANT PROPOS (2)

►Toutes les commandes se terminent obligatoirement par un point-virgule.

◆ On peut étaler une commande sur plusieurs lignes ou mettre plusieurs commandes sur une ligne.

►En C il faut obligatoirement déclarer explicitement toutes les variables qu'on utilise.
►La déclaration d'une variable réserve une petite boîte dans la mémoire de la bonne
taille pour mettre une valeur de ce type, mais n'y met aucune valeur d'initialisation !
◆ Après int i; la valeur de i est aléatoire.

►Une commande d’affectation, indiqué par l'opérateur d’affectation =, calcule d'abord

le résultat de l'expression à droite, puis affecte cette valeur à la variable à gauche,
écrasant la valeur précédente de la variable
►Tout comme le commentaire, l'indentation des lignes est une façon de rendre un
programme plus lisible et plus compréhensible pour les humains, sans changer
quelque chose pour le compilateur. C'est fortement conseillé !

4
 02/02/2023

REPRÉSENTATION DES DONNÉES

NUMÉRIQUES

REPRÉSENTATION DES VALEURS NUMÉRIQUES

Principe
► Les nombres sont représentés en mémoire sur des bits.
► Le nombre de bits dédiés à chaque nombre définit ses limites.

► Les limites sont de natures différentes selon que l’on encode des nombres entiers ou réels.

Architectures
4 bits Intel 4004 (1971)
8 bits MOS Technology 6502 (NES 1985), Sharp x80 (GameBoy 1989)
16 bits Intel 8086 (1978), 65C816 (Super Nintendo 1990)
32 bits Intel x86 (1985), AMD Athlon K5 (1995), R3000A (Playstation 1994)
64 bits Athlon 6 (2003), Pentium 4 (2004), ARMv8-A (2011)

10

5
 02/02/2023

Nombres entiers Nom

Nombres entiers Nom
Nombres entiers Nombr
Entier
Entiers signés NOMBRES ENTIERS Entier
Entiers
Stocké signés
en mémoire en base 2 : Bits s
Entiers signés Entiers
Stocké en mémoire en base 2 : p 2 Bits
X 8
Entiers signés Stocké en mémoire en base 2 : x = sX p 2 d 2i Bits 8
i 16
p s2 i
Stockés en mémoire en base 2 : x =X i=0 di i 2 8 1632 in
I s signe (en binaire le signe moins x = s est i=0
encodé
di 2 par 1)
► 𝑠 signe (en binaire le I
signe moins (en
s signe est encodé
binaireparle 1)
signe moins est encodé par 1)
16 3264 inil
I I int⇤lo
i=0 32 64 ,
p entier
s signe (en est
binairele nombre
le signedemoins
bits (souvent
est encodé puissance
par 1) de 2)
► 𝑝 entier est le nombre I de bits (souvent
p entier est lepuissance
nombre de de2)bits (souvent puissance de 2) 64 long
I I di 8i 2est0,le
p entier . . nombre
. , p 2 de est bits
un nombre
(souventbinaire (0 oude1).
puissance 2) I ⇤
I
► 𝑑! ∀𝑖 ∈ 0, … , 𝑝 − 2 est un
dinombre
8i 2 0, binaire
. . . , p (0 2ouest
1). un nombre binaire (0 ou 1). I ⇤s
I
I di 8i 2(16
Représentation en mémoire (16 bits) :
. . , p: 2 est un nombre binaire (0 ou 1).
0, .bits)
I Représentation
► Représentation en mémoire I ⇤ Le sy
en mémoire (16 bits) : I L
I Représentation signe 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20 syst
signe en 214mémoire
213 212 (16211
bits)210
: 29 28 27 26 25 24 23 22 21 20 I L
s 14d1413d1312d1211d1110d109 d98 d87 d76 d65 d54 d43 d32 d21 d10 d0 I C
I Les
Exercice signes 2 d 2 d 2 d 2 d 2 d 2 d2 d2 d2 d2 d2 d2 d2 d2 d2 d I C
14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

► Donner la représentation
Exercicebinairesdes dnombres
14 d13 suivants
d12 d11: d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0 I Ces
Exercice
Donner la représentation binaire des nombres suivants : Entie
Exercice
Donner la représentation binaire des nombres suivants : Entier
x signe 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20 I n
Entiers M
Donner la représentation 14 binaire
13 des2nombres
212 11
210 2suivants
9
28 27: 26 25 24 23 22 21 20
x signe 2
5 2 I M c
14
x 5signe 2 2 2 2 2 2 2 27 26 25 24 23 22 21 20
13 12 11 10 9 8
I Mêm c
-10 I D
5 -10 Icom
37 Dd
-10 37 I Déc d
37 de u
11 5 / 44
5 / 44

5 / 44
Limitation des entiers en C
Limitation des entiers en C
Limitation des entiers en C
Taille et intervalle
ensurNOMBRES ENTIERS EN C
Taille et intervalle
Nombres entiers I Entier
TailleIetEntier
Cp bits
intervalle
sur p bits
I Signé entre 2p 1 et 2p 1 1
Entiers
Entiers signés
signés I I Entier surentre
Signé p bits 2p 1 et 2p 1 1
I Non signé entre 0 et 2p 1
Bits Usage I I Signé
Nonentre 2p 1 0etet2p2p1 11 Intervalle
signé entre Déc.
8 char⇤ , int8It Représentation exacte et règles
-128 arithmétiques
à 127 respectées dans 3l’intervalle.
16
I I
int⇤ (min), int16Non et 2p et1-32
t signé entre 0 exacte
Représentation règles
768arithmétiques
à 32 767 respectées dans 5l’intervalle.
32 int⇤ , long⇤ (min)I Représentation
, int32 t exacte-2et
147 483 648
règles à 2 147 483respectées
arithmétiques 647 10
dans l’intervalle.
64 long⇤ , long long, Codeint64 t -9 223 372 036 854 775 808 à 9 223 372Sortie
source 036 854 775 807 19
Code sourcei=127;
int8_t Sortie
./ex_int
►∗ Le nombre de bits12 pour
1 1
char, short,
int8_t
int32_t i=127; int, long dépend du compilateur C 12et i=127
j=127; du système.
./ex_int
I ⇤ Code
Le nombre source
de bit Sortie
pour char, short, int, long dépend du compilateur C et du
23 int32_t
► Les types int*_t1 indépendant j=127;ont été définis dans le standard C99.
du système
printf("i=%d\n",i); 23 i=127
i+1=-128
int8_t i=127; 1 ./ex_int
système. 34 printf("i=%d\n",i);
i=i+1; 34 i+1=-128
j=127
► Ces types nécessitentint32_t j=127; i=127
45 la i=i+1;
déclaration du header <stdint.h>
2 2
4 j=127
20 I Les types int*
3
printf("i+1=%d\n",i);
tprintf("i=%d\n",i);
indépendant du système ont été définis dans j+1=128 C99.
le55 standard
3 i+1=-128
5 6 printf("i+1=%d\n",i);
printf("j=%d\n",j); j+1=128
6 j+3000000001=-1294967168
i=i+1;
I Ces types nécessite
4 4 j=127
d0 67 printf("j=%d\n",j);
la déclaration du header <stdint.h>
j=j+1; 6 j+3000000001=-1294967168
Entiers non signés
5 printf("i+1=%d\n",i); 5 j+1=128
78 j=j+1;
printf("j+1=%d\n",j); Exemple de déclaration
6
89
printf("j=%d\n",j);
printf("j+1=%d\n",j); 6 j+3000000001=-1294967168
► Même intervalle7mais commençant
j=j+1; à 0.
j=j+3000000000 ;
1 #include <stdint.h>
Entiers non signés 9
10 j=j+3000000000 ; Exemple de déclaration
printf("j+3000000001=%d\n",j);
► Déclarés en précédant
8 l’identifieur de unsigned ou comme uint*_t.
printf("j+1=%d\n",j); 2 int i;
10 printf("j+3000000001=%d\n",j); 3 int64_t j=2014;
20 j=j+3000000000 ;
I Même intervalle
9
mais 1 #include <stdint.h> 4 unsigned long k;
10 printf("j+3000000001=%d\n",j);int i;
commençant à 0. 2
7 / 44
3 int64_t j=2014;
I Déclarés en précédant l’identifieur 4 unsigned long k;
7 / 44

12 de unsigned ou comme uint* t. 7 / 44

5 / 44 6 / 44

6
 02/02/2023

Nombres entiers en C
Entiers signés
Bits Usage LIMITATION DES ENTIERS EN C
Intervalle Déc.
8 ⇤
char , int8 t -128 à 127 3
16 int⇤Taille
(min),et intervalle
int16 t -32 768 à 32 767 5
32 int⇤ , long ⇤ (min)
► Entier sur 𝑝, bits
int32 t -2 147 483 648 à 2 147 483 647 10
64 long⇤ , ► long
Signélong, int64
entre −2 t 2-9
"#$ et "#$223
− 1 372 036 854 775 808 à 9 223 372 036 854 775 807 19
► Non signé entre 0 et 2" − 1
I ⇤
Le nombre de bit exacte
► Représentation char,
pour et règlesshort, int, respectées
arithmétiques long dépend du compilateur C et du
dans l’intervalle.
système.
Source Sortie
I Les types int* t indépendant du système ont été définis dans le standard C99.
I Ces types nécessite la déclaration du header <stdint.h>
i=127
i+1=-128
j=127
Entiers non signés Exemple de déclaration
j+1=128
j+3000000001=-1294967168
I Même intervalle mais 1 #include <stdint.h>
commençant à 0. 2 int i;
3 int64_t j=2014;
I Déclarés en précédant l’identifieur 4 unsigned long k;
13 unsigned ou comme uint* t.
de

6 / 44

Nombres à virgule flottante

NOMBRES À VIRGULE FLOTTANTE
Virgule flottante
Virgule flottante
Un flottant Un
estflottant
encodé comme
est encodé : :
comme
x = sm2e d
► 𝑠 signe
I s signe► 1 ≤ 𝑚 < 2 mantisse (𝑚)
► 𝑒 exposant, 𝑑 decalage de l’exposant.
I 1  m < 2 mantisse (m)
I e exposant, décalage
NormedIEEE 754 de l’exposant
Norme IEEE 754
► Flottant 32 bits (s : 1 bits, m : 23 bits, e : 8 bits, d=28−1 −1=127)
◆ Chiffres significatifs : 2−23 ≈ 1.10−7 → 7 chiffres
◆ Min/max en valeur absolue : 1.10−38, 3.4.1038
► Flottant 64 bits (s : 1 bits, m : 52 bits, e : 11 bits, d=211−1 −1=1023 )

I Flottant◆32
Chiffres significatifs : 2 ≈ 2.2.10 → 15 chiffres
−52 −16
bits (s : 1 bits, m : 23 bits, e : 8 bits, d=28 1 1=127)
◆ Min/max en valeur absolue : 2.22.10−308, 1.79.10308
I Chi↵res significatifs : 2 23 ⇡ 1.10 7 ! 7 chi↵res
I Min/max en valeur absolue : 1.10 38 , 3.4.1038
I Flottant
14 64 bits (s : 1 bits, m : 52 bits, e : 11 bits, d=211 1 1=1023 )
I Chi↵res significatifs : 2 52 ⇡ 2.2.10 16 ! 15 chi↵res
I Min/max en valeur absolue : 2.22.10 308 , 1.79.10308

8 / 44
7
 02/02/2023
Opérations en virgule flottante Flottants
Soient x1 et x2 deux nombres flottants.
Addition
I L’addition nécessite queOPÉRATIONS I De la mê
ENaient
les deux nombres VIRGULE
le mêmeFLOTTANTE
exposant.
I Si e1 = e2 , on additionne les mantisses. compilat
Soient 𝑥$ et 𝑥% deux nombres flottants. I Les type
I Si e1 6= e2 , on décale la mantisse du nombre le plus petit pour qu’ils aient le
Addition <math.h
même►exposant, ensuite on additionne les mantisses.
L’addition nécessite que les deux nombres aient le même exposant. I La précis
I Si après
► Si l’addition la mantisse
𝑒$ = 𝑒%, on additionne m > 2, on la décale vers la droite et on ajoute 1 à
les mantisses. le codag
l’exposant.
► Si 𝑒$ ≠ 𝑒%, on décale la mantisse du nombre le plus petit pour qu’ils aient le même exposant, ensuite on Code source
additionne les mantisses.
I Attention si les nombres sont d’un ordre de grandeur très di↵érents ! 1 float_t x=
► Si après l’addition la mantisse m > 2, on la décale vers la droite et on ajoute 1 à l’exposant.
2 printf("x=
► Attention si les nombres sont d’un ordre de grandeur très différents ! 3 x=x+1e-8;
Multiplication 4 printf("x+
Multiplication
5 x=x+1e50;
printf("x+
x1 x2 = m1 m2 2e1 +e2 2d 6
7 double_t y
► On effectue le produit des mantisses et la somme des exposants. 8 printf("y=
I On e↵ectue le deproduit
► Si 𝑚 sort des
l’intervalle, mantisses
on décale et et
la mantisse lachange
somme des exposants.
l’exposant. 9 y=y+1e-8;
I si m sort de l’intervalle, on décale la mantisse et change l’exposant. 10 printf("y+
11 y=y+1e50;
15 12 printf("y+
9 / 44

Exemples d’encodage Les point

Flottants en C FLOTTANTS EN C
Définition
Code source Bits Usage absolute max/min Déc.
I Un point
1 int nb=7; 32 float⇤ , float t 1.10 38 , 3.4.1038 7
64 double⇤ , double t 2.22.10 308 , 1.79.10308 15 d’une au
2 float lst[] = { 3.14,0.125, 9.3, 0,-0.,atof("NaN"), atof("inf") };
3
► De la même manière que pour les entiers, les types float et double dépendent du compilateur et du système.
I De la même manière que pour les entiers, les types float et double dépendent du I L’accès à
for (int► Les types
i=0; float_t et double_t
i<nb;i++)
compilateur sont définis dans le standard C99 (entête <math.h>).
et du système. I L’accès à
4
5 { ► LaIprécision numérique
Les types floatettles
eterreurs
double d’arrondis
t sont doivent
définis être
dansprisleenstandard
compte dans
C99le (entête
codage.
aient le 6 printf("%2.6f -> ",lst[i]);
<math.h>). I Les poin
Source
printBits_IEEE754(sz, lst+i); Sortie
7
I La précision numérique et les erreurs d’arrondis doivent être pris en compte dans I Ils doiven
n ajoute 81 };
à le codage.
x=1.00000000
Sortie Code source Sortiex+1e-8=1.00000000
1 ./ex_float_enc
1 float_t x=1.; 1 ./ex_float
x+1e50=inf
2 printf("x=%2.8f\n",x); x=1.00000000
y=1.00000000
Code source
2 3.140000 -> 0 10000000 10010001111010111000011 2
3 x=x+1e-8; y+1e-8=1.000000010000000
x+1e-8=1.00000000 1 int i=10;
3 0.125000 -> 0 01111100 00000000000000000000000 3 y+1e50=1.000000000000000e+50
4 printf("x+1e-8=%2.8f\n",x); 4 x+1e50=inf 2 int *p=NUL
4 9.300000 -> 0 10000010 00101001100110011001101 5
5 x=x+1e50; y=1.00000000 3 printf("i=
5 0.000000 -> 0 00000000 00000000000000000000000 6
6 printf("x+1e50=%2.8f\n",x); y+1e-8=1.000000010000000 4 p=&i;
6 -0.000000 -> 1 00000000
7 double_t y=1.; 00000000000000000000000 7 y+1e50=1.000000000000000e+50
printf("y=%2.8f\n",y); 5 printf("i=
7 nan -> 0 11111111 10000000000000000000000
8
9 y=y+1e-8; 6 *p=5;
8 inf16-> 0 11111111 00000000000000000000000
10 printf("y+1e-8=%2.15f\n",y); 7 printf("i=
11 y=y+1e50; 8 p[0]=4;
12 printf("y+1e50=%2.15e\n",y); 9 printf("i=
9 / 44 10 / 44

11 / 44 8
Les pointeurs
Définition
 02/02/2023

LES POINTEURS

Définition
► Un pointeur est une variable dont la valeur (un entier) est l’adresse mémoire d’une autre variable (ou d’une série
de valeurs).
► L’accès à la valeur pointée par l’adresse est fait avec l’opérateur *.

► L’accès à l’adresse d’une variable se fait par l’intermédiaire de l’opérateur &.

► Les pointeurs peuvent être utilisés pour tout type d’objets.

► Ils doivent toujours pointer sur une zone mémoire allouée (segmentation fault).

Source Sortie

i=10, p=0
i=10, p=1568687836
i=5, p=1568687836
i=4, p=1568687836

17

CHAINES DE CARACTÈRES

► Ce sont des pointeurs vers une suite de caractères imprimables (type char).
► Nombreuses fonctions de gestion définies dans <string.h>.
► Se termine par le caractère \0. Elle a donc un octet de plus que la liste de caractères imprimables.

► Toujours possible de déterminer sa taille avec la fonction strlen().

► Une chaîne de caractères est délimitée par " en C.

► Le caractère \n représente un retour à la ligne, \t une tabulation.
► On accède aux caractères avec l’opérateur [ ] (indexage à 0).
Source Sortie

Premier texte
abcdefghijklmnopqrstuvwxyz

18

9
 02/02/2023

TABLEAUX 1D ET MÉMOIRE

Les tableaux utilisent les pointeurs pour accéder à une suite de valeurs voisines en mémoire. L’opérateur utilisé
pour la déclaration et l’accès aux données est [ ].
Allocation et déclaration
► Taille donnée : type_t p[n];
◆ Initialise un tableau vers n cases mémoires du type type_t

► Par valeur : type_t p[]={val1,val2,...,valn};

◆ Initialise un tableau vers n cases mémoire du type type_t avec les valeurs données dans {...}

Source Sortie

p1->1,2,5,10,17,26,37,50,65,82,
p2->1,2,3,4,5,6,7,8,9,10,

19

TABLEAUX N-DIMENSIONNELS

► Les tableaux peuvent être étendu à N dimensions.

► Les déclarations de font de manière similaire.

Source Sortie

m1:
0,1,2,
1,2,3,
2,3,4,

m2:
1,2,3,
4,5,6,
7,8,9,

20

10
 02/02/2023

TABLEAUX ET POINTEURS

► Les tableaux peuvent être vus comme des pointeurs à l’adresse fixée.
► Un pointeur peut récupérer l’adresse d’un tableau et avoir accès aux données mais doit utiliser un indexage
linéaire (warning compilateur).

Source Sortie

m[0][0]=1
*p=1
p[0]=1
m[2][1]=8
*(p+2*3+1)=8
p[2*3+1]=8

21

STRUCTURES ET DÉFINITION DE TYPE

► struct permet de définir une structure contenant plusieurs variables.

► Les valeurs de ces variables sont obtenues avec l’opérateur .

► typedef permet de définir un type (évite de répéter le struct).

► Une structure peut être adressée avec un pointeur.

Source Sortie

Etudiant:
Nom: Toto
Note: 12.500000

22

11
 02/02/2023

STRUCTURE D’UN PROGRAMME C

Source Sortie

Structures et définition de type

Hello, world!
I struct permet de définir une structure contennant plusieurs variables.
I Les valeurs de ces variables sont obtenues avec l’opérateur .
I typedef permet de définir un type (évite de répéter le struct).
I Une structure peut être adressée avec un pointeur.

► #include <stdio.h>, en-tête standard contenant les déclarations des fonctions d’entrées-sorties (dont
Code source Sortie
printf). 1 struct etud 1 ./ex_struct
{ Etudiant:
► int est le type renvoyé par la fonction main. 2 2
3 char nom[50]; 3 Nom: Bibi
► main est le nom de la fonction principale, aussi 4appelée point
floatd’entrée
note; du programme. 4 Note: 12.500000
5 };
► Les parenthèses après main indiquent qu’il s’agit6 d’une fonction.
7 typedef struct etud Etudiant;
► Les accolades { et } entourent les instructions constituant
8 le corps de la fonction main.
9 Etudiant e;
► Un point-virgule ; termine l’instruction. 10 strcpy(e.nom,"Bibi");
11 e.note=12.5;
12
23 13 printf("Etudiant:\nNom: %s\nNote:
%f",e.nom,e.note);

17 / 44

Entrée/Sortie écran
ENTRÉE/SORTIE
printf ÉCRAN
I Imprime une chaı̂ne de caractères à Type Format
printf int, long %d,%ld
l’écran (terminal).
► Imprime une chaîne de caractères à l’écran (terminal). unsigned int %u
I Chaı̂nes de caractères formatées en
float,double %f, %lf
► Chaînes de caractères formatées en insérant des valeurs contenues
insérant dans
des valeurs des variables.
contenues dans char %c
► Exemple : des variables. char* %s
I Exemple :

Input: printf("Color %s, Number %d, Float %5.2f", "red", 123456, 3.14);

Output: Color red, Number 123456, Float 3.14

scanf scanf
► Permet de demander à l’utilisateur du programmeId’entrer
Permet des données. à l’utilisateur du programme d’entrée des données.
de demander
► Même format que printf, passage de la variableIà modifier
Même formatpointeur
par à scanf("format",
que printf, &variable);
passage de la variable à modifier par pointeur.
int i; à scanf("%d",&i); | float t; à scanf("%f",&t);
I Préférer le passage d’information par ligne de commande.
► Utiliser getchar() pour lire un caractère.
19 / 44
► Préférer le passage d’information par ligne de commande.

24

12
 02/02/2023

ENTRÉE/SORTIE PAR LIGNE DE COMMANDE

► Des paramètres (séparés par des espaces) peuvent être donnés lors de l’exécution du programme.
► Les paramètres donnés en ligne de commande sont passés à la fonction main.
► argc est un entier donnant le nombre de paramètres et argv est un tableau de pointeurs vers ces paramètres.

► Le premier paramètre (index 0) est toujours le nom du programme.

Source Sortie
Sans paramètre
Nombre de params: 1
Param. 0: ./a.out
Avec paramètres :1 "Hello world"

Nombre de params: 3
Param. 0: ./a.out
Param. 1: 1
Param. 2: Hello world

25

ENTRÉE/SORTIE FICHIER
Écriture de fichier avec fputs
► Le type FILE permet de gérer la lecture/écriture dans un fichier à l’aide des fonctions fopen, fputs, fgets,
fscanf, fclose .
► Un fichier doit être ouvert avec fopen et fermé avec fclose pour être écrit sur le disque.

Source Sortie

fichier_example.txt
Texte de test
Sur deux lignes

Lecture de fichier
► fgets permet de lire une chaine de caractères de taille connue à partir d’un pointeur fichier.
► fscanf permet de lire une chaine de caractères formatée.

26

13
 02/02/2023

PORTÉE OU VISIBILITÉ DES VARIABLES

Cela représente la validité ou accessibilité du contenu d’une variable dans un programme.

► Variable Globale
◆ Déclarée à l’extérieur du main et des autres fonctions.
◆ Son contenu est en lecture/écriture partout.
► Variable locale
◆ Déclarée à l’intérieur du main ou des autres fonctions.
◆ Son contenu est en lecture/écriture dans la fonction mais n’est pas accessible ailleurs.
◆ Son nom peut être le même qu’une autre variable dans une autre fonction.

◆ Un argument reçu par une fonction est considéré comme une variable locale.
◆ Si une variable locale a le même nom qu’une variable locale (à éviter !!!), cette dernière sera utilisée.
► Variable statique
◆ Une variable déclarée comme static (static int i;) maintient sa valeur à travers les fonctions.

► Variable registre
◆ Une variable déclarée comme register (register int k;) indique au compilateur qu’elle sera utilisée fréquemment et
un registre pourrait lui être dédié.

27

PROGRAMME C ET FONCTIONS

28

14
 02/02/2023

FONCTIONS EN C

► Les fonctions permettent d’exécuter simplement une suite d’instructions (avec des paramètres).
► Elles sont définies par leur nom, liste de paramètres d’entrée et type de sortie.
► Si on veut modifier plusieurs variables dans une fonction on passe en paramètre des pointeurs vers les variables à
modifier.

Source Sortie

i=0, carre(i)=0
i=1, carre(i)=1
i=2, carre(i)=4
i=3, carre(i)=9
i=4, carre(i)=16

29

ENTÊTE ET DÉFINITION DE FONCTION

► Une fonction peut être déclarée sans sa définition. Ceci permet son utilisation sans avoir sa définition (dans un
autre fichier *.c par exemple)
► Il faut un point virgule à la fin de la déclaration (pas de la définition).
► Les directives compilateur #include "fichier.h" permettent de déclarer les fonctions pour une
utilisation dans le code (parfois utilisé pour la définition des fonctions).
► La définition des fonctions est souvent faite dans un fichier fichier.c associé au fichier fichier.h.

Source Sortie
carre.h Exp_fct.c

i=0, carre(i)=0
i=1, carre(i)=1
i=2, carre(i)=4
carre.c i=3, carre(i)=9
i=4, carre(i)=16

30

15
 02/02/2023

EXERCICE 1

Coder une fonction qui retourne le cube d’un nombre flottant :

Analyse du problème
► Nom :

► Entrée : Lien pour faire et rendre l’exercice

► Sortie : Groupe A : https://onlinegdb.com/classroom/invite/8qPuaAHXm

► Mise en œuvre : Groupe B : https://onlinegdb.com/classroom/invite/8SXaj0EYC
Groupe C : https://onlinegdb.com/classroom/invite/i5cYBIPop
Groupe D : https://onlinegdb.com/classroom/invite/--r9zJ75w
Groupe E : https://onlinegdb.com/classroom/invite/VD9UQa0ly
Groupe F : https://onlinegdb.com/classroom/invite/CcJB7OXAy

31

RÉCURSION

► Une notion est dite récursive quand elle fait référence à elle-même soit de manière directe ou indirecte.
► Méthode :
◆ Le paramétrage consiste à mettre en évidence les éléments dont dépend la solution, en particulier la taille du problème.

◆ La recherche et la résolution d'au moins un cas trivial.

◆ La décomposition du cas général consiste à passer d'un problème de taille N à un ou des problèmes de taille < N.

► Exemple : calcul de factorielle

◆ paramétrage : n

◆ cas triviaux : 1! = 0! = 1

◆ décomposition : n! = n* (n-1)!

Source Sortie

facto(3)=6
facto(5)=120
facto(7)=5040

32

16
 02/02/2023

POINTEUR DE FONCTION EN C

► Utiliser une variable comme une fonction.

► Utile pour résoudre des équations ou en intégration numérique.
► On utilise des pointeurs de fonction.

► Un pointeur de fonction est déclaré par : type_ret (*nomfunc)(params);

Source Sortie

f1(2)=4.000000
f2(2)=0.909297

33

BIBLIOTHÈQUES STANDARD DU C

► Ce sont un ensemble de fonctions et de fichiers d’entête qui sont présents sur tous les systèmes.
► Ils forment la bibliothèque standard ANSI C.
► Liste des entêtes/fonctions les plus utiles, mais documentation détaillée sur le web.

Principaux fichiers d’entête :

<stdio.h> Entrées/Sorties standards (terminal et fichiers).
<stdlib.h> Allocation mémoire et générateur aléatoire.
<strings.h> Gestion des chaînes de caractères.
<math.h> Fonctions mathématiques courantes.
<float.h> Constantes pour les nombres à virgule flottante (ε, min, max).
<limits.h> Constantes pour les nombres entiers ( min, max).
<complex.h> Nouveaux types pour les nombres complexes (C99).
<time.h> Temps et affichage de dates.

34

17
 02/02/2023

BIBLIOTHÈQUE STANDARD : <STDIO.H>

Fonctions d’entrée/sortie de base :

► Entrée/sortie terminal
printf Écrire une chaîne de caractères dans le terminal.
scanf Lire une chaîne de caractères sur le terminal.
► Entrée/sortie fichier
fopen Ouverture de fichier.
fclose Fermeture de fichier et écriture définitive.
fprintf Écrire une chaîne de caractères dans un fichier.
fscanf Lire une chaîne de caractères dans un fichier.

Source Sortie
i=-10, j=3
x=3.142 ou x=3.141590e+00
Nom: toto

35

BIBLIOTHÈQUE STANDARD : <STRING.H>

Fonctions de gestion de chaînes de caractères :

► Gestion de chaînes de caractères
strcpy Copie de chaîne.
strcat Concaténation de deux chaînes.
strlen Longueur d’une chaîne.
► Conversion de chaînes de caractères
atof Conversion de chaîne en flottant.
atoi Conversion de chaîne en entier.

Source Sortie

Prénom, Nom

36

18
 02/02/2023

BIBLIOTHÈQUE STANDARD : <MATH.H>

Fonctions mathématiques de base : ► Nombres à virgule flottante

► Nombres entiers round Arrondi d’un flottant.
abs Valeur absolue. fabs Valeur absolue.
div Division entière (quotient et reste). exp Exponentielle.
log(10)Logarithme népérien et décimal.
pow Puissance.
sqrt Racine carrée.
sin/cos/tan Fonctions trigonométriques.

Source Sortie
round(3.14)=3.000000
log(2)=0.693147
exp(1)=2.718282
sqrt(2)=1.414214
sin(1)=0.841471

37

37

OPÉRATEURS ARITHMÉTIQUES EN C

► Une expression (¹ instruction) indique une action à mener (expression = élément syntaxique).
► Une expression représente une donnée élémentaire (constante, variable, un élément d’un tableau, le résultat d’un calcul, …).

► Toute expression a une valeur.

► Opérateur bi-opérandes ► Opérations unaires

◆ +,- ◆ +,- signe (ex: a=-b)
◆ *,/,% (modulo) ◆ ++,-- incrémentation et décrémentation.

◆ Les opérandes doivent être des valeurs numériques. ◆ ++i pré-incrémentation (incrémentationàopération).

◆ int opérateur int à résultat int ◆ i++ post-incrémentation (opérationàincrémentation).

◆ float opérateur float à résultat float

◆ int opérateur float à résultat float

Source Sortie

Post: i=3, j=4

Pré: i=4, j=4

38

38

19
 02/02/2023

OPÉRATEURS LOGIQUES ET RELATIONNELS EN C

Ces opérateurs sont utilisés pour tester une condition booléenne (branchement ou boucle) et pour combiner les
conditions.
► Comparaisons ► Opérations booléennes Exemples

◆ ==, != Égalité, inégalité. ◆ ~ Complément à 1. 5 0000 0000 0000 0101

◆ <,> Stricte comparaison. ◆ & ET booléen. 20 0000 0000 0001 0100

◆ | OU booléen. 5 & 20 0000 0000 0000 0100 => 5 & 20 => 4
◆ <=, >= Comparaison avec égalité
◆ ˆ OU exclusif booléen. 5 | 20 0000 0000 0001 0101 => 5 | 20 => 21
◆ << Décalage à gauche. 5 ^ 20 0000 0000 0001 0001 => 5 ^ 20 => 17
◆ >> Décalage à droite. ~5 1111 1111 1111 1010 => -6
► Opérations logiques
◆ && ET logique. Exercice
◆ || OU logique. Donner la valeur binaire retournée par ces expressions :
► (1>=0)&!(10==10) :
◆ ! NON logique.
► 4==9/2 :
◆ 0 est considéré comme la valeur logique "faux", toute
► (1<=0)|!(10) :
valeur ¹ 0 comme la valeur logique "vraie"
► i=3.; (i<=4)&(i>=1) :
► i=3.; (i>=4)|(i<=1) :
39

39

OPÉRATEURS D’AFFECTATION EN C

► Une expression (¹ instruction) indique une action à mener (expression = élément syntaxique).
► Une expression représente une donnée élémentaire (constante, variable, un élément d’un tableau, le résultat d’un calcul, …).

► Toute expression a une valeur.

► Opérateur bi-opérandes ► Opérations unaires

◆ +,- ◆ +,- signe (ex: a=-b)
◆ *,/,% (modulo) ◆ ++,-- incrémentation et décrémentation.

◆ Les opérandes doivent être des valeurs numériques. ◆ ++i pré-incrémentation (incrémentationàopération).

◆ int opérateur int à résultat int ◆ i++ post-incrémentation (opérationàincrémentation).

◆ float opérateur float à résultat float

◆ int opérateur float à résultat float

40

40

20
 02/02/2023

CONDITION IF

► Exécute une série d’instructions si une condition est vérifiée.

► Format standard : if (condition){instructions};
► Le mot clé else permet de définir des instructions exécutées si la condition est fausse :

if (condition){instructions1}; else {instructions2};

Source Sortie

Le nombre a est inférieur à 5

41

CONDITION SWITCH

► Permet de tester l’égalité d’une variable avec plusieurs valeurs.

► Attention à ne pas oublier le mot clé break pour éviter d’exécuter tous les cas.
► Le dernier cas default permet de gérer les cas qui n’ont pas été définis.

Source Sortie

12
Le nombre a est égal à une autre
valeur

42

21
 02/02/2023

BOUCLE FOR

► Format en C : for (initialisation;condition;iteration){instructions};

► La boucle exécute les instructions tant que condition est vraie, iteration est exécuté à chaque tour de la
boucle.
► La boucle for est en général utilisée lorsque l’on connait le nombre d’itérations a priori.
► Exemple d’itérations avec une variable entière :

Source Sortie i=0, i*i=0

Exemple d’itérations avec une variable entière : i=1, i*i=1
i=2, i*i=4
i=3, i*i=9
i=4, i*i=16

Exemple d’itérations avec une variable flottante : x=0.000000, x*x=0.000000

x=0.200000, x*x=0.040000
x=0.400000, x*x=0.160000
x=0.600000, x*x=0.360000
x=0.800000, x*x=0.640000

43

BOUCLE WHILE

► Format en C : while (condition){instructions};

► La boucle exécute les instructions tant que condition est vraie.

Source Sortie

s=1, i=1
s=4, i=2
s=9, i=3
s=16, i=4
s=25, i=5

► Attention à l’initialisation et à bien vérifier que la boucle se termine.

► Souvent remplacée par une boucle for en C car cette dernière est extrêmement puissante.

44

22
 02/02/2023

Boucle for
BOUCLE DO…WHILE
I Format en C : for (initialisation;condition;iteration){instructions};
eurs valeurs. I La boucle exécute les instructions tant que condition est vraie, iteration
► Format en C : do {instructions} while (condition);
est exécuté à chaque tour de la boucle.
► La boucle exécute les I
instructions
La boucle au for
moins
estune
en fois avantutilisée
général de vérifier la condition.
lorsque l’on connait le nombre d’itérations à
ex_switch
nombre a est egal a 1 ou 2 priori.
Source I Exemple d’itérations avec une variable Sortie
entière :
Code source Sortie
1 int nb=5; 1 ./ex_for
2 for (int i=0;i<nb;i++) s=1, i=1
2 i=0, i*i=0
3 printf("i=%d, i*i=%d\n",i,i*i); s=4, i=2
3 i=1, i*i=1
s=9, i=3
4 i=2, i*i=4
s=16, i=4
5 i=3, i*i=9
s=25, i=5
6 i=4, i*i=16

I Exemple d’itérations avec une variable flottante :

Code source Sortie
1 float pas=.2; 1 ./ex_for2
2 float max=1.0; 2 x=0.000000, x*x=0.000000
3 for (float x=0;x<max;x=x+pas) 3 x=0.200000, x*x=0.040000
viter d’exécuter tous les cas. 4 printf("x=%f, x*x=%f\n",x,x*x); 4 x=0.400000, x*x=0.160000
5 x=0.600000, x*x=0.360000
n’ont pas été définis.
6 x=0.800000, x*x=0.640000
45 33 / 44 34 / 44

Exercice 2 : Somme

EXERCICE
Coder une fonction C calculant la2 valeur
: SOMME
entière
dition est vraie. n
X
► Coder une fonction C calculant la valeur entière sommecarre(n) = i2
i=0

ex_while
, i=1
, i=2 Analyse du problèmeAnalyse du problème Solution
, i=3 ► Nom : I Nom :
6, i=4
5, i=5 ► Entrée : I Entrée :
► Sortie : I Sortie :
► Mise en œuvre : I Mise en oeuvre :

boucle se termine.
tte dernière est extrêmement

35 / 44 36 / 44

46

23