Présentation - Cours de Langage C

Présentation - Cours de Langage C
École Centrale
de Marseille
²
±
Programmation Structurée
en Langage C - 1re année
¯
°
Stéphane Derrode, Bureau 206 (Institut Fresnel),
stephane.derrode@ec-marseille.fr
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
i n t main ( )
l e message
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
Adresse
Octet
0x2ab09c
ECM, Mathématique et Informatique, S. Derrode
Octet
0x2ab09d
0x2ab09e
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
ë float
ë float
ë int i
ë float
: Conversion implicite et explicite (¿ cast À)
f = 2 / 4;
ýf =
f = 2.0 / 4 ;
ýf =
= 2.0 / 4 ;
ýi =
j = (float) 3/2 ;
ýj =
0.0
0.5
0
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
ë int i = 5 ; int a = --i ; donne i=4
Post-incrémentation
ë int i = 5 ; int a = i++ ; donne i=6
ë int i = 5 ; int a = i-- ; donne i=4
ECM, Mathématique et Informatique, S. Derrode
et a=6
et a=4
et a=5
et a=5
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]
3.5
4.8
tf[5]
-2
1.2
0
0
0
0
0
1.2
-1
0
5.8
0
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
s
a
\0
– char ch[] = "message" ;
m
e
s
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
p r i n t f ( ”Au r e v o i r
instruction
2-
if ( expression )
if
instruction2
ECM, Mathématique et Informatique, S. Derrode
! ”) ;
( ( n==1) && (m>=10) ) {
p r i n t f ( ” Bonjour ” ) ;
instruction1
else
( f i n == 1 )
fin = 1;
}
else
p r i n t f ( ”Au r e v o i r ” ) ;
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 ;
démo 8
s c a n f ( ”%c ” , &c ) ;
switch ( c )
int
{
case
’a ’
:
p r i n t f ( ” Choix
switch ( i )
’a ’”) ;
{
break ;
case
’A ’
i ;
s c a n f ( ”%d ” , & i ) ;
:
p r i n t f ( ” Choix
’A ’ ” ) ;
case 1
:
case 2
:
p r i n t f ( ” Choix 1 ou 2 ” ) ;
break ;
case
’b ’
break ;
:
p r i n t f ( ” Choix
’b ’”) ;
break ;
case
’B ’
:
case 4
:
p r i n t f ( ” Choix 3 ou 4 ” ) ;
:
p r i n t f ( ” Choix
break ;
’B ’ ” ) ;
default
break ;
default
case 3
:
p r i n t f ( ” Mauvais
:
p r i n t f ( ” Mauvais
choix
choix
! ”) ;
break ;
! ”) ;
}
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 {
s [ i ] = n % 10;
Condition
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
ECM, Mathématique et Informatique, S. Derrode
Vrai
Faux
32
Programmation Structurée en Langage C, 1re année
double ta b [ 4 ] = { 3 . 2 , 5 . 1 , 9 ,
−1.8};
démo 10
int i ;
f o r ( i =0; i <=3; i ++)
p r i n t f ( ” \ n V a l e u r : % l f ” , t ab [ i ] ) ;
i n t nb ;
p r i n t f ( ” E n t r e z un nombre : ” ) ;
s c a n f ( ”%d” , &nb ) ;
f o r ( i n t i=nb ; i >0; i −−)
char ch1 [ ] = ” Coucou ! ” ;
char ch2 [ 5 0 ] ;
int i ;
f o r ( i =0; i <=s t r l e n ( ch1 ) ;
i ++)
ch2 [ i ] = ch1 [ i ] ;
p r i n t f ( ” Copie=%s ” , ch2 ) ;
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
// D é c l a r a t i o n de l a
fonction
void A f f i c h e ( ) {
p r i n t f ( ” Message ” ) ;
}
fonction
void A f f i c h e ( ) ;
// f o n c t i o n
principale
i n t main ( ) {
// 1 p p e l de l a
// f o n c t i o n
principale
i n t main ( ) {
// Appel de l a
fct
Affiche () ;
return 0 ;
}
fct
Affiche () ;
return 0 ;
}
// D é c l a r a t i o n de l a
fonction
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
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 ) ;
r e s = Add( −8 , 1 5 ) ;
r e s = Add( −8∗2 −5 , 6∗ a ) ;
return
locale
p r i n t f ( ” \ n R e s u l t a t = %d ” ,
p r i n t f ( ” \ n R e s u l t a t = %d ” ,
p r i n t f ( ” \ n R e s u l t a t = %d ” ,
res ) ;
res ) ;
res ) ;
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>
//
int
D é c l a r a t i o n
de
la
fonction
f a c t ( int n) {
if
fact(4)
4*fact(3)
4*6 = 24
fact(3)
3*fact(2)
3*2 = 6
fact(2)
2*fact(1)
2*1 = 2
fact(1)
1
( n<=1)
return
1;
else
return n∗ f a c t ( n−1) ;
}
int
main ( )
//
{
Appel
de
la
fonction
p r i n t f ( ”\ n F a c t o r i e l
return
4 = %d ” ,
fact (4) ) ;
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
c=’F’
x=-12.98567E-5
0x2ab091
0x2ab097
ë Pointeurs :
Déclaration : float* px ; et char* pc ;
Initialisation : px = &x ; et pc = &c ;
Octet Octet
px=0x2ab091
0x2fc0b3
pc=0x2ab097
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
∗px = 0 ;
la valeur 1 (x)
// 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]
2
vect[2]
3
vect[3]
4
vect[4]
5
6
0x2fcb03
0x2fcb05
0x2fcb07
0x2fcb09
0x2fcb0b
vect
vect+1
vect+2
vect+3
vect+4
ë &vect[0] == vect
ë &vect[i] == vect+i
ë vect[i] == *(vect+i)
: Adresse du 1er élément de vect.
: Adresse du ième élément de vect.
: 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++;
∗ ( q+2) = −10;
\\ Post−i n c ré m e n t a t i o n !
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 ,
i n t aux = ∗ p t 1 ;
∗ pt1 = ∗ pt2 ;
∗ p t 2 = aux ;
}
int
int ∗ pt2 ) {
main ( ) {
int a = 5 , b = 8;
p r i n t f ( ” \ na= %d ,
Swap(&a , &b ) ;
p r i n t f ( ” \ na= %d ,
return
b = %d ” ,
a,
b) ;
b = %d ” ,
a,
b) ;
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” ,
return 0 ;
}
ECM, Mathématique et Informatique, S. Derrode
taille1 ,
taille2 ) ;
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 r e s u l t 2 = mult ( a , b ) ;
i n t mult ( i n t a , i n t 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
#include "test.h"
\\ Prog2.c
#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
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
double a , b ;
val1 ,
double
val2 ) {
point ;
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
return ( p t 1 . x == p t 2 . x ) && ( p t 1 . y == p t 2 . y ) ;
}
int
main ( )
struct
struct
pt2 ) {
{
Point2D
Point2D
point1 = {2.0 , −9.5};
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
pt1−>x += p t 2 . x ;
pt1−>y += p t 2 . y ;
}
int
main ( )
struct
struct
Point2D ∗ pt1 ,
struct
Point2D
pt2 ) {
{
Point2D
Point2D
point1 = {2.0 , −9.5};
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 =
C o m p e t i t i o n S a u t [ 0 ] . Age
7.4;
= 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
x
0x2ab097
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
ECM, Mathématique et Informatique, S. Derrode
x
y
x
y
x
y
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.
Tete
T
A
T
B
T
C
NULL
struct maillon {
char
symb ;
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 ("entree.txt", "r") ;
ë En écriture (avec écrasement !)
g = fopen ("resultat.txt", "w") ;
ë En écriture/ajout (sans écrasement)
g = fopen ("resultat.txt", "a") ;
ë Lecture/Ecriture (sans écrasement, position fin) :
g = fopen ("resultat.txt", "r+") ;
ë Lecture/Ecriture (avec écrasement) :
g = fopen ("resultat.txt", "w+") ;
ë Lecture/Ecriture (sans écrasement, position début) :
g = fopen ("resultat.txt", "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("fichier.bin", "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 ,
f w r i t e (& e l e v e , t a i l l e , 1 ,
}
ficIn ) ;
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 : ” ) ;
if
s c a n f ( ”%d” , &f ) ;
( f ==1)
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 9 . 0 ,
fct 1 (9.0) ) ;
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 9 . 0 ,
fct 2 (9.0) ) ;
else
if
( f ==1)
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 1 2 . 0 ,
fct 1 (12.0) ) ;
p r i n t f ( ” \n f c t (% l f ) = % l f ” , 1 2 . 0 ,
fct 2 (12.0) ) ;
else
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,
équivaut à
NON = 0 , OUI } ;
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 ;
ý Exemple :
signed i n t b 3 7
: 5;
unsigned i n t
: 7;
unsigned i n t b15
: 1;
}
b15
inutilise
15 14 13 12 11 10
b3_7
9
8
7
6
5
b0_2
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
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
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 a.out
gcc monFic.c -o monFic
exécutable monFic
Exécution du programme monFic
Anglais
list
./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
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertising