École Centrale

de Marseille

² ¯
Programmation Structurée
en Langage C - 1re année
± °

Stéphane Derrode, Bureau 206 (Institut Fresnel),

[Link]@[Link]

Pôle Mathématique et Informatique

Programmation Structurée en Langage C, 1re année

Sommaire
ë Introduction, Tr. 3
ë Types et variables, Tr. 5
ë Lire et écrire, Tr. 11
ë Opérateurs et expressions, Tr. 16
ë Types dérivés (tableaux), Tr. 21
ë Instructions de contrôle, Tr. 25
ë Fonctions, Tr. 37
ë Pointeurs et adresses, Tr. 43
ë Compilation séparée et Makefile, Tr. 54
ë Préprocesseur, Tr. 61
ë Structures, unions et énumérations, Tr. 66
ë Manipulation des fichiers, Tr. 79
ë Autres petites choses. Tr. 96

ECM, Mathématique et Informatique, S. Derrode 2

Programmation Structurée en Langage C, 1re année

Le langage C

ë B.W. Kernighan et D.M. Ritchie : Le Langage C ANSI, 1977 ;

ë Langage ¿ universel À : disponible sur toutes les plate-formes
(Unix, Linux, Windows, ...) ;
ë Langage de ¿ 2e génération À, comme Pascal / Delphi ;
ë Langage structuré (modulaire) et impératif :
– Types de variables : Nombres entiers, nombres réels, caractères
– Structures de contrôle : Si ... alors, boucles, séquences
– Construction de types : Tableaux, structures, enregistrements
– Sous-programmes : Fonctions
ë Langage compilé (6= interprété) ;
ë Successeur : langage orienté objet C++ (OG de 2e A).

ECM, Mathématique et Informatique, S. Derrode 3

Programmation Structurée en Langage C, 1re année

Premiers programmes

1 – Ne fait rien 2– ¿ Hello World ! À

/∗ #i n c l u d e <s t d i o . h>
Programme minimum
ne f a i s a n t rien i n t main ( )
∗/ {
// A f f i c h e l e message
i n t main ( ) p r i n t f ( ” \ n H e l l o World ! ” ) ;
{
return 0 ; return 0 ;
} }

démo 1
Ligne de compilation : cf. Tr. 105

ECM, Mathématique et Informatique, S. Derrode 4

Programmation Structurée en Langage C, 1re année

Principales bases
Bases Notations Symboles
2 binaire 0, 1
8 octale 0, 1, ..., 7
10 décimale 0, 1, ..., 9
16 hexadécimal 0, 1, ..., 9, a, b, c, d, e, f

décimale binaire octale hexadécimal

70 1000110 106 46
511 111111111 777 1FF

70 = 0 ∗ 20 + 1 ∗ 21 + 1 ∗ 22 + ... + 1 ∗ 26 , 70 = 6 ∗ 160 + 4 ∗ 161

ECM, Mathématique et Informatique, S. Derrode 5

Programmation Structurée en Langage C, 1re année

Élément mémoire : bit et octet

ë Un octet (ou ¿ byte À) est composé de 8 ¿ bits À,

ë Un bit est un élément mémoire de base : valeurs 0 ou 1.
ë Un octet : 28 = 256 possibilités, valeurs de -128 à +127.
Octet : 8 bits

0 1 0 0 0 1 1 0

Bit de signe

ë Mémoire (RAM) : suite d’octets adressés.

Memoire (RAM)
Octet Octet Octet

Adresse 0x2ab09c 0x2ab09d 0x2ab09e

ECM, Mathématique et Informatique, S. Derrode 6

Programmation Structurée en Langage C, 1re année

Les différents types de variables

ý En informatique, on fait la distinction entre les variables contenant des

entiers, des nombres réels, des tableaux (vecteurs) de nombres, ...

ý On peut distinguer 5 types de variables :

ë Types entiers : nombres entiers et caractères - Tr. 8.
ë Types flottants : nombre réels - Tr. 10.
ë Types dérivés : tableaux (chaı̂nes de caractères) - Tr. 21.
ë Types pointeurs : adresse mémoire - Tr. 43.
ë Types complexes : structures (unions et énumérations) - Tr. 66.

ECM, Mathématique et Informatique, S. Derrode 7

Programmation Structurée en Langage C, 1re année

Types entiers
ý 3 types entiers
ë char : ’a’ (1 octet), de -128 à +127. ë Tr. 9
ë short int : -10814 (2 octets), de -32768 à +32767.
ë int, long int : 158141234 (4 octets), de ... à ...
Qualificatifs : signed (défaut) ou unsigned.

ý Déclaration, initialisation de variables

Déclaration Initialisation Les deux

int i ; i=-5 ; unsigned int k=5, j=2 ;
unsigned char c ; c=’s’ ; (c=115 ;) char v = 168 ;

ý Constantes : const unsigned char c=’S’ ; const int dix=10 ;

ECM, Mathématique et Informatique, S. Derrode 8

Programmation Structurée en Langage C, 1re année

Type char
ë Entre côtes : ’a’, ’z’, ’B’
ý Table des codes ASCII (annexe du poly. de langage C).
ë Valeur de type entier
’A’ à ’Z’ : caractères majuscule ý code ASCII : 65 à 90
’a’ à ’z’ : caractères minuscule ý code ASCII : 97 à 122
’0’ à ’9’ : caractères chiffres ý code ASCII : 48 à 57
ë Caractères spéciaux :
’\’’ : apostrophe ý code ASCII : 39
’\\’ : antislash ý code ASCII : 92
’\t’ : tabulation ý code ASCII : 9
’\n’ : saut de ligne ý code ASCII : 10
’\0’ : terminaison de chaı̂ne ý code ASCII : 0

ECM, Mathématique et Informatique, S. Derrode 9

Programmation Structurée en Langage C, 1re année

Types flottants

ý 3 types flottants
ë float : 125.46 (4 octets), de −1038 à +1038 .
ë double,long double : 1.55e-6, (8 octets), de −10308 à +10308 .
Qualificatifs signed ou unsigned interdits ! ! !
ý Déclaration, initialisation de variables

Déclaration Initialisation Les deux ensemble

float v ; v=-5.8975 ; float w=4.25, z=-5E-5 ;
double x ; x=+5.23e-12 ; double y = -168E2 ;

ý Variable à valeur constante : const double PI=3.14 ;

ECM, Mathématique et Informatique, S. Derrode 10

Programmation Structurée en Langage C, 1re année

Lire / Écrire (Input/Output)

Librairie standard : #include<stdio.h>

printf() : Le programme affiche des résultats sur la console.

ë int i=5 ; printf("La valeur de i est %d", i) ;
ë char c=’A’ ;
printf("Caractere : %c, code ASCII : %d", c, c) ;
ë char ch[9]="hello" ;
printf("message : %s", ch) ;
scanf() : L’utilisateur donne des informations au programme.
ë float reel ; scanf("%f", &reel) ;
ë float r1,r2,r3 ;
printf("Entrez trois nombres réels :") ;
scanf("%f%f%f", &r1, &r2, &r3) ;
Exemples : cf. poly Langage C, Chapitre 3. démo 2

ECM, Mathématique et Informatique, S. Derrode 11

Programmation Structurée en Langage C, 1re année

Déclaration Lecture Écriture Format externe

int i ; scanf("%d",&i) ; printf("%d",i) ; décimal
int i ; scanf("%o",&i) ; printf("%o",i) ; octal
int i ; scanf("%x",&i) ; printf("%x",i) ; hexadécimal
float m ; scanf("%f",&m) ; printf("%f",m) ; point décimal
double m ; scanf("%lf",&m) ; printf("%lf",m) ; point décimal
double m ; scanf("%le",&m) ; printf("%le",m) ; exponentielle
double m ; scanf("%lg",&m) ; printf("%lg",m) ; la + courte
char o ; scanf("%c",&o) ; printf("%c",o) ; caractère
char p[10] ; scanf("%s",p) ; printf("%s",p) ; chaı̂ne de caractères

ECM, Mathématique et Informatique, S. Derrode 12

Programmation Structurée en Langage C, 1re année

Exemples de printf() et scanf()

#i n c l u d e <s t d i o . h>
i n t main ( ) {
i nt a = 5 ;
i nt b = a ;

a = 8;
p r i n t f ( ” a = %d , b = %d” , a , b ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 13

Programmation Structurée en Langage C, 1re année

démo 3

#i n c l u d e <s t d i o . h>
i n t main ( ) {
char t t [ 8 0 ] ; // Tableau de 80 c a r a c t è r e s
p r i n t f ( ” Donnez une c h a i n e de c a r a c t e r e s : ” ) ;
s c a n f ( ”%s ” , t t ) ;
p r i n t f ( ” \nLa c h a i n e e n t r e e e s t : %s \n” , t t ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 14

Programmation Structurée en Langage C, 1re année

#i n c l u d e <s t d i o . h>
in t main ( ) {
i n t i =10;
float l =3.14159;
char p [ 5 0 ] = ” Bonjour ” ;

p r i n t f ( ”Avant l e c t u r e au c l a v i e r : %d %f %s \n” , i , l , p ) ;
s c a n f ( ”%d%f%s ” ,& i ,& l , p ) ;
p r i n t f ( ” Apres l e c t u r e au c l a v i e r : %d %f %s \n” , i , l , p ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 15

Programmation Structurée en Langage C, 1re année

Opérateurs arithmétiques

Par ordre de priorité croissante

ë -, + : unaire (inverse/confirme le signe). Ex : -a, +5.6
ë +, - : addition et soustraction. Ex : 6+5, a-5.6
ë *, / : multiplication et division. Ex : 6*5, a/5.6
ë % : reste de la division entière. Ex 7%2 donne 1 (7 = 3 ∗ 2 + 1)

démo 4

#i n c l u d e <s t d i o . h>
i n t main ( ) {
i n t i =10 , j =−3;
i n t k = i −j ;
p r i n t f ( ” \nk=%d , c a l c u l=%d\n” , k , ( i ∗ i )%(− j ) ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 16

Programmation Structurée en Langage C, 1re année

Librairie mathématique : #include<math.h> : cos, sin, tan, ... démo 5

#i n c l u d e <s t d i o . h>
#i n c l u d e <math . h>
i n t main ( ) {
double a ;
p r i n t f ( ” \ n E n t r e z un a n g l e : ”) ;
s c a n f ( ”% l f ” , &a ) ;

p r i n t f ( ” Le c o s de l ’ a n g l e vaut : % l f \n” , c o s ( a ) ) ;
p r i n t f ( ” Son l o g a r i t h m e vaut : % l f \n” , l o g 1 0 ( a ) ) ;
return 0 ;
}

Attention : Conversion implicite et explicite (¿ cast À)

ë float f = 2 / 4; ýf = 0.0
ë float f = 2.0 / 4 ; ýf = 0.5
ë int i = 2.0 / 4 ; ýi = 0
ë float j = (float) 3/2 ; ýj = 1.5

ECM, Mathématique et Informatique, S. Derrode 17

Programmation Structurée en Langage C, 1re année

Incrémentation et décrémentation
Incrémentation
ë i++ ; ou ++i ; signifie i = i + 1 ;
ë i += n ; signifie i = i + n ;
ë Même chose avec i--, --i et i -= n
Pré-incrémentation
ë int i = 5 ; int a = ++i ; donne i=6 et a=6
ë int i = 5 ; int a = --i ; donne i=4 et a=4
Post-incrémentation
ë int i = 5 ; int a = i++ ; donne i=6 et a=5
ë int i = 5 ; int a = i-- ; donne i=4 et a=5

ECM, Mathématique et Informatique, S. Derrode 18

Programmation Structurée en Langage C, 1re année

Opérateurs relationnels et logiques

ý Opérateurs relationnels (true ou false)

ë ==, != : identité, différent . Ex : A == 5
ë >, <, >=, <= : supérieur, inférieur
Exemples int A = 10, B = -5 ;
ë A == B ý 0 : false
ë A >= B ý 1 : true
Attention Les deux opérandes doivent avoir le même type arithmétique,
sinon une conversion de types est effectuée.
ý Opérateurs logiques :
ë ! : négation unaire d’une valeur logique. Ex : !true == false
ë && : ¿ ET À de deux valeurs logiques. Ex : true && false == false
ë || : ¿ OU À de deux valeurs logiques. Ex : true || false == true
Exemple de combinaison d’opérateurs : (K>5) && (L<10).

ECM, Mathématique et Informatique, S. Derrode 19

Programmation Structurée en Langage C, 1re année

Priorité des opérateurs (ordre décroissant)

Classe d’opérateur Opérateur(s) Associativité
Parenthèsage () de gauche à droite
Suffixes [] -> . ++ –– de gauche à droite
Unaires & * + - ! sizeof ∼ de droite à gauche
Changement de type (type) de droite à gauche
Multiplicatifs * / % de gauche à droite
Additifs + - de gauche à droite
Décalage << >> de gauche à droite
Comparaisons < <= > >= de gauche à droite
Égalités == != de gauche à droite
ET bit à bit & de gauche à droite
OU exclusif bit à bit ∧ de gauche à droite
OU bit à bit  de gauche à droite
ET logique && de gauche à droite
OU logique  de gauche à droite
Condition ? : de droite à gauche
Affectations = += -= *= /= &= = ∧= <<= >>= de gauche à droite
Succession , de gauche à droite

ECM, Mathématique et Informatique, S. Derrode 20

Programmation Structurée en Langage C, 1re année

Types dérivés (1) : tableaux

ë Déclaration : int tab[5] ;

ë Initialisation :
– double tf[10]={3.5, 4.8, -2, 1.2} ;
– float tab[2][3]={{1.2, -1}, {5.8}} ;
tab[0][1]
tf[0] tf[5]
1.2 -1 0

3.5 4.8 -2 1.2 0 0 0 0 0 0

5.8 0 0 tab[1][2]

ë Affectation :
– tf[5] = 3.8 ;
– tab[0][2] = -5.0 ;

ECM, Mathématique et Informatique, S. Derrode 21

Programmation Structurée en Langage C, 1re année

#i n c l u d e <s t d i o . h>
i n t main ( ) {

double t f [ 5 ] = { 1 . 2 , −4.7 , 3 . 4 } ;
p r i n t f ( ”\ n t f [0]= %l f ” , t f [ 0 ] ) ;

double t = t f [ 2 ] ;
p r i n t f ( ” \ nt = %l f ” , t ) ;

démo 6 t f [ 3 ] = −8.789;
p r i n t f ( ”\ n t f [3]= %l f ” , t f [ 3 ] ) ;

p r i n t f ( ”\ n t f [5]= %l f ” , t f [ 5 ] ) ;
tf [5] = 1.21;
p r i n t f ( ” t f [5]= %l f ” , t f [ 5 ] ) ;

return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 22

Programmation Structurée en Langage C, 1re année

Types dérivés (2) : chaı̂nes de caractères

ë Déclaration : char chaine[20] ;
ë Initialisation :
– char hello1[13] = {’b’,’o’,’n’,’j’,’o’,’u’,’r’} ;
– char hello2[13] = "bonjour" ;

b o n j o u r \0

– char ch[] = "message" ;

m e s s a g e \0

ë ch[4] = ’b’ : remplace la lettre a par la lettre de b.

ë Pensez à ajouter un espace mémoire pour le caractère de terminaison
de chaı̂ne \0.
ë La fonction strlen() (bibliothèque #include <string.h>) ne
s’applique qu’aux chaı̂nes de caractère (et non aux tableaux de
nombres !).

ECM, Mathématique et Informatique, S. Derrode 23

Programmation Structurée en Langage C, 1re année

démo 7
#i n c l u d e <s t d i o . h>
#i n c l u d e < s t r i n g . h>
i n t main ( ) {
char ch1 [ 5 0 ] = ” Bonjour ! ” ;
p r i n t f ( ” \ nch1=%s ; ch1 [3]=% c ; ch1 [20]=% c ” , ch1 , ch1 [ 3 ] , ch1 [ 2 0 ] ) ;

char ch2 [ 1 2 0 ] ;
p r i n t f ( ” \ n E n t r e z une c h a i n e : ” ) ;
s c a n f ( ”%s ” , ch2 ) ;

ch2 [ 3 ] = ’ Z ’ ;
p r i n t f ( ” \ nch2=%s ; ch2 [3]=% c ; ch2 [20]=% c ” , ch2 , ch2 [ 3 ] , ch2 [ 2 0 ] ) ;

i n t t a i l l e = s t r l e n ( ch2 ) ;
p r i n t f ( ” \ n T a i l l e de ch2 = %d” , taille ) ;

return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 24

Programmation Structurée en Langage C, 1re année

Instructions de contrôle

ë Instructions conditionnelles :
if : test. Tr. 26
switch : table de branchement. Tr. 28
ë Instructions répétitives :
while. Tr. 30
for. Tr. 32
do ... while. Tr. 31
ë Rupture de séquence :
continue. Tr. 35
break, return. Tr. 36

ECM, Mathématique et Informatique, S. Derrode 25

Programmation Structurée en Langage C, 1re année

Inst. cond. : if

1- if ( expression ) if ( f i n == 1 )
p r i n t f ( ”Au r e v o i r ! ”) ;
instruction
if ( ( n==1) && (m>=10) ) {
2- if ( expression )
p r i n t f ( ” Bonjour ” ) ;
instruction1 fin = 1;
}
else else
instruction2 p r i n t f ( ”Au r e v o i r ” ) ;

ECM, Mathématique et Informatique, S. Derrode 26

Programmation Structurée en Langage C, 1re année

i n t main ( ) {

p r i n t f ( ” V o u l e z vous i m p r i m e r l e mode d ’ e m p l o i ?\ n” ) ;
char c ;
s c a n f ( ”%c ” , &c ) ;

if ( c== ’ o ’ )
p r i n t f ( ” \ nJe l a n c e l e p r o c e s s u s d ’ i m p r e s s i o n ” ) ;
else {
i f ( c== ’ n ’ )
p r i n t f ( ” \ nJe ne f a i s r i e n ” ) ;
else
p r i n t f ( ” Tapez o ou n” ) ;
}

return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 27

Programmation Structurée en Langage C, 1re année

Inst. cond. : switch

switch (expression) {
case value1 : bloc inst 1
break ;
case value2 : bloc inst 2
break ;
case valueN : bloc inst N
break ;
default : bloc inst d
break ;
}

ECM, Mathématique et Informatique, S. Derrode 28

Programmation Structurée en Langage C, 1re année

Inst. cond. : switch

char c ;
s c a n f ( ”%c ” , &c ) ; démo 8
switch ( c )
int i ;
{
s c a n f ( ”%d ” , & i ) ;
case ’a ’ :
switch ( i )
p r i n t f ( ” Choix ’a ’”) ;
{
break ;
case 1 :
case ’A ’ :
case 2 :
p r i n t f ( ” Choix ’A ’ ” ) ;
p r i n t f ( ” Choix 1 ou 2 ” ) ;
break ;
break ;
case ’b ’ :
case 3 :
p r i n t f ( ” Choix ’b ’”) ;
case 4 :
break ;
p r i n t f ( ” Choix 3 ou 4 ” ) ;
case ’B ’ :
break ;
p r i n t f ( ” Choix ’B ’ ” ) ;
default :
break ;
p r i n t f ( ” Mauvais choix ! ”) ;
default :
break ;
p r i n t f ( ” Mauvais choix ! ”) ;
}
break ;
}

ECM, Mathématique et Informatique, S. Derrode 29

Programmation Structurée en Langage C, 1re année

Inst. répétitive : while

while ( expression de fin ) instruction

i n t nb ;
p r i n t f ( ” \ n E n t r e z un nombre : ” ) ;
s c a n f ( ”%d” , &nb ) ;

Instruction Condition int i = 0 ;

while ( i <nb )
Vrai Faux {
printf (” Iteration : %d” , i ) ;
i ++;
}

ECM, Mathématique et Informatique, S. Derrode 30

Programmation Structurée en Langage C, 1re année

Inst. répétitive : do ... while

do instruction while ( expression de fin ) ;

démo 9
Instruction in t s [ 1 0 ] , i =0 , n =5634;
do {

Condition s [ i ] = n % 10;
i ++;
Vrai Faux n /= 1 0 ;
} while ( n > 0 ) ;

ECM, Mathématique et Informatique, S. Derrode 31

Programmation Structurée en Langage C, 1re année

Inst. répétitive : for

for ( exp1 ; exp2 ; exp3 ) instruction

Initialisation
Exp 1

Rebouclage
Exp 3
Test
Exp 2
Instruction Vrai Faux

ECM, Mathématique et Informatique, S. Derrode 32

Programmation Structurée en Langage C, 1re année

double ta b [ 4 ] = { 3 . 2 , 5 . 1 , 9 , −1.8};
int i ; démo 10
f o r ( i =0; i <=3; i ++)
char ch1 [ ] = ” Coucou ! ” ;
p r i n t f ( ” \ n V a l e u r : % l f ” , t ab [ i ] ) ;
char ch2 [ 5 0 ] ;
int i ;
i n t nb ;
f o r ( i =0; i <=s t r l e n ( ch1 ) ;
p r i n t f ( ” E n t r e z un nombre : ” ) ;
i ++)
s c a n f ( ”%d” , &nb ) ;
ch2 [ i ] = ch1 [ i ] ;
p r i n t f ( ” Copie=%s ” , ch2 ) ;
f o r ( i n t i=nb ; i >0; i −−)
p r i n t f ( ” I t e r numero : %d” , i ) ;

ECM, Mathématique et Informatique, S. Derrode 33

Programmation Structurée en Langage C, 1re année

ECM, Mathématique et Informatique, S. Derrode 34

Programmation Structurée en Langage C, 1re année

Rupture : continue
int i , j = 0 ;
char c =0;
f o r ( i = 0 ; c != ’ \n ’ ; i ++){
s c a n f ( ”%c ” , &c ) ;
i f ( ( c == ’ ’ | | ( c == ’ \ t ’ ) | | ( c == ’ \n ’ ) )
continue ;
j ++;
}

démo 11
Le programme compte le nombre de caractères non blancs entrés au clavier
et le nombre total de caractères (jusqu’à un Retour-chariot).
ë i contient le nombre total de caractères qui ont été tapés au clavier ;
ë j contient le nombre de caractères non blancs ;

ECM, Mathématique et Informatique, S. Derrode 35

Programmation Structurée en Langage C, 1re année

Rupture : break
i n t i , j =0;
char c =0;
f o r ( i =0; ; i++ ) {
s c a n f ( ”%c ” ,& c ) ;
i f ( c == ’ \n ’ ) break ;
i f ( ( c == ’ ’ ) | | ( c == ’ \ t ’ ) ) continue ;
j++ ;
}

ë La boucle se termine lorsque l’utilisateur tape un retour-chariot.

ECM, Mathématique et Informatique, S. Derrode 36

Programmation Structurée en Langage C, 1re année

Fonctions : rôles et intérêts

ý Objectifs : Découper un programme en petites entités :
ë Indépendantes ;
ë Réutilisables ;
ë Plus lisibles.
ý Où : Les fonctions peuvent être définies :
ë Dans le fichier principal ;
ë Dans d’autres fichiers source (compilation séparée - Tr. 54) ;
ý Syntaxe d’une fonction
type de retour nom fonction ( arguments ) {
declarations des variables locales ;
instructions ;
}

ECM, Mathématique et Informatique, S. Derrode 37

Programmation Structurée en Langage C, 1re année

Fonction sans argument

// En−t ê t e de l a fonction
void A f f i c h e ( ) ;
// D é c l a r a t i o n de l a fonction
void A f f i c h e ( ) {
// f o n c t i o n principale
p r i n t f ( ” Message ” ) ;
i n t main ( ) {
}
// 1 p p e l de l a fct
Affiche () ;
// f o n c t i o n principale
return 0 ;
i n t main ( ) {
}
// Appel de l a fct
Affiche () ;
// D é c l a r a t i o n de l a fonction
return 0 ;
void A f f i c h e ( ) {
}
p r i n t f ( ” Message ” ) ;
}

ECM, Mathématique et Informatique, S. Derrode 38

Programmation Structurée en Langage C, 1re année

Fonction : valeur de retour

#include<s t d i o . h>
#include<math . h>

// D é c l a r a t i o n de l a f o n c t i o n
double S i n u s ( ) {
double a n g l e ;
s c a n f ( ”% l f ” , &a n g l e ) ;
return s i n ( a n g l e ) ;
}

i n t main ( ) {
double r e s ;
// Appel de l a f o n c t i o n
res = Sinus () ;
p r i n t f ( ”\ nRe sult at = %l f ” , r e s ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 39

Programmation Structurée en Langage C, 1re année

Fonction : passage d’argument par valeur

démo 13
#i n c l u d e<s t d i o . h>

// D é c l a r a t i o n de l a f o n c t i o n
i n t Add ( i n t v a l 1 , i n t v a l 2 ) {
int r e s u l t ; // d e c v a r locale
r e s u l t = val1 + val2 ; // c a l c u l
return r e s u l t ; // r e t o u r
}

int main ( ) {
int res , a = 5 , b = 8;
// A p p e l s de l a f o n c t i o n
r e s = Add ( a , b ) ; p r i n t f ( ” \ n R e s u l t a t = %d ” , res ) ;
r e s = Add( −8 , 1 5 ) ; p r i n t f ( ” \ n R e s u l t a t = %d ” , res ) ;
r e s = Add( −8∗2 −5 , 6∗ a ) ; p r i n t f ( ” \ n R e s u l t a t = %d ” , res ) ;

return 0;
}

ë Les arguments transmis sont recopiés dans les variables locales de la fonction.

ECM, Mathématique et Informatique, S. Derrode 40

Programmation Structurée en Langage C, 1re année

Fonctions récursives
ë La fonction s’appelle elle-même ! ë Exemple : 4! = 4 ∗ 3!.

démo 16
#i n c l u d e <s t d i o . h>

// D é c l a r a t i o n de la fonction
int f a c t ( int n) { fact(4) 4*fact(3) 4*6 = 24
if ( n<=1)
return 1;
fact(3) 3*fact(2) 3*2 = 6
else
return n∗ f a c t ( n−1) ;
}
fact(2) 2*fact(1) 2*1 = 2
int main ( ) {
// Appel de la fonction
p r i n t f ( ”\ n F a c t o r i e l 4 = %d ” , fact (4) ) ; fact(1) 1
return 0;
}

Attention au test de fin de récursivité !

ECM, Mathématique et Informatique, S. Derrode 41

Programmation Structurée en Langage C, 1re année

Pointeurs et adresses

ë Type pointeur, Tr. 43

ë Pointeurs et tableaux, Tr. 46
ë Allocation dynamique de mémoire, Tr. 48
ë Passage d’arg. par adresse dans les fonctions, Tr. 51

ECM, Mathématique et Informatique, S. Derrode 42

Programmation Structurée en Langage C, 1re année

Type pointeur
ë Variables : float x=-12.98587E-5 ; char c=’F’ ;
Octet Octet

x=-12.98567E-5 c=’F’

0x2ab091 0x2ab097

ë Pointeurs :
Déclaration : float* px ; et char* pc ;
Initialisation : px = &x ; et pc = &c ;
Octet Octet

px=0x2ab091 pc=0x2ab097

0x2fc0b3 0x2fc0b8

ë Remarque : La taille d’un pointeur, c’est à dire la quantité de

mémoire réservée au stockage d’une adresse, est de 4 octets (quel que
soit le type sur lequel il pointe).
sizeof(char*)==sizeof(double*)==4 sizeof(char)==1 ; sizeof(double)==8

ECM, Mathématique et Informatique, S. Derrode 43

Programmation Structurée en Langage C, 1re année

Schéma global :

px c pc x

Autre exemple :
i n t x=1 , y =2;
i n t ∗ px ; // p i p o i n t e s u r un i n t
px = &x ; // p i p o i n t e s u r x
y = ∗px ; // y r e ç o i t la valeur 1 (x)
∗px = 0 ; // x vaut 0

Remarques :
ë &*p est identique à p (pour p un pointeur)
ë Opérateurs sur les pointeurs : +, -, ++, --, +=, -=, ==, != ...
ë p=NULL : identique à l’initialisation à 0 d’une variable entière ou
flottante.

ECM, Mathématique et Informatique, S. Derrode 44

Programmation Structurée en Langage C, 1re année

#i n c l u d e <s t d i o . h>
void main ( ) {
int i = 0 ;
i n t ∗p ;
float x = 3.14;
float ∗ f ;

p = &i ;
∗ f = 666;
f = &x ;
∗ f = ∗p ;
∗p = 3 4 ;
p = f;
∗p = ∗p + 1 ;

p r i n t f ( ” \ n i=%d ; ∗ f=%f ” , i , ∗ f ) ;
}

Supprimer les lignes invalides - Que s’affiche-t’il ?

ECM, Mathématique et Informatique, S. Derrode 45

Programmation Structurée en Langage C, 1re année

Pointeurs et Tableaux
ë Tableau 1D (Vecteur) : int vect[5] = {2, 3, 4, 5, 6} ;
vect[0] vect[1] vect[2] vect[3] vect[4]

2 3 4 5 6
0x2fcb03 0x2fcb05 0x2fcb07 0x2fcb09 0x2fcb0b

vect vect+1 vect+2 vect+3 vect+4

ë &vect[0] == vect : Adresse du 1er élément de vect.

ë &vect[i] == vect+i : Adresse du ième élément de vect.
ë vect[i] == *(vect+i) : Valeur du ième élément de vect.
ý C’est la fin du mystère scanf("%s", chaine) ; !

ECM, Mathématique et Informatique, S. Derrode 46

Programmation Structurée en Langage C, 1re année

ý À vous de deviner ... :

f l o a t ∗p , ∗q ;
f l o a t tab [ 5 ] = { 1 , 2 , 3 , 4 , 5 } ;

p = &tab [ 2 ] ;
p = tab +2;
∗p= 0 . 0 ;
q = p++; \\ Post−i n c ré m e n t a t i o n !
∗ ( q+2) = −10;

Supprimer les lignes invalides - État du vecteur ?

ECM, Mathématique et Informatique, S. Derrode 47

Programmation Structurée en Langage C, 1re année

Allocation dynamique de mémoire

ý Types d’allocation :
ý Allocation statique :
ë Pour créer et supprimer des ¿ objets À lors de la compilation.
ë Utilise la pile (limitée en taille).
ë La taille de la mémoire à allouer doit être connue à la compilation.
ý Allocation dynamique :
ë Pour créer et supprimer des ¿ objets À lors de l’execution.
ë Utilise le tas (limitée par la mémoire de votre PC).
ë La taille de la mémoire à allouer peut être connue lors de l’éxecution.

ý Allocation dynamique : librairie #include<stdlib.h>

ë malloc() alloue de la mémoire
ë free() libère de la mémoire

ECM, Mathématique et Informatique, S. Derrode 48

Programmation Structurée en Langage C, 1re année

démo 12
#i n c l u d e <s t d i o . h>
#i n c l u d e <s t d l i b . h>
i n t main ( ) {

int t a i l l e , i ;
p r i n t f ( ” E n t r e z l a t a i l l e du v e c t e u r : ”) ;
s c a n f ( ”%d” , & t a i l l e ) ;

double ∗ ta b ;
ta b = ( double ∗ ) m a l l o c ( t a i l l e ∗ s i z e o f ( double ) ) ;
f o r ( i =0; i < t a i l l e ; i ++) t a b [ i ] = 8 . 0 ∗ i ;
f r e e ( ta b ) ;

return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 49

Programmation Structurée en Langage C, 1re année

Allocation dynamique de mémoire : Exo

ë Tableau 2D (Matrice) : Écrire un programme qui alloue

dynamiquement la mémoire d’un tableau à deux dimensions, selon le
schéma suivant (exemple : 4 lignes, 2 colonnes) :

1 2 3 4 5 6 7 8

démo 12bis

ECM, Mathématique et Informatique, S. Derrode 50

Programmation Structurée en Langage C, 1re année

Passage d’arguments par adresse dans les

fonctions
démo 14
#i n c l u d e<s t d i o . h>

void Swap ( i n t ∗ pt1 , int ∗ pt2 ) {

i n t aux = ∗ p t 1 ;
∗ pt1 = ∗ pt2 ;
∗ p t 2 = aux ;
}

int main ( ) {
int a = 5 , b = 8;

p r i n t f ( ” \ na= %d , b = %d ” , a, b) ;
Swap(&a , &b ) ;
p r i n t f ( ” \ na= %d , b = %d ” , a, b) ;

return 0;
}

ë Les arguments transmis sont les adresses des variables. Les valeurs des
variables de la fonction appellante sont modifiées.

ECM, Mathématique et Informatique, S. Derrode 51

Programmation Structurée en Langage C, 1re année

Calcul de la longueur d’une chaı̂ne

démo 15
i n t s t r l e n 1 ( char ∗ s ) {
int n ;
f o r ( n =0;∗ s != ’ \0 ’ ; n++) s ++;
return n ;
}
i n t s t r l e n 2 ( char ∗ s ) {
char ∗ p=s ;
while ( ∗p != ’ \0 ’ ) p++;
return p−s ; // Conv . hé x a −> dé c .
}

i n t main ( ) {
int t a i l l e 1 , t a i l l e 2 ;
char c h a i n e [ ] = ” La p i e c h a n t e . ” ;
t a i l l e 1 = s t r l e n 1 ( chaine ) ;
t a i l l e 2 = s t r l e n 2 ( chaine ) ;
p r i n t f ( ” \ n t a i l l e 1=%d , t a i l l e 2=%d” , taille1 , taille2 ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 52

Programmation Structurée en Langage C, 1re année

Concaténation de deux tableaux

#i n c l u d e <s t d i o . h>
#i n c l u d e <s t d l i b . h>
co n s t i n t TAILLE=3;

i n t ∗ C o n c a t V e c t ( i n t ∗ Vect1 , i n t ∗ V e c t 2 ) {
i n t ∗ NewVect ;
NewVect = ( i n t ∗ ) m a l l o c ( 2 ∗ TAILLE∗ s i z e o f ( i n t ) ) ;

f o r ( i n t k =0; k<TAILLE ; k++) {

NewVect [ k ] = Vect1 [ k ] ;
NewVect [ k+TAILLE ] = V e c t 2 [ k ] ;
}

return NewVect ;
}

i n t main ( ) {
i n t t a b 1 [ TAILLE ] = { 1 , 2 , 3 } ;
i n t t a b 2 [ TAILLE ] = { 4 , 5 , 6 } ;
int ∗ tab12 ;
tab12 = ConcatVect ( tab1 , tab2 ) ;
...
f r e e ( t a b 1 2 ) ; // l i b é r a t i o n mémoire
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 53

Programmation Structurée en Langage C, 1re année

Compilation séparée

ý Compilation d’un programme dans un seul fichier

ë 1 : gcc main.c -o prg ë fichiers main.o et prg
Equivalent à
ë 1 : Compilation gcc -c main.c ë fichier main.o
ë 2 : Ed. de liens gcc main.o -o prg ë éxecutable prg

ý Compilation d’un programme dans plusieurs fichiers

ë Les fonctions sont réparties dans plusieurs fichiers.
ë Les fonctions non déclarées dans le fichier principal (celui
contenant la fonction int main() ...) sont appelées fonctions
externes.

ECM, Mathématique et Informatique, S. Derrode 54

Programmation Structurée en Langage C, 1re année

main.c fichier.c

Precompilation

main.i fichier.i

Compilation

main.o fichier.o

Edition de liens

prg

ë 1 : Compilation gcc -c main.c ë fichier main.o

ë 2 : Compilation gcc -c fichier.c ë fichier fichier.o
ë 3 : Ed. de liens gcc main.o fichier.o -o prg ë éxecutable prg

ECM, Mathématique et Informatique, S. Derrode 55

Programmation Structurée en Langage C, 1re année

// main . c // f i c h i e r . c

// P r o t o t y p e d e s f o n c t i o n s int plus ( int a , int b) {

extern i n t p l u s ( i n t a , i n t b ) ; int c ;
extern i n t mult ( i n t a , i n t b ) ; c = a + b;
return c ;
// Programme p r i n c i p a l }
i n t main ( ) {
int a = 5 , b = 8 ; i n t mult ( i n t a , i n t b ) {
int r e s u l t 1 = plus ( a , b) ; int c ;
i n t r e s u l t 2 = mult ( a , b ) ; c = a ∗ b;
return 0 ; return c ;
} }

On délocalise les en-têtes des fonctions dans un fichier ¿ header file À, que
l’on appelle généralement fichier.h (extension .h). Dans ce fichier, on y
ajoute la définition des constantes, des structures, les macro-fonctions ...

ECM, Mathématique et Informatique, S. Derrode 56

Programmation Structurée en Langage C, 1re année

// f i c h i e r . h
extern i n t p l u s ( i n t a , i n t b ) ;
extern i n t mult ( i n t a , i n t b ) ;

// f i c h i e r . c
// main . c
int plus ( int a , int b) {
#i n c l u d e ” f i c h i e r . h”
int c = a + b ;
return c ;
i n t main ( ) {
}
int a = 5 , b = 8 ;
int r e s u l t 1 = plus ( a , b) ;
i n t mult ( i n t a , i n t b ) {
i n t r e s u l t 2 = mult ( a , b ) ;
int c = a ∗ b ;
return 0 ;
return c ;
}
}

démo 17 à modifier

ECM, Mathématique et Informatique, S. Derrode 57

Programmation Structurée en Langage C, 1re année

Makefile : pour simplifier la compilation

ë Principe du Makefile
ë Au lieu de taper toutes les commandes de compilation et
d’édition de liens, on peut les regrouper dans un fichier
(généralement appelé Makefile ou makefile).
ë Les Makefile doivent respecter une syntaxe très particulière.
ë On lance la compilation grâce à l’utilitaire make, qu’il suffit
d’exécuter avec make (ou make -f Makefile).
ë La compilation par make est intelligente, au sens où n’est
recompilé que ce qui a été modifié.

ECM, Mathématique et Informatique, S. Derrode 58

Programmation Structurée en Langage C, 1re année

ë Règle d’écriture d’un Makefile Le principe pour ¿ rédiger À un

Makefile est de décrire les dépendances entre les fichiers selon le
principe suivant :
fichier cible : liste fichiers requis
<tabulation> commande associee
ý fichier cible : Nom du fichier qui doit être mis à jour.
ý liste fichiers requis : Liste des fichiers (séparés par des
espaces) dont dépend fichier cible. Ces fichiers sont nécessaires à
la création de fichier cible.
ý commande associée : Ligne de commande permettant la mise à
jour de fichier cible.

ECM, Mathématique et Informatique, S. Derrode 59

Programmation Structurée en Langage C, 1re année

ë Exemple de Makefile

# C ré a t i o n de l ’ e x é c u t a b l e par é d i t i o n de l i e n s .
prg : main . o f i c h i e r . o
g c c −o prg main . o f i c h i e r . o

# C ré a t i o n de main . o par c o m p i l a t i o n .

main . o : main . c f i c h i e r . h
g c c −c main . c

# C ré a t i o n de f i c h i e r . o par c o m p i l a t i o n .
fichier .o: fichier . c fichier .h
g c c −c f i c h i e r . c

ECM, Mathématique et Informatique, S. Derrode 60

Programmation Structurée en Langage C, 1re année

Préprocesseur

ý Le préprocesseur intervient juste avant la phase de compilation. Il

prend en compte :
ë Les commentaires (suppression),
ë Les commandes commençant par #.

ý 4 types de directives commençant par #

ë Inclusion des fichiers d’en-tête (#include)
ë Définition de variables du pré-processeur (#define et #undef)
ë Les macro-fonctions (#define)
ë La sélection de codes en fonction des variables du
pré-processeur (#if, #else, #elif et #end)

ECM, Mathématique et Informatique, S. Derrode 61

Programmation Structurée en Langage C, 1re année

Variables du pré-processeur

ý Constante de pré-compilation

Sans constante de pré-compilation Avec constante de pré-compilation

#define LG 20
int tab[20] ; int tab[LG]
for( i=0 ; i<20 ; i++ ) for( i=0 ; i<LG ; i++ )
... ...

ý Si on souhaite changer la taille du tableau, il suffit de changer la

variable (lisibilité, gain de temps, ...).

ý Pour supprimer une variable : #undef.

ECM, Mathématique et Informatique, S. Derrode 62

Programmation Structurée en Langage C, 1re année

Macro-expression ou macro-fonction

ý Directive : #define.
ý Exemple : #define add(x1,x2) ((x1) += (x2)) .
ý add(a,b) est remplacé par ((a) += (b))
ý Attention au parenthésage : Il faut toujours encadrer les
pseudo-variables par des parenthèses.

ECM, Mathématique et Informatique, S. Derrode 63

Programmation Structurée en Langage C, 1re année

Évaluation de macro-expressions
démo 18

Avant pré-compilation Après pré-compilation Bon/Faux

#define m(x) 128*x+342*x*x
#define y(x) 128*(x)+342*(x)*(x)
int a,b,d,e,f,g ; int a,b,d,e,f,g ;
a = b = 1; a = b = 1;
d = m(a) ; d = 128*a+342*a*a ; bon
e = y(a) ; e = 128*(a)+342*(a)*(a) ; bon
f = m(a+b) ; d = 128*a+b+342*a+b*a+b ; faux
g = y(a+b) ; d = 128*(a+b)+342*(a+b) bon
*(a+b) ;

ECM, Mathématique et Informatique, S. Derrode 64

Programmation Structurée en Langage C, 1re année

Protection contre l’inclusion multiple

\\ test.h \\ Prog1.c \\ Prog2.c

#include "test.h" #include "test.h"

// T e s t . h
#i f n d e f TEST H
#d e f i n e TEST H

extern i n t add ( i n t C, i n t D) ;

int VarGlobale ;

#e n d i f

ECM, Mathématique et Informatique, S. Derrode 65

Programmation Structurée en Langage C, 1re année

Structures, unions et énumérations

ý Types de base : char, short, int, float, double + pointeurs.
ý Types dérivés : Tableaux de nombres ou de caractères.
ý Types complexes (objets) :
ë Énumération : Sert à offrir la possibilité de gérer des
constantes numériques, Tr. 103.
ë Structure : Objets composé de plusieurs champs. Exemple :
Voiture = (marque, num. d’immatriculation, année, ...)
– Définition et exemples, Tr. 67
– Structure et pointeurs, Tr. 70
– Structure et fonctions, Tr. 71
– Tableau statique de structures, Tr. 74
– Structure et alloc. dyn. de mémoire, Tr. 75
– Structures auto-référentielles, Tr. 77

ECM, Mathématique et Informatique, S. Derrode 66

Programmation Structurée en Langage C, 1re année

Structures : définition et utilisation

ý Structures : Agrégat de plusieurs objets de types quelconques
(appelés champs de la structure).
ý Syntaxe :
struct nom structure {
type1 variable1 ;
type2 variable2 ;
...
};
ý Exemple : Point du plan
struct Point2D {
float x ;
float y ;
};

ECM, Mathématique et Informatique, S. Derrode 67

Programmation Structurée en Langage C, 1re année

ý Une structure est un type et non une variable.

ý Pour déclarer une variable du type Point2D :
ë struct Point2D coord ;
ë struct Point2D TabCoord[3] ;
ý On peut déclarer et initialiser les champs d’une structure :
ë struct Point2D coord = {2.8, 9.8} ;
ë struct Point2D TabCoord[3] = {{2.8, -0.8}, {4.2, -9.8},
{-1.0, 1.0}} ;
ý Pour accéder à un champ de la structure :
ë printf("%f",coord.x) ;
ë coord.x = 5.0 ;
ë double root = coord.x*coord.x+coord.y*coord.y ;
ë printf("%f", TabCoord[1].y) ;

ECM, Mathématique et Informatique, S. Derrode 68

Programmation Structurée en Langage C, 1re année

ý L’affectation entre deux structures de même type est permise :

struct Point2D coord1 = {3.0, 8.5}, coord2 ;
coord2 = coord1 ;
ý Par contre, il n’est pas possible de tester l’égalité, la supériorité, ... de
deux structures. Il faut comparer individuellement chaque champs :
if ((coord1.x==coord2.x) && (coord1.y==coord2.y) )... ;
ý Structure incorporant des structures. Exemple :
struct Rect {
struct Point2D pt1 ;
struct Point2D pt2 ;
};
Déclaration et init. : struct Rect carre = {{1.0,2.0}, {3.0,4.0}} ;
Affectation : carre.pt1.x=3.2 ; carre.pt1.y=5.8 ;

ECM, Mathématique et Informatique, S. Derrode 69

Programmation Structurée en Langage C, 1re année

Structures et pointeurs

ý Déclaration d’un pointeur sur une structure :

struct Point2D* p ;
ý Initialisation d’un pointeur sur une structure :
struct Point2D coord1 ;
p = &coord1 ;
ý Comment accéder au contenu de la valeur pointée ?
(*p).x == coord1.x
Remarque : Plutôt que (*p).x, on préfèrera écrire p->x.
Exemple : printf("%f, %f, %f", (*p).x, p->x, coord1.x) ;
affiche 3 fois la même valeur.

ECM, Mathématique et Informatique, S. Derrode 70

Programmation Structurée en Langage C, 1re année

Structures et fonctions
démo 19
#i n c l u d e<s t d i o . h>
s t r u c t Point2D {
double x ;
double y ;
};

s t r u c t Point2D I n i t P o i n t ( double val1 , double val2 ) {

s t r u c t Point2D temp ;
temp . x = v a l 1 ; temp . y = v a l 2 ;
return temp ;
}

i n t main ( ) {
s t r u c t Point2D point ;
double a , b ;

p r i n t f ( ” E n t r e z deux v a l e u r s : ” ) ;
s c a n f ( ”% l f % l f ” , &a , &b ) ;
point = InitPoint (a , b) ;
p r i n t f ( ” x=%l f , y=%l f ” , p o i n t . x , p o i n t . y ) ;

return 0;
}

ECM, Mathématique et Informatique, S. Derrode 71

Programmation Structurée en Langage C, 1re année

démo 20
#i n c l u d e<s t d i o . h>
s t r u c t Point2D {
double x ;
double y ;
};

i n t ComparePoint ( s t r u c t Point2D pt1 , s t r u c t Point2D pt2 ) {

return ( p t 1 . x == p t 2 . x ) && ( p t 1 . y == p t 2 . y ) ;
}

int main ( ) {

struct Point2D point1 = {2.0 , −9.5};

struct Point2D p o i n t 2 = { −1.0 , 2 . 0 } ;

i n t ok = ComparePoint ( p o i n t 1 , p o i n t 2 ) ;
i f ( ok == 1 )
p r i n t f ( ” L e s deux p o i n t s s o n t i d e n t i q u e s ” ) ;
else
p r i n t f ( ” L e s deux p o i n t s s o n t d i f f e r e n t s ” ) ;

return 0;
}

ECM, Mathématique et Informatique, S. Derrode 72

Programmation Structurée en Langage C, 1re année

démo 21
#i n c l u d e<s t d i o . h>
s t r u c t Point2D {
double x ;
double y ;
};

void A j o u t e P o i n t ( s t r u c t Point2D ∗ pt1 , struct Point2D pt2 ) {

pt1−>x += p t 2 . x ;
pt1−>y += p t 2 . y ;
}

int main ( ) {

struct Point2D point1 = {2.0 , −9.5};

struct Point2D p o i n t 2 = { −1.0 , 2 . 0 } ;

p r i n t f ( ” \ nAvant : p o i n t 1 (% f ,% f ) , p o i n t 2 (% f ,% f ) ” , p o i n t 1 . x ,
point1 . y , point2 . x , point2 . y) ;
A j o u t e P o i n t (& p o i n t 1 , p o i n t 2 ) ;
p r i n t f ( ” \ n A p r e s : p o i n t 1 (% f ,% f ) , p o i n t 2 (% f ,% f ) \n” , p o i n t 1 . x ,
point1 . y , point2 . x , point2 . y) ;

return 0;
}

ECM, Mathématique et Informatique, S. Derrode 73

Programmation Structurée en Langage C, 1re année

Tableau statique de structures

#i n c l u d e < s t r i n g . h>
struct a t h l e t e {
int Age ;
char Nom [ 1 5 ] ;
double BestJump ;
};
void main ( ) {
struct a t h l e t e CompetitionSaut [ 1 0 ] ;
C o m p e t i t i o n S a u t [ 0 ] . BestJump = 7.4;
C o m p e t i t i o n S a u t [ 0 ] . Age = 26;
s t r c p y ( C o m p e t i t i o n S a u t [ 0 ] . Nom, ” Durant ” ) ;
}

26 Durant 7.4 22 Dupont 7.8 8 Perlin 2.5 77 Pinpin 6.5

CompetitionSaut

ECM, Mathématique et Informatique, S. Derrode 74

Programmation Structurée en Langage C, 1re année

Structure et
allocation dynamique de mémoire

Exemple 1 : une structure

s t r u c t Point2D ∗ pPt ;
pPt = ( s t r u c t Point2D ∗ ) m a l l o c ( s i z e o f ( s t r u c t Point2D ) ) ;
...
f r e e ( pPt ) ; pPt = NULL ;

Octet
pPt
0x2ab097 x y

ECM, Mathématique et Informatique, S. Derrode 75

Programmation Structurée en Langage C, 1re année

Exemple 2 : un tableau de structures

démo 22
int cpt ;
p r i n t f ( ” Dimension du t a b l e a u : ”) ; s c a n f ( ”%d” , &c p t ) ;

s t r u c t Point2D ∗ pTabPt ;
pTabPt = ( s t r u c t Point2D ∗ ) m a l l o c ( c p t ∗ s i z e o f ( s t r u c t Point2D ) ) ;
...
f r e e ( pTabPt ) ;
pTabPt = NULL ;

Octet
pTabPt
0x2ab097 x y x y x y

ECM, Mathématique et Informatique, S. Derrode 76

Programmation Structurée en Langage C, 1re année

Structures auto-référentielles : Listes

ý Liste : Ensemble d’objets chainés et de même type. Les objets

sont appelés maillons.
struct maillon {
Tete T T T NULL
char symb ;
A B C
struct m a i l l o n ∗ s u i v ;
};
typedef s t r u c t m a i l l o n M;

démo 23
ë Queue ou file d’attente : Liste FIFO ¿ First In, First Out À
(Ex : File d’attente à un guichet)
ë Pile : Liste LIFO ¿ Last In, First Out À
ë Listes circulaires
ë Listes symétriques

ECM, Mathématique et Informatique, S. Derrode 77

Programmation Structurée en Langage C, 1re année

ý Opérations classiques sur les listes :

ë Ajouter un objet (allocation mémoire),
ë Supprimer un objet (libération mémoire),
ë Tester si la liste est vide (NULL),
ë Supprimer toute la liste (libération mémoire),
ë Parcourir la liste : pour retrouver ou afficher un objet,
ë Trier une liste,
ë ...

ECM, Mathématique et Informatique, S. Derrode 78

Programmation Structurée en Langage C, 1re année

Les fichiers
ý Rangement des fichiers : Le système de répertoires est un outil de
classement organisé sous forme arborescente :
ë Il existe un répertoire racine (root) à partir duquel s’organise
l’arborescence.
ë Chaque répertoire (à l’exception du répertoire racine) possède
un répertoire père.
ë Un répertoire peut contenir à la fois des fichiers et d’autres
répertoires (qui sont ses répertoires fils).
ë L’organisation sous forme de répertoires permet de positionner
les différents fichiers du disque. La position d’un fichier au sein
de l’arborescence est donnée par un chemin (path) qui part de
la racine jusqu’au répertoire contenant le fichier.

ECM, Mathématique et Informatique, S. Derrode 79

Programmation Structurée en Langage C, 1re année

ý Un fichier est doté :

ë d’un nom,
ë d’une position (son chemin dans le système de répertoires)
ë d’un certain nombre de droits (son ou ses propriétaires)
ë d’une taille (correspondant à un certain nombre
d’emplacements réservés sur l’espace de stockage)
ë d’une date de création, de modification ...

ý Descripteur de fichiers : Un descripteur de fichiers sert à désigner

une connexion avec un fichier (ou un périphérique d’E/S comme
l’écran, l’imprimante, le clavier, ...). Un fichier est représenté par une
structure prédéfinie FILE (en majuscule !).
FILE* f ;
Le pointeur f désigne le flux (canal de communication) établi avec le
fichier.

ECM, Mathématique et Informatique, S. Derrode 80

Programmation Structurée en Langage C, 1re année

ý Descripteurs pré-définis :
ë stdin : flux d’entrée standard
ë stdout : flux de sortie standard
ë stderr : flux de sortie des messages d’erreur

do {
fprintf ( s t d o u t , ” V o u l e z vous c o n t i n u e r ( o /n ) ?\ n” ) ;
f s c a n f ( s t d i n , ” %c ” , &r e p ) ;
} while ( r e p== ’ o ’ ) ;

Est équivalent à :

do {
p r i n t f ( ” V o u l e z vous c o n t i n u e r ( o /n ) ?\ n” ) ;
s c a n f ( ” %c ” , &r e p ) ;
} while ( r e p== ’ o ’ ) ;

ECM, Mathématique et Informatique, S. Derrode 81

Programmation Structurée en Langage C, 1re année

Modes et fonctions d’ouverture

ý l’appel à la fonction fopen s’écrit :
g = fopen (nom, mode) ;
ý l’opération d’ouverture correspond :
ë à associer à g un fichier décrit par son nom. On dit pour
simplifier que g ¿ pointe sur le fichier À.
ë au positionnement de la tête de lecture sur la première ligne de
ce fichier.
ý Fermeture du flux associé au pointeur sur fichier.
ë En cas de mode d’utilisation en écriture, les données écrites sont
transférées sur le disque dur.
ë Exemple : fclose(g) ;

ECM, Mathématique et Informatique, S. Derrode 82

Programmation Structurée en Langage C, 1re année

ý Modes d’ouverture (FILE *f ;)

ë En lecture :
g = fopen ("[Link]", "r") ;
ë En écriture (avec écrasement !)
g = fopen ("[Link]", "w") ;
ë En écriture/ajout (sans écrasement)
g = fopen ("[Link]", "a") ;
ë Lecture/Ecriture (sans écrasement, position fin) :
g = fopen ("[Link]", "r+") ;
ë Lecture/Ecriture (avec écrasement) :
g = fopen ("[Link]", "w+") ;
ë Lecture/Ecriture (sans écrasement, position début) :
g = fopen ("[Link]", "a+") ;
À la seconde chaı̂ne, on peut ajouter le caractère "b", pour signifier que
l’enregistrement sera codé en binaire. Par défaut, le codage est "t" pour
texte.

ECM, Mathématique et Informatique, S. Derrode 83

Programmation Structurée en Langage C, 1re année

ë Test à l’ouverture Selon les droits disponibles, il arrive souvent que

l’ouverture d’un fichier se passe ¿ mal À. Il faut traiter les erreurs
d’ouverture pour éviter des erreurs ultérieures.

f = fopen ( ” monfichier . txt ” , ” r ” ) ;

i f ( f==NULL) {
p r i n t f ( ” I m p o s s i b l e d ’ o u v r i r ! \ n” ) ;
exit (0) ;
}

ë La valeur NULL pour le pointeur f indique une erreur d’ouverture

ë La fonction exit termine l’exécution du programme.

ECM, Mathématique et Informatique, S. Derrode 84

Programmation Structurée en Langage C, 1re année

Les fichiers texte

ý Organisation d’un fichier texte : Une séquence de chaı̂nes de

caractères séparées par sauts à la ligne.

ECM, Mathématique et Informatique, S. Derrode 85

Programmation Structurée en Langage C, 1re année

ý Organisation d’un fichier de données texte : Dans un fichier de

données texte, les données sont structurées sous forme de tableau, où
les champs sont en général séparés par des tabulations.

ECM, Mathématique et Informatique, S. Derrode 86

Programmation Structurée en Langage C, 1re année

ý Parcours (lecture) d’un fichier texte : Fonction fscanf

ë Chaque appel à cette fonction permet de poursuivre la lecture,
c’est à dire de lire l’élément qui suit l’élément précédemment lu.
ë À chaque nouvel appel à fscanf, la tête de lecture est déplacée
sur l’élément suivant.
ë fscanf retourne le nombre d’éléments lus
ë Exemple :
FILE ∗ f = f o p e n ( ” data . t x t ” , ” r ” ) ;
char mot [ 5 0 ] ;
f s c a n f ( f , ”%s ” , mot ) ;
p r i n t f ( ” v o i c i l e mot : %s ” , mot ) ;

ECM, Mathématique et Informatique, S. Derrode 87

Programmation Structurée en Langage C, 1re année

ý Test de fin de fichier : Fonction feof

ë A chaque lecture, la tête de lecture se déplace
ë La fonction feof indique si la fin de fichier est atteinte (valeur 1)
ë Exemple :
char p ;
while ( f e o f ( f )==0) {
f s c a n f ( f , ”%c ” , &p ) ;
p r i n t f ( ”%c ” , p ) ;
}

ECM, Mathématique et Informatique, S. Derrode 88

Programmation Structurée en Langage C, 1re année

ý Exemple récapitulatif :
#include<s t d i o . h>
i n t main ( ) {
FILE ∗ f ;
char p ;
f = fopen ( ” texte . txt ” , ” r ” ) ;
if ( f==NULL) {
printf (” Impossible d ’ ouvrir ! \n” ) ;
exit (0) ;
}
while ( f e o f ( f ) ==0){
f s c a n f ( f , ”%c ” , &p ) ;
p r i n t f ( ”%c ” , p ) ;
}
fclose ( f ) ;
}

ECM, Mathématique et Informatique, S. Derrode 89

Programmation Structurée en Langage C, 1re année

ý Écriture dans un fichier texte :

ë Mode d’ouverture de fopen : w - Exemple :
FILE ∗h ;
h = f o p e n ( ” r e s u l t a t . t x t ” , ”w” ) ;

ë Utilisation de la fonction fprintf : comme printf. Exemple :

char mot [ 2 0 ] = ” Bonjour ” ;
f p r i n t f ( h , ”%s ” , mot ) ;

ë Les données sont écrites physiquement au moment de la

fermeture : fclose(h) ;

ECM, Mathématique et Informatique, S. Derrode 90

Programmation Structurée en Langage C, 1re année

ý Accès séquentiel par caractère et par ligne

par caractère :
ë int fgetc(FILE* f) : Lecture d’un caractère à partir du
fichier pointé par f. Ex : char c = fgetc(ficIn) ;.
ë int fputc(char c, FILE* f) : Écrit le caractère c dans le
fichier pointé par f. Ex : char c = ’o’ ; fputc(c,
ficIn) ;.

par ligne :
ë char* fgets(char* ch, int n, FILE* f) : Lecture de
n-1 caractères sur le fichier pointé par f. Les caractères lus
sont rangés dans ch.
ë int fputs(char* ch, FILE* f) : Écrit la chaı̂ne de
caractères ch dans le fichier pointé par f.

ECM, Mathématique et Informatique, S. Derrode 91

Programmation Structurée en Langage C, 1re année

Exemple : Recopie d’un fichier

démo 24
#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
void main ( ) {
char c;

FILE∗ f i c I n = f o p e n ( ” . . \ o r i g i n a l . t x t ” , ” r ” ) ;
i f ( f i c I n == NULL) e x i t ( 0 ) ;
FILE∗ f i c O u t = f o p e n ( ” . \ temp\ c o p i e . t x t ” , ”w” ) ;
i f ( f i c O u t == NULL) e x i t ( 0 ) ;

while ( f e o f ( f i c I n ) == 0 ) {
c = fgetc ( ficIn ) ;
fputc (c , ficOut ) ;
}

fclose ( ficIn ) ;
f c l o s e ( ficOut ) ;
}

ECM, Mathématique et Informatique, S. Derrode 92

Programmation Structurée en Langage C, 1re année

Les fichiers binaires

ë Ouverture : Exemple g = fopen("[Link]", "wb") ;

ë Fermeture : fclose(g) ;
ë Lecture :
int fread(void* p, int s, int nb, FILE* f) ;.
Cette fonction transfert, depuis le fichier associé à f, nb
éléments de taille s octets et dont le type est celui de *p. La
fonction retourne le nombre d’octets lus.
Exemple :
char mot [ 2 0 ] ;
f r e a d ( mot , 1 , 1 0 , g ) ;

ECM, Mathématique et Informatique, S. Derrode 93

Programmation Structurée en Langage C, 1re année

ë Écriture :
int fwrite(void* p, int s, int nb, FILE* f) ;.
Cette fonction transfert, vers le fichier associé à f, nb éléments
de taille s octets et dont le type est celui de *p. La fonction
retourne le nombre d’octets écrits.
Exemple :
char mot [ 2 0 ] = ” Bonjour ” ;
f w r i t e ( mot , 1 , s t r l e n ( mot ) , g ) ;

ECM, Mathématique et Informatique, S. Derrode 94

Programmation Structurée en Langage C, 1re année

#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
struct i n d i v i d u {
char nom [ 1 5 ] ;
int age ;
};

void main ( ) {
struct i n d i v i d u e l e v e ;
int t a i l l e = si z e o f ( struct individu ) ;

FILE∗ f i c I n = f o p e n ( ” c : \ \ temp \\ o r i g i n a l . b i n ” , ” r b ” ) ;
i f ( f i c I n == NULL) e x i t ( 0 ) ;
FILE∗ f i c O u t = f o p e n ( ” c : \ \ temp \\ c o p i e . b i n ” , ”wb” ) ;
i f ( f i c O u t == NULL) e x i t ( 0 ) ;

// B o u c l e de r e c o p i e
while ( f e o f ( f i c I n ) == 0 ) {
f r e a d (& e l e v e , t a i l l e , 1 , ficIn ) ;
f w r i t e (& e l e v e , t a i l l e , 1 , ficOut ) ;
}

fclose ( ficIn ) ;
f c l o s e ( ficOut ) ;
}

ECM, Mathématique et Informatique, S. Derrode 95

Programmation Structurée en Langage C, 1re année

Autres petites choses ...

– Les arguments de la fonction principale, Tr. 97

– Les pointeurs de fonctions, Tr. 100
– Les énumérations, Tr. 103
– Les champs de bits, Tr. 104
– UNIX/Linux, commandes élémentaires, Tr. 105

ECM, Mathématique et Informatique, S. Derrode 96

Programmation Structurée en Langage C, 1re année

Les arguments de int main(...)

int main (int argc, char **argv) { ... }

ý Explication des arguments (variables pré-définies)

– int argc : nombre d’argument transmis au prg principal
– char **argv : tableau de chaı̂nes de caractères contenant les
arguments transmis

ý Fonction avec un nombre d’arguments variable

– argv[0] : chaı̂ne contenant le nom du programme
– argv[argc] : contient \0
– Le premier argument est donc argv[1] et le dernier argv[argc-1]

ECM, Mathématique et Informatique, S. Derrode 97

Programmation Structurée en Langage C, 1re année

ý Exemple
#include ” s t d i o . h”

void main ( in t argc , char ∗∗ argv ) {

in t i ;
double d ;

p r i n t f ( ” \nNombre d ’ arguments : %d : \ n” , a r g c ) ;
f o r ( i =0; i <a r g c ; i ++)
printf (” Arg #%d : %s \n” , i , argv [ i ] ) ;
}

démo 25

ECM, Mathématique et Informatique, S. Derrode 98

Programmation Structurée en Langage C, 1re année

ý Si un argument attendu est un nombre entier ou réel, on peut

utiliser les fonctions int atoi(char *s), long atoi(char *s) et
double atoi(char *s) de stdlib.h.
Exercice : écrire un programme Add qui fait la somme de tous les
nombres entiers qui lui sont transmis. Ainsi l’appel ./Add 1 2 3 doit
afficher 6.
#include ” s t d i o . h”
void main ( in t argc , char ∗∗ argv ) {
in t i , r e s = 0 ;
f o r ( i =1; i <a r g c ; i ++)
r e s += a t o i ( argv [ i ] ) ;
p r i n t f ( ” \ n R e s u l t a t = %d” , r e s ) ;
}

ECM, Mathématique et Informatique, S. Derrode 99

Programmation Structurée en Langage C, 1re année

Pointeur de fonction
ý Pointeur pointant vers une fonction (et non plus sur un nombre) !
Il s’agit donc d’une variable qui peut contenir l’adresse d’une
fonction.

void AjouteUn ( i n t ∗x ) {
∗x += 1 ;
}

void ( ∗ i n c ) ( i n t ∗ z ) ; // d é c l a r a t i o n
i n c = AjouteUn ; // i n i t i a l i s a t i o n

int a = 1 0 ;
i n c (&a ) ; // i n c ré m e n t e a de 1

ý Exemple

ECM, Mathématique et Informatique, S. Derrode 100

Programmation Structurée en Langage C, 1re année

ý Sans pointeur de fonction

#i n c l u d e ” s t d i o . h”
double f c t 1 ( double x ) { return 3 . 0 ∗ x ; }
double f c t 2 ( double x ) { return x / 3 . 0 ; }
i n t main ( ) {
int f;
p r i n t f ( ” \ n F o n c t i o n 1 ou 2 : ” ) ; s c a n f ( ”%d” , &f ) ;
if ( f ==1)
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 9 . 0 , fct 1 (9.0) ) ;
else
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 9 . 0 , fct 2 (9.0) ) ;
if ( f ==1)
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 1 2 . 0 , fct 1 (12.0) ) ;
else
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 1 2 . 0 , fct 2 (12.0) ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 101

Programmation Structurée en Langage C, 1re année

ý Avec pointeur de fonction : démo 26

#i n c l u d e ” s t d i o . h”
double f c t 1 ( double x ) { return 3 . 0 ∗ x ; }
double f c t 2 ( double x ) { return x / 3 . 0 ; }

i n t main ( ) {
int f;
p r i n t f ( ” \ n Q u e l l e f o n c t i o n ( 1 ou 2 ) : ” ) ; s c a n f ( ”%d” , &f ) ;

double ( ∗ p f c t ) ( double z ) ;
if ( f ==1)
pfct = fct 1 ;
else
pfct = fct 2 ;

p r i n t f ( ” \n f c t (% l f ) = % l f ” , 9 . 0 , pfct (9.0) ) ;
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 1 2 . 0 , p f c t ( 1 2 . 0 ) ) ;
return 0 ;
}

ECM, Mathématique et Informatique, S. Derrode 102

Programmation Structurée en Langage C, 1re année

Les énumérations
ý Sert à définir des variables entières qui ne peuvent prendre que certaines
valeurs précises :
ý Exemple
enum c o l o r { n o i r , bl eu , v e r t , cyan , rouge , magenta , b l a n c } ;
typedef enum c o l o r c o u l e u r ;
c o u l e u r c1 = magenta ;
p r i n t f ( ” \ nCouleur = %d” , c1 ) ; // a f f i c h e 5

ý Remarque : Identifié comme des entiers

enum b a s c u l e {ON, OFF, NON = 0 , OUI } ;

équivaut à enum b a s c u l e {ON=0 , OFF=0 , NON=0 , OUI=1}

ý Remarque : Alternative à #define

ECM, Mathématique et Informatique, S. Derrode 103

Programmation Structurée en Langage C, 1re année

Les champs de bits

struct chps {
unsigned i n t b 0 2 : 3 ;
signed i n t b 3 7 : 5;
ý Exemple :
unsigned i n t : 7;
unsigned i n t b15 : 1;
}

b15 inutilise b3_7 b0_2

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

ý Remarques :
ë Les type sont soit int (équiv. signed int), soit unsigned int.
ë Ils peuvent entraı̂ner des problèmes de portabilité entre
machines (¿ Low Indian À et ¿ Big Indian À)

ECM, Mathématique et Informatique, S. Derrode 104

Programmation Structurée en Langage C, 1re année

UNIX/Linux, commandes élémentaires

Description Commande Anglais
Affichage du répertoire courant pwd
Création d’un nouveau rép. monRep mkdir monRep make directory
Changement de répertoire cd monRep change directory
Retour au répertoire précédent cd ..
Liste des fichiers du rép. courant ls list
Création d’un fichier vide appelé monFic.c touch monFic.c
Déplacement d’un fichier vers un répertoire monRep mv monFic.c monRep move
Copie de fichier1 dans fichier2 cp fichier1 fichier2 copy
Renommage de fichier1 en fichier3 mv fichier1 fichier3 move
Suppression d’un fichier rm monFic remove
Suppression d’un répertoire complet rm -r monRep
Edition d’un fichier nedit monFic & nedit : editeur
Compilation de monFic.c gcc monFic.c exécutable [Link]
gcc monFic.c -o monFic exécutable monFic
Exécution du programme monFic ./monFic

ECM, Mathématique et Informatique, S. Derrode 105

Programmation Structurée en Langage C, 1re année

FIN

ECM, Mathématique et Informatique, S. Derrode 106