Vous êtes sur la page 1sur 50

Initiation à La Programmation

en Langage C
M. Lagh him-Lahlou
Département de Mathématiques
Fa ulté Des S ien es Semlalia Marrake h
Filière SMA/Automne 2008
2
Table des matières

1 Généralités 5
1.1 Stru ture des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2 Instru tions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.3 Identi ateurs et mots- lés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.4 Les onstantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.5 Variables et types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.5.1 Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.5.2 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.5.3 Dé laration d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.5.4 Ae tation d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Entrées Sorties 11
2.1 É riture formatée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2 Le ture formatée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3 Opérateurs et Expressions 15
3.1 Les Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.1.1 Opérateurs onnus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.2 Les expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.3 Les onversions de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.3.1 Conversion automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.3.2 Conversion expli ite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4 Instru tions de ontrle 21


4.1 Les instru tions onditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.2 Les instru tions itératives : bou les . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.2.1 bou le while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.2.2 bou le do .. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.2.3 bou le for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

4.2.4 Quelques pièges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.2.5 Les instru tions break et ontinue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3
4 TABLE DES MATIÈRES

5 Les fon tions 29


5.1 Dénition d'une fon tion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2 Appel d'une fon tion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.3 Dé laration d'une fon tion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.4 Variables lo ales et variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.4.1 Variables lo ales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.4.2 Variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

6 Tableaux et Pointeurs 37
6.1 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
6.1.1 Tableaux à un indi e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
6.1.2 Tableaux à plusieurs indi es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.2 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2.1 Adresse d'un objet-Opérateur & . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2.2 Notion de pointeur -Opérateur * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2.3 Pointeurs et Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.2.4 Transmission de paramètres par adresse . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2.5 Tableaux à un indi e en arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

7 Gestion des  hiers 47


7.1 Ouverture et fermeture d'un  hier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.1.1 La fon tion fopen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.1.2 La fon tion f lose . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.2 Fon tions de manipulation de  hiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.2.1 Les fon tion d'é riture/le ture formatées . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.2.2 Impression et le ture de ara tères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Chapitre 1

Généralités

1.1 Stru ture des programmes


• Un programme est une suite d'instru tions déstinées à être exé utées par un ordinateur.
• Un programme ne peut être formulé qu'à l'aide d'un langage ompréhensible par la ma hine. En fait,
la seule langue que omprend l'ordinateur est le langage ma hine (des 0 et des 1).
• Pour des raisons de lisibilité et de maintenan e, il existe des langages de programmation tels que C,
Pas al, Fortran, ... qui sont traduits en langage ma hine à l'aide d'un ompilateur.
voi i un programme en C :

#in lude <stdio.h>


main()
{
printf("voi i un programme C");
}

L'exé ution de e programme a he à l'é ran le message :

voi i un programme C

 hier sour e On é rit le programme à l'aide d'un simple éditeur de texte. Ce texte s'appelle  hier
sour e et on le sauve dans un  hier ave l'extension . . Par ex. On sauve le programme i-dessus sous forme
d'un  hier prog1.
Compilation Un programme ompilé sans erreur rée un  hier exé utable. Sous Linux la ompilation
d'un  hier se fait à l'aide de la ommande g : Par ex. i i on produit un  hier exé utable prog1.e en
faisant

g -o prog1.e prog1.

Exé ution On exé ute par ex. l'exé utable prog1.e en tapant à l'invite ./prog1.e En résumé :

5
6 CHAPITRE 1. GÉNÉRALITÉS


Edition Sour e 
 ⇓ 
Compilation
 
 ⇓
Exé ution 

• Tout programme ne peut être exé uté que si la fon tion prin ipale main est é rite. Tout e qu'il y a
entre { et } après main est le orps prin ipal du programme qui renferme les instru tions à exé uter.
main est appelée la fon tion prin ipale. Les instru tions elles mêmes peuvent être organisées en blo s
{ et }.
délimités par les ara tères
• la ligne #in lude <stdio.h> est une dire tive d'en-tête qui fait appel à une bibliothèque pré ompilée
de nom stdio.h, né essaire pour l'instru tion printf.
• printf est une fon tion qui permet d'a her à l'é ran le texte entre les doubles-apostrophes.
• Toute instru tion élémentaire nit obligatoirement par le point-virgule ( ;) sinon le ompilateur roit
qu'elle n'est pas nie.
• Tout e qui est é rit entre /* et */ est un ommentaire ignoré par le ompilateur.
Généralement un programme a la forme suivante :

Dé larations
main ( )
{
Instru tions ....
}

1.2 Instru tions


Une instru tion est :
• soit simple et se termine toujours par point-virgule  ;
• soit omposée (blo d'instru tins) ontenue entre deux a olades { }

1.3 Identi ateurs et mots- lés


Identi ateur est un nom donné à un objet dans un programme. Ce nom est omposé de lettres (ma-
jus ules ou minus ules), de hires ou du ara tère souligné _dans un ordre quel onque.
 le 1er ara tère ne doit pas être un hire.
 ne doit pas ontenir de ara tères spé iaux omme le point , espa e, &, #, ... mais peut ontenir _
 C distingue les majus ules et les minus ules.
Valable Non Valable
s 1s
_xG3 .xG3
An5t A n5t

Mots- lés Certains mots sont réservés au langage omme :


1.4. LES CONSTANTES 7

int, float, auto, break, onst, if, else, for, while, return, ...
Ces mots sont appelés mots- lés du langage C et ne peuvent être utilisés omme identi ateurs. Dans le
programme i-dessus Nb et Nb_ arre sont des identi ateurs. int, printf, main, in lude sont des mots- lés.

1.4 Les onstantes


Une onstante est une donnée dont la valeur ne se modie pas durant l'exé ution d'un programme.
Une onstante peut être :
→ entière :
124
-5
.
.
.
→ réelle :
-12.45
114.32
65.1e+3 (65.1 × 103 )
→ ara tère :
'a' 'D' '2'
→ haîne de ara tère :
"bonjour"
• un ara tère est toujours entouré d'apostrophes.
• L'é riture '3' signie le ara tère 3 et non l'entier 3
• une haîne de ara tères est une suite de ara tères entourés de guillemets
Il est plus intéressant de désigner une onstante par un nom par ex.
1 :

Exemple.
#in lude <stdio.h>
#define pi 3.141592
main()
{
printf("diamètre d'un er le de rayon 3.8 est %f\n",2*pi*3.8);
}
Dans e programme, l'identi ateur pi est rempla é par la valeur 3.141592 dans toute instru tion dans
le programme qui utilise pi.
Plus généralement, on dé lare une onstante en dehors de main après l'en-tête #in lude ... par :

#define Nom_Constante Valeur

1.5 Variables et types de base


1.5.1 Variable
On pourrait omparer la mémoire de l'ordinateur à une armoire remplie de tiroirs dans lesquels on sto ke
des hoses.
1 22 sep.
8 CHAPITRE 1. GÉNÉRALITÉS

Une variable est un empla ement mémoire qui ontient des valeurs modiables pendant l'exé ution d'un
programme, auquel on asso ie un identi ateur.

1.5.2 Types de base


• Toute variable pour qu'elle soit manipulable, elle doit être asso iée à un type qui orrespond à sa
nature, à la façon de la sto ker et au genre d'a tions sur laquelle on peut ee tuer.
• La mémoire de la ma hine est onstituée de bits (des 0 et des 1). La quantité de mémoire se mesure en
o tets (1 o tet = 8 bits)
• En langage C, il y a trois types fondamentaux de variables suivant la taille de leur o upation en o tets.
On résume ertaines ara téristiques de es types omme suit :
− Les entiers

Type Dés ription Domaine Nombre o tets

int entier standard


31
[−2 , 2 [ 31
4
long entier long [−263 , 263 [ 4
unsigned int entier standard non signé [0, 232 [ 2
unsigned long entier long non signé [0, 264 [ 4

− Les réels ou nombres à virgule ottante : Exemples 3.12, −55.43E − 12, 0.564e + 5 (remarquer que
la virgule du nombre dé imal est toujours notée par point)

Type Dés ription Domaine Nombre o tets

float simple pré ision [3.4 × 10−38 , 3.4 × 1038 ] 4


double double pré ision [1.7 × 10−308 , 1.7 × 10308 ] 8
long double double pré ision long 10

− har (les ara tères) : peut ontenir n'importe quel ara tère de la ma hine, est odé sur un o tet.
Tout objet har est assimilé dans la mémoire par un ode entier dans [−128, 127] appelé ode ASCII.
Don le type har est onsidéré omme un int parti ulier. Par ex. le ara tère 'A' a le ode 65 et
l'opération 'A'+1 a un sens et vaut 66 qui est le ode de 'B'.

Ces ara téristiques dépendent du type de la ma hine et du système d'exploitation.

1.5.3 Dé laration d'une variable


Lorsqu'on programme, il faut toujours énon er le type et le nom d'une variable avant de l'utiliser. Cette
a tion s'appelle dé laration
On dé lare une ou plusieurs variables suivant la syntaxe :

NomType Identifi ateur ;

ou si plusieurs variables d e même t y p e ,


on les sépare par une virgule et on termine la dé laration par ;

NomType Identifi ateur1 , Identifi ateur2 , ...;


1.5. VARIABLES ET TYPES DE BASE 9

1.5.4 Ae tation d'une variable


Lorsqu'on met dans l'empla ement mémoire d'une variable une valeur, on dit qu'on ae te (ou assigne )
ette valeur à la variable

Syntaxe :
Identifi ateur=Valeur;
Initialisation : Une variable est initialisée, lorsqu'elle reçoit pour la première fois une valeur dans le
programme.

Par ex.

#in lude < s t d i o . h>


int a ;
main ( )
{
a =1; /∗ a i n t i a l i s é e à 1 ∗/
...
autres instru tions
}

On peut dé larer et initialiser en même temps une variable.

NomType Identifi ateur=Valeur;


Par ex.

#in lude < s t d i o . h>


int a =0 ,b ; / ∗ a d é l a r é e e t i n i t i a l i s é e à 0 ∗ /
main ( )
{
b=a +1; /∗ a i n i t i a l i s é e à l a d é l a r a t i o n ∗/
b reçoit la valeur de l ' expression a+1 : 1 ∗/
}

Erreur à éviter : utiliser une variable non initialisée


#in lude < s t d i o . h>
int a , b ;
main ( )
{
b=a +1; / ∗ a t t e n t i o n au une v a l e u r dans a ∗ /
...
}
10 CHAPITRE 1. GÉNÉRALITÉS
Chapitre 2

Entrées Sorties
La bibliothèque standard stdio ontient plusieurs fon tions qui assurent la ommuni ation de la ma hine
ave le monde extérieur. Les plus importantes sont printf, s anf, put har, get har

2.1 É riture formatée


int a =2;
float b = 3 . 5 ;
...
printf (" le produit d e %i e t %f e s t %f " , a , b , a ∗ b ) ;

Cette instru tion a he à l'é ran :


le produit de 2 et 3.500000 est 7.000000

La fon tion printf a he du texte, des valeurs de variables ou des résultats d'expressions.

Syntaxe
printf(" haîne de ontrle",expr1,expr2, ...) ;


" haîne de ontrle" ontrle la présentation et peut ontenir :
• du texte
• des odes d'é happement (\n,\t, ...)
• des odes de format : indiquent la manière d'a her les valeurs respe tives des expressions expr1,
expr2, ... Cha un de es odes .

Règle : nombre de odes de format dans la haîne de ontrle = nombre d'expressions


odes d'é happement : est un ouple de ara tères dont le 1er est le ba kslash  \ , qui ontrle
l'a hages de ertains ara tères spé iaux omme les espa ements entre les données.

11
12 CHAPITRE 2. ENTRÉES SORTIES

Code Signi ation

\n passage à une nouvelle ligne


\t espa e tabulation
\r retour au début de la ligne
\b urseur en arrière
\\ ba kslash
\" guillemets
\f saut de page
\v tabulation verti ale

odes de format : est un ensemble de ara tères dont le 1er est le ara tère spé ial  %  suivi d'autres
ara tères

Code Type A hage

%d ou %i int entier relatif


%u unsigned int entier positif
%ld ou %li long entier long
% har ara tère
%s har* haîne de ara tères
%f float ou double notation dé imale (6 hires par défaut après le point dé imal)
%e (ou %E)  notation s ientique (6 hires par défaut après le point dé imal)
%Lf long double notation dé imale
%Le (ou %LE)  notation s ientique

Exemple.
#in lude < s t s i o . h>
int n ;
double f ;
main ( )
{
n =112;
f =12.5;
p r i n t f ( n=%d \ t f=%E\n , n , f ) ;
}

produit l'a hage :

n=112 f=1.250000E+01

un ode de format admet une forme plus générale :

% drapeau largeur .pre ision ode


2.2. LECTURE FORMATÉE 13

2.2 Le ture formatée


La fon tion de le ture ou de saisie de données à partir du lavier est s anf().
syntaxe :
s anf("format",&var1;&var2,...) ;


"format" indique le format de le ture des variables var1,var2, ... . en respe tant :
 format ne ontient que les odes de format %d, %f, ... ( ni texte, ni odes d'é happement : (\n, \t,
...).
 Les données saisies au lavier doivent être séparées par des espa es ou des retours à ligne ou des
tabulations.
 Il ne faut jamais oublier le symbole & devant le nom de haque variable à lire.
&var est l'adresse mémoire de la variable var qui va re evoir la donnée du lavier.
Remarque. Les spé i ateurs de format pour s anf sont les mêmes que pour printf sauf pour le type double
pour lequel on doit utiliser %lf ou %le.
Exer i e. É rire un programme qui lit 2 entiers a,b au lavier et a he leur diéren e.
Programme :

#in lude < s t d i o . h>


int r ;
main ( )
{
p r i n t f ( " Entrez les 2 e n t i e r s \n " ) ;
s a n f ( "%d " ,& a ) ;
s a n f ( "%d " ,&b ) ; / ∗ ou bien s anf ("%d%d",&a,&b ) ; ∗ /
p r i n t f ( " La differen e d e %d e t %d e s t %d \ n " , a , b , a−b ) ;
}
14 CHAPITRE 2. ENTRÉES SORTIES
Chapitre 3

Opérateurs et Expressions

3.1 Les Opérateurs


3.1.1 Opérateurs onnus
On lasse les opérateurs en 2 atégories :
• unaires : il n'agissent que sur une donnée
• binaires : ils agissent sur 2 données

Opérateurs arithmétiques
+ addition binaires
- soustra tion 
* multipli ation 
/ division 
% modulo (reste de la div. eu lidienne) 
- nombre négatif unaire

Remarque.
1. Si a et b sont 2 entiers alors l'opération a/b donne le quotient de la division de a par b et non la division
dé imale.
Exemple : Si on a

float x; x=3/2;
alors on ae te à x la valeur 1.000000 et non 1.5.
Par ontre x=3/2.0 ; ou x=3.0/2 ; ae te à x 1.500000
2. L'opérateur % ne s'applique qu'à 2 entiers.
b
3. Il n'y a pas en C d'opérateur d'exponentiation (a )

15
16 CHAPITRE 3. OPÉRATEURS ET EXPRESSIONS

Opérateurs de omparaison
== égal à x==y
!= diérent de x !=y
>= supérieur ou égal x>=y
> stri tement supérieur x>y
<= inférieur ou égal x<=y
< stri tement inférieur x<y

Attention : ne pas onfondre l'opérateur de test d'égalité == ave l'ae tation =

Opérateurs logiques
&& et logique x&&y
|| ou logique x||y
! négation logique !x

Remarque.
1. En C l'évaluation logique d'une expression obéit à la règle générale :

(a) Une expression numérique est logiquement fausse si sa valeur numérique est 0

(b) est vraie si sa valeur numérique est 6= 0.

2. Le résultat d'une omparaison est soit 0 (faux), soit 1 (vraie).

Exemple.
1. 5==10 a omme valeur logique 0.
Ainsi x==(5==10) ; signie que x reçoit 0. Et x=(10>=5) signie que x reçoit 1

2<0 (vaut 0)
-1==(3-4) (vaut 1)
1 && (11>(2.5-2) (vaut 1 ar 11>0.5 vaut 1)
!0.5 && (2<=1) (vaut 0 ar !0.5 vaut 0 et 2<=1 vaut 0)
Une équivalen e : Une relation souvent employée ave les stru tures de ontrle (voir hap. 4) est la
suivante :
!x ⇐⇒ x==0.
En eet, si x est égal à 0 alorsx==0 est vraie et vaut 1 et !x vaut 1. Sinon !x vaut 0 et x==0 est fausse et
vaut 0.

Exemple.
int x =5;
. . .
p r i n t f ( "%d \ t%d " , ! x , x ==0); /∗ a f f i h e 0 0 ∗/
ar x vaut 5 (valeur logique vraie ar 6= 0 → !x vaut 0). Et x==0 est fausse vaut 0.
3.2. LES EXPRESSIONS 17

Opérateurs d'ae tation C dispose des opérateurs d'ae tation suivants :

reçoit
=
←−
ae tation simple x=y
+= ae tation ave addition x+=y⇔x=x+y
-= soustra tion x-=y⇔x=x-y
*= Multipli ation x*=y⇔x=x*y
/= Division x/=y⇔x=x/y
%= Modulo x%=y⇔x=x%y
++ In rémentation (augmenter de 1) x++ (ou ++x)⇔x=x+1
-- Dé rémentation (diminuer de 1) x- - (ou - -x)⇔x=x-1

Exemple.
int i =10;
...
i ++; i +=2; p r i n t f ( i=%d " , i ) ; /∗ affi he i =13 ∗/

Attention A utiliser ave pruden e : On les emploie en général dans les bou les (voir un hapitre plus
loin).

3.2 Les expressions


On forme une expression par l'une des manières suivantes :
• onstantes ou variables sont des expressions
• On peut ombiner des expressions à l'aide des opérateurs pour former de nouvelles expressions plus
omplexes

Priorité des opérateurs Pour évaluer une expression, il existe des priorités entre les opérateurs.
Soit l'instru tion : printf("%d",1+2*3+4); /* affi he 11 */
ar i i l'opérateur * +:
a une priorité plus élevée que
étape 1 2*3 → 6
étape 2 1+6 → 7
étape 3 7+4 → 11
Parenthésage : Si on veut infulen er le résultat d'une instru tion il faut grouper les parties de l'expression
à al uler en priorité entre parenthèses :
printf("%d",(1+2)*3+4); /* affi he 13 */
18 CHAPITRE 3. OPÉRATEURS ET EXPRESSIONS

Classement des priorités :


Priorité Opérateur

1 (la plus forte) ( )


2 ! ++ -- -(unaire)
3 * / %
4 + -
5 < <= > >=
6 == !=
7 &&
8 ||
9 (la plus faible) = += -= *= /= %=

Exer i e. Soit u=2 ;v=-5 ;


Que fait v*=u+1 ;
A quelle instru tion est-elle équivalente ?

Fon tions mathématiques :


Certaines fon tions mathématiques sont prédénies dans la bibliothèque math.h. Pour pouvoir les utiliser,
le programme doit ontenir la dire tive #in lude <math.h> et ompiler le  hier du programme fi hier.
ave l'option -lm :

g -o fi hier.e fi hier. -lm

Fon tion C Notation math.

exp(x) ex
log(x) ln(x)
pow(x,y) √
xy
sqrt(x) x
fabs(x) |x|
floor(x) E(x)
sin(x) os(x) tan(x) sin(x) cos(x) tan(x)
asin(x) a os(x) atan(x) arcsin(x) arccos(x) arctan(x)
sinh(x) osh(x) tanh(x) sinh(x) cosh(x) tan(x)

3.3 Les onversions de type


3.3.1 Conversion automatique
une onversion de type est automatique lorsque :
 une expression est évaluée
 une ae tation est faite
3.3. LES CONVERSIONS DE TYPE 19

Exemple. on onsidère les variables :

har x= 'A ' ;


int k =2;
float y = 1 . 5 ;
double z ;
z=x ∗ k−y ;

1. x*k
x→int (65)⇒x*k de type int vaut 130
2. x*k-y⇒x*k→float ( ar float plus large que int) vaut 130.000000
puis x*k-y vaut 128.500000

3. x*k-y→double ( ar z est double plus large que float)


z vaut 128.500000
danger : si on avait dé larait int z; valeur de z deviendrait 128 (perte de la partie dé imale).
En règle générale dans une expression :

har =⇒ int =⇒ long =⇒ float =⇒ double =⇒ long double


Mais il faut par ex. éviter :
float, double, long double → int, har
long double → double, float
dans une ae tation.

3.3.2 Conversion expli ite


Il est possible de onvertir expli itement une valeur en un type quel onque en forçant la transformation
à l'aide de la syntaxe :

(nom_type)expression
Exemple. On fait la division de deux entiers :

int a =3;
int b =4;
int ;
float d ;
=a / b ;
d=( float ) a / b ;
puisque a,b sont de type int, a/b est le quotient de la division entière de a par b. Don prend la valeur
entière 0. Mais l'é riture (float)a for e à onvertir a en ottant et la division sera dé imale. Don d prend
la valeur 0.75.
20 CHAPITRE 3. OPÉRATEURS ET EXPRESSIONS
Chapitre 4

Instru tions de ontrle


Ce sont des instru tions par lesquelles on peut ontrler le déroulement du programme

4.1 Les instru tions onditionnelles


Une stru ture onditionnelle (ou alternative) est une instru tion qui exé ute une a tion selon qu'une
ondition logique soit vraie on fausse

Forme 1 : if
if ( ondition )
{
instru tions
}

ondition est une expression logique. Si elle est vraie alors intru tions sont exé utées.

Exemple. if (x<0) printf(" e nombre est négatif") ;


Forme 2 : if ... else ...
if ( ondition )
{
instru tions
}
else
{
aures instru tions
}

Si ondition est vraie alors instru tions sont exé utées, sinon autres_instru tions sont exé utées.

Exemple. Cal uler le maximum de 2 nombres :

21
22 CHAPITRE 4. INSTRUCTIONS DE CONTRÔLE

int a , b , max ;
...
i f ( a<b ) max=b ;
else max=a ;
Remarque. 1. On peut enlever les a olades désignant les blo s lorsqu'on a une seule instru tion

2. ondition peut être une expression numérique. Si ondition 6= 0 : vraie et si ondition= 0 :


faux.
On peut avoir des stru tures if .. else imbriquées :

if ( ondition1 )
{
instru tions_1
}
else
if ( ondition2 )
{
instru tions_2
}
else
if ( ondition3 )
{
instru tions_3
}

....

Règle : la partie else est toujours liée au dernier if qui ne possède pas de else
Exer i e : que fait l'instru tion

int N=0, A=1, B=2;


...
if (N>0)
if(A>B) C=A;
else C=B;
4.1. LES INSTRUCTIONS CONDITIONNELLES 23

Bran hement multiple : swit h


swit h ( e x p r e s s i o n _ e n t i è r e )
{
ase onst − 1:
{
instru tions_1
}
break ;
ase onst − 2:
{
instru tions_2
}
break ;
. . .
ase onst−n :
{
instru tions −n
}
break ;
default : / ∗ f a u l t a t i f ∗/
{
autresinstru tions
}
}

Si expression= onst-1, instru tions-1 sont exé utées et break : sort de la stru ture swit h à la suite
du programme.
Si expression= onst-2, instru tions-2 sont exé utées et break.
... et
Si expression ne vaut au une des onstantes (par défault) autres_instru tions sont exé utées.

Exemple.
#in lude < s t d i o . h>
int nb ;
main ( )
{
printf (" entrez un entier : \ n" ) ;
s a n f ( "%d " ,& nb ) ;
swit h ( nb )
{
ase 0 : p r i n t f ( " z e r o \n" ) ;
break ;
ase 1 : p r i n t f ( " un \ n " ) ;
break ;
24 CHAPITRE 4. INSTRUCTIONS DE CONTRÔLE

ase 2 : p r i n t f ( " deux \ n " ) ;


break ;
default : p r i n t f ( " g r a n d \n " ) ;
}

4.2 Les instru tions itératives : bou les


Les stru tures itératives ou bou les permettent de répéter l'exé ution d'une ou plusieurs instru tions
sans les réé rire.
On distingue 3 types de bou les :
• while
• do .. while
• for

4.2.1 bou le while


while ( ondition )
{
instru tions
}

Tant que ondition est vraie exé uter instru tions.


Exemple. E rire une bou le qui al ule la somme 1 + 2 + · · · + n, ave n lu au lavier.

int k,s ,n;


...
s a n f ( "%d " ,&n ) ;
s =0; / ∗ i n i t i a l i s a t i o n de l a somme dans une v a r i a b l e s ∗ /
k =1; / ∗ i n i t i a l i s a t i o n d ' une v a r i a b l e de o n t r  l e de l a b o u l e ∗ /
while ( k<=n )
{
s+=k ;
k++; / ∗ mise à jour de k ∗ /
}

Attention. Il ne faut jamais oublier l'initialisaion des variables qui interviennent dans la ondition de while
ou dans son orps avant l'entête : while ( ondition).
En eet,

1. Si on oublie de lire n ou initialiser k, la ondition de while ne peut être vériée

2. Si on oublie d'initialiser s le al ul ne peut être fait orre tement.


4.2. LES INSTRUCTIONS ITÉRATIVES : BOUCLES 25

Exer i e : E rire un programme qui a he

100
98
96
.
.
.
2
0

sol.
#in lude < s t d i o . h>
int I = 1 0 0 ;
main ( )
while ( I >−1)
{
p r i n t f ( "%d " , I ) ;
I −=2;
}

4.2.2 bou le do .. while


do
{
instru tions
}
while ( o n d i t i o n ) ;
I i la ondition de la bou le est testée après le blo d'instru tions.
Exemple. Examinons l'exemple :

int i,j;
. . .
printf(" ombien de fois doit tourner ette bou le ?\n");
s anf("%d",&i);
j=0;
do
{
j++;
printf("C'est le passage numero %d\n",j);
}
while(j<i);
26 CHAPITRE 4. INSTRUCTIONS DE CONTRÔLE

4.2.3 bou le for


C'est une bou le de la forme

for ( i n i t i a l i s a t i o n ; o n d i t i o n ; o m p t e u r )
{
instru tions
}

L'entête est omposée de 3 mor eaux séparés entre eux du point-virgule :


 initialisation est une (ou des) instru tion(s) d'initialisation des données de la bou le. Elle est exé-
utée une seule fois avant le passage de la bou le ( e qui orrespond à l'initialisation de while).
 ondition est une ondition logique qui dé ide de la répétition de la bou le. Si elle est fausse la bou le
s'arrête.
 ompteur est une expression qui met à jour après haque passage de la bou le les variables qui la
ontrlent.

Exemple.
int I;
...
for(I=0;I<=10;I++)
printf("Le arre de %d est %d\n",n,n*n);

Cette bou le donne à son exé ution :

Le arre de 0 est 0
Le arre de 1 est 1
Le arre de 2 est 4
...
Le arre de 10 est 100

On appelle en général la variable entière qui gure dans initialisation et ompteur une variable de
ontrle ou de omptage de la bou le.

Remarque.
1. La bou le for est équivalente à la stru ture :
initialisation;
while( ondition)
{
instru tions
mise à jour du ompteur
}
2. En pratique, souvent les parties initialisation et ompteur peuvent ontenir resp. plusieurs instru -
tions qu'il faut séparer par des virgules omme dans l'exemple suivant :
4.2. LES INSTRUCTIONS ITÉRATIVES : BOUCLES 27

Exemple.
int n , som ;
...
for ( som =0 ,n=1 ; n<100 ; n++) som=som+n ;

4.2.4 Quelques pièges


On onsidère la bou le :

int i =−1;
while ( i <10)
/ ∗ f i n de b o u l e ∗ /
p r i n t f ( "%d \ n " , i ) ;
i ++; / ∗ en dehors de l a b o u l e ∗ /
Cette bou le ne s'arrête jamais, i sera toujours égale à -1 et a hera sans arrêt -1.
Ce genre de stru tures s'appelle bou le inni.
Il faut mettre les a olades pour in lure i++ dans le orps de la bou le pour a her 1 2 3 :

int i =−1;
while ( i <10)
{
p r i n t f ( "%d \ n " , i ) ;
i ++;
} / ∗ f i n de b o u l e ∗ /
De même :

for ( i =3; i >0; i ++) p r i n t f ( "%d \n " , i ) ;

a hera sans arrêt les entiers à partir de 3


Autre exemple. :

int i ; . . .
for ( i =1; i <=−1;i −−) p r i n t f ( "%d \ n " , i ) ;

La ondition de répétition i<=-1 n'est jamais vériée. Don au un passage dans la bou le n'est ee tué.
C'est e qu'on applle une bou le vide.

4.2.5 Les instru tions break et ontinue


• break : permet d'interrompre le déroulement d'une bou le et passe à la première instru tion qui la
suit :

for ( i =0; i <5; i ++)


{
p r i n t f ( " i=%d \n " , i ) ;
if ( i ==3) break ;
}
28 CHAPITRE 4. INSTRUCTIONS DE CONTRÔLE

exé ution :

i=0
i=1
i=2
i=3
sort de la bou le
• ontinue : permet de passer dire tement au tour suivant de la bou le sans exé uter les instru tions de
la bou le :

for ( i =0; i <5; i ++)


{
if ( i ==2) ontinue ;
p r i n t f ( " i=%d \n " , i ) ;
}

exé ution

i=0
i=1
i=3
i=4
Chapitre 5

Les fon tions


Tout programme é rit en C ontient obligatoirement au moins une fon tion : la fon tion prin ipale main
qui permet d'exé uter le programme. On a besoin de onstruire des fon tions se ondaires pour les raisons
suivantes :
• Pour une question de larté : lorsqu'un programme en C est long, sa le ture et sa maintenan e devien-
nent pénibles. Imaginez un livre sans hapitres et paragraphes.
• Certaines parties du programme réalisent des tâ hes identiques ou omparables. Un dé oupage en parties
distin tes et ohérentes est utile.
• Lorsqu'on veut réutiliser (ou partager) ertains mor eaux du programme dans (ou ave ) d'autres pro-
grammes
Une fon tion est un mor eau de programme, auquel on a attribué un nom. C'est en quelque sorte un
sous-programme du programme prin ipal

5.1 Dénition d'une fon tion


La dénition générale d'une fon tion est :

typeresultat nomfon tions ( type1 argument1 , t y p e 2 argument2 , ...)


{
de larations lo ales
...
instru tions
}


• type-resultat : est le type de la valeur du résultat qu'elle renvoie (s'il y en un)
• argument1, argument2, ... sont ses arguments formels de type respe tivement type1, type2, ...
• Le orps de la fon tion ontient des dé larations lo ales (variables ...) à la fon tion et des instru tions et
se termine par l'instru tion return(expression);. La valeur de expression est la valeur que renvoie
la fon tion de même type que type-resultat de l'en-tête.

29
30 CHAPITRE 5. LES FONCTIONS

Exemple.
float diff ( int a, float b)
{
float t;
t=a−b ;
return ( t ) ;
}

Exemple. Une fon tion de nom Max qui a 2 entiers en paramètres et fournit leur maximum omme résultat

int Max( int n, int m)


{
i f ( n>m) return ( n ) ;
else return (m) ;
}

Remarques
1. Le mot lef return est né essaire lorsque la fon tion retourne une valeur résultat .
2. Le type-resultat est un type simple non omposé (int, float, ...)
3. Si le type d'une fon tion n'est pas dé laré expli itement, elle est automatiquement de type int
4. void est le type indéni, utilisé :
− lorsqu'une fon tion n'a pas d'arguments : on le met à la pla e des arguments
− lorsqu'une fon tion ne retourne au une valeur en résultat. Dans e as, on dé lare void omme type
de la fon tion et on peut enlever return.
5. Il est interdit de dénir une fon tion à l'intérieur du orps d'une autre fon tion
Exemple.
1. La fon tion Entree suivante sans paramètre donne en sortie un nombre lu au lavier

Entree ( void )
{
int nbr ;
p r i n t f ( " Entrez un nombre " ) ;
s a n f ( "%d " ,& n b r ) ;
return ( n b r ) ;
}

2. La fon tion affi he a he un message à l'é ran. Elle n'a ni arguments ni de retour d'un résultat :

void affi he ( void )


{
p r i n t f ( " Ce i est une f o n t i o n \n" ) ;
}
5.2. APPEL D'UNE FONCTION 31

5.2 Appel d'une fon tion


L'appel d'une fon tion dans un programme se fait par

nom-fon tion(param1,param2, ...) ;


où param1,param2, ... sont les valeurs ee tives des paramètres transmises à la fon tion lors de son appel.
Leur ordre et leur type doit stri tement respe ter eux des arguments formels dans l'en-tête de la
dénition.

Exemple. Voi i un programme qui appelle Max :

#in lude < s t d i o . h>


int Max( int r , int s )
{
i f ( p>q ) return ( r ) ;
else return ( s ) ;
}

main ( )
{
int a , b ,m;
p r i n t f ( " Entrer 2 entiers");
s a n f ( "%d%d " ,&a ,& b ) ;
m=Max( a , b ) ; / ∗ p l a e l e r e s u l t a t de Max dans m ∗ /
p r i n t f ( " Le max e s t %d \ n " ,m) ;
}

En C, le passage des paramètres se fait toujours par leurs valeurs ee tives. On ee tue le passage des
paramètres par valeurs.

Erreurs à éviter :
Exemple.
#in lude < s t d i o . h>
double g ( int n , float x)
{
...
return ( . . . ) ;
}
main ( )
{
int a ;
float b ;
...
g (b , a ) ; / ∗ faux ∗ /
g(a ,b ); /∗ j u s t e ∗/
g ( a , b , x ) ; / ∗ faux ∗ /
...
}
32 CHAPITRE 5. LES FONCTIONS

Remarque : Si une fon tion n'a pas d'arguments : type nom-fon tion(void) { ... }, alors on l'ap-
pelle par nom-fon tion() ;
exer i e E rire un programme qui appelle Entree et Affi he i dessus.
#in lude < s t d i o . h>
int E n t r e e ( void )
{
int nbr ;
p r i n t f ( " Entrez un nombre " ) ;
s anf (" r e t u r n ( nbr ) ;
}
void a f f i h e ( void )
{
p r i n t f ( Ce i est une fon tionn ) ;
}
main ( )
{
Entree ( ) ;
Affi he ( ) ;
}

Remarque. Une fon tion peut appeler une (ou plusieurs autres ) fon tion(s) : La fon tion appelée
doit être dénie avant la fon tion appelante.

...
type fun 1 ( . . . )
{
...
}
type fun 2 ( . . . )
{
...
appel fun 1
...
}
type fun 3 ( . . . )
{
...
appel fun 1
...
appel fun 2
...
}
5.3. DÉCLARATION D'UNE FONCTION 33

5.3 Dé laration d'une fon tion


La dénition d'une fon tion doit être pla ée soit avant, soit après la fon tion appelante (main par ex.)
Toutefois, le ompilateur a besoin de onnaître la fon tion au moment de son appel. Si une fon tion est dénie
après son premier appel, elle doit être dé larée avant d'être appelée pour la première fois.
On dé lare une fon tion par son prototype sous la forme :

type_resultat nom_fon tion(type1, type2, ...) ;

Cette dé laration peut être pla ée avant ou au début de la fon tion appelante.

...
type fun ( type1 , type2 , ...); / ∗ d e l a r a t i o n avant main ∗ /
main ( )
{
...
appel fun ;
...
}
type fun ( . . . ) / ∗ d e f i n i t i o n apres 1 er appel de fun ∗ /
{
...
}

Exemple. On dé lare une fon tion dist à 4 arguments, les oordonnées de deux points x1, y1, x2, y2 de type
float et qui renvoie la dista e entre es 2 points (x2 − x1)2 + (y2 − y1)2 . On pourrait la dénir après main
p

#in lude < s t d i o . h>


#in lude <math . h>
float d i s t ( float , float , float , float ) ;
main ( )
{
float a,b, ,d ,;
printf (" entrez les oordonnées" ) ;
s anf (" printf (" la distan e est :% f \ n " , d i s t ( a , b , , d ) ) ;
}
float dist ( float x, float y, float z, float t)
{
float d;
d=s q r t ( ( x−y ) ∗ ( x−y )+( z−t ) ∗ ( z −t ) ) ;
return (d ) ;
}

Remarque. Comme pré édemment, une fon tion fun 2 peut appeler une autre fon tion fun 1 dénie après
son appel, à ondition de dé larer ette dernière avant ou au début du orps de fun 2 suivant le même
prin ipe.
34 CHAPITRE 5. LES FONCTIONS

5.4 Variables lo ales et variables globales


5.4.1 Variables lo ales
Considérons le programme suivant :

#in lude < s t d i o . h>


void a f f e t ( void )
{
int u =2;
p r i n t f ( " La valeur de u à l ' intérieur de la fon tion e s t %d \n " , u ) ;
}

main ( )
{
int u =0;
p r i n t f ( " La valeur de u avant l ' appel de la fon tion e s t %d \n " , u ) ;
affe t ();
p r i n t f ( " La valeur de u apres l ' appel de la fon tion e s t %d \n " , u ) ;
}

L'éxé ution de e programme donne :

La valeur de u avant l'appel de la fon tion est 0


La valeur de u a l'interieur de la fon tion est 2
La valeur de u apres l'appel de la fon tion est 0
On voit que la variable u dé larée à l'intérieur de la fon tion affe t est détruite après l'appel et l'éxé ution
de la fon tion affe t.
Les variables lo ales sont les variables dé larées dans la dénition d'une fon tion.
Elles n'ont une durée de vie dans la mémoire que pendant l'exé ution de la fon tion

5.4.2 Variables globales


Une variable globale est une variable disponible pour toutes les fon tions
Elle est dé larée en dehors de toute fon tion.
Exemple.
#in lude < s t d i o . h>
void a f f e t ( void )
{
int u=u +2;
p r i n t f ( " La valeur de u à l ' intérieur de la fon tion e s t %d \n " , u ) ;
}

main ( )
{
int u =0;
5.4. VARIABLES LOCALES ET VARIABLES GLOBALES 35

p r i n t f ( " La valeur de u avant l ' appel de la fon tion e s t %d \n " , u ) ;


affe t ();
p r i n t f ( " La valeur de u apres l ' appel de la fon tion e s t %d \n " , u ) ;
}

Ce programme a he :

La valeur de u avant l'appel de la fon tion est 0


La valeur de u a l'interieur de la fon tion est 2
La valeur de u apres l'appel de la fon tion est 2
36 CHAPITRE 5. LES FONCTIONS
Chapitre 6

Tableaux et Pointeurs

6.1 Tableaux
6.1.1 Tableaux à un indi e
Exemple. On suppose qu'on veut déterminer à partir de 100 notes d'étudiants de SMA/S3 ombien d'entre
elles sont supérieures à la moyenne.
Ave les outils que l'on sait jusqu'à présent, on essaie de programmer omme suit :

float nt , moy ;
...
s =0;
for ( i =1; i <=100; i ++)
{
s a n f ( "%f " ,& n t ) ;
s=s+n t ;
moy=s / 1 0 0 ;

Il ne s'agit pas que de al uler la moyenne moy mais de omparer en plus ha une des notes à moy et de
les omptabiliser.
Problème ! dans la mémoire, nt n'est qu'une variable simple qui ontient une seule valeur é rasée par le
passage suivant de la bou le.
Il est né essaire de mémoriser toutes les notes.

Solution : dé larer 100 variables diérentes ? ?

Un tableau à un indi e est un ensemble ni formé d'un nombre N de variables simples
de même type, qui sont appelées omposantes du tableau et N est sa taille

Les omposantes d'un tableau o upent des zones mémoires ontigues

... ...
N omposantes

37
38 CHAPITRE 6. TABLEAUX ET POINTEURS

Dé laration
type nom_tableau[taille℄;

Exemples.

int t [ 1 0 0 ℄ ; / ∗ on r é s e r v e l ' empla ements pour 100 éléments de type i n t ∗/


float B [ 1 0 ℄ ; / ∗ t a b l e a u B de f l o t t a n t s de t a i l l e 10 ∗ /
har a [ 6 ℄ ; / ∗ t a b l e a u a de 5 a r a t è r e s ∗ /
On peut aussi dé larer et initialiser un tableau omme e i :

int tb1 [4℄={12 ,13 ,15 , −12};


int tb2 [ ℄ = { 1 0 , 2 0 , 3 0 , 4 0 , 5 0 , 5 0 0 } ; / ∗ a t t r i b u t i o n automatique de l a t a i l l e à tb2 ∗ /
Si la taille est plus grande que le nombre de valeurs dans la liste alors toutes les omposantes restantes
sont initialisées à 0.
Par ontre :

int tb3 [2℄={2 ,5 , −1 ,8 ,3} / ∗ erreur ar t a i l l e < nombre de v a l e u r s ∗ /

A ès aux omposantes
Chaque élément du tableau est repéré par sa position dans le tableau appelée indi e. Les valeurs que peut
prendre l'indi e doivent être des entiers ≥ 0.
Par ex. si on dé lare un tableau par :

int A[ 5 ℄ ;

On a ède à ses omposantes par l'identi ateur du tableau suivi d'un indi e entre ro hets : A[0℄, A[1℄,
...

Par onvention en C, la 1ère position porte toujours le numéro 0 Si T est un tableau


de taille N, le premier élément est T[0℄ et le dernier est T[N-1℄

Quelques règles
1. Un élément de tableau est manipulé omme une variable :

 peut être ae té : t[2℄=1.4 ;


 ou omme opérande de n'importe quelle expression : 2*t[2℄-3+t[0℄ ;
 lu au lavier : s anf("%d",&t[3℄);
Mais il est interdit d'é rire des opérations globales omme par exemple : t1=t2 où t1 et t2 sont deux
tableaux.

2. Un indi e peut être n'importe quelle expression arithmétique dont la valeur est un entier≥ 0. Par ex.
si n,p,k,j sont de type int les notations t[n-3℄, t[3*p-2*k+j℄ sont valables à ondition qu'on ne
fait pas de dépassement de l'intervalle des indi es.

3. La taille d'un tableau ne peut être qu'une onstante ou une expression onstante. de type entier.
Par ex.
6.1. TABLEAUX 39

#define N 50
...
int t [ N ℄ ;
float h [ 2 ∗ N− 1 ℄ ;
sont des dé larations orre tes.
Mais les dé larations suivantes ne sont pas valables

int N ;
int t [ N ℄ ; / ∗ t a i l l e in onnue ? ∗ /
float A [ 6 . 5 ℄ ; / ∗ t a i l l e n ' e s t pas un e n t i e r ∗ /
Il faut éviter aussi :

int N= 1 0 ;
float t [ N ℄ ;
Exer i e. E rire un programme qui lit N omposantes à partir du lavier d'un tableau T de type float de
taille 20. L'entier N est entré au lavier et le programme a hera les éléments du tableau.

Programme :
#in lude < s t d i o . h>
#define dim 2 0
int i , N ;
float T [ dim ℄ ;
main ( )
{
p r i n t f ( " Entrez un e n t i e r <= 2 0 " ) ;
s a n f ( "%d " ,&N ) ;
p r i n t f ( " Le ture d e %d o m p o s a n t e s \n " ,N ) ;
for ( i =0; i <N ; i ++) s a n f ( "%f " ,&T [ i ℄ ) ;
printf (" Affi hage \n :");
for ( i =0; i <N ; i ++)
p r i n t f ( " omposante de p o s i t i o n %d = %f \ n \ " , i , T [ i ℄ ) ;
}

6.1.2 Tableaux à plusieurs indi es


Dé laration et initialisation
On se limite aux tableaux de dimension 2. C'est un tableau de tableaux
Dé laration :
nom_type nom_tableau[taille1℄[taille2℄;

double a[4℄[6℄ ; réserve un tableau a de 24 = 4 × 6 éléments de type double.


Le rangement en mémoire se fait omme suit :
40 CHAPITRE 6. TABLEAUX ET POINTEURS

a[0℄[0℄ a[0℄[1℄ ... a[0℄[5℄ a[1℄[0℄ ... a[1℄[5℄ ... a[3℄[0℄ ... a[3℄[5℄

On peut initialiser dans la dé laration omme :

float Tab [ 4 ℄ [ 3 ℄ = { { 4 5 , 4 . 2 , −2.5} , {0.5 ,2.5 ,13} , {11 ,0.5 ,5.8} , { −5.35 ,41 , −51}};

D'autres exemples :

int C[ 4 ℄ [ 4 ℄ = { { 1 , 1 , 1 , 1 } } ;

1 1 1 1
0 0 0 0
0 0 0 0
0 0 0 0

int C[ 4 ℄ [ 4 ℄ = { { 1 } , { 1 } , { 1 } , { 1 } } ;

1 0 0 0
1 0 0 0
1 0 0 0
1 0 0 0

float B [ ℄ [ 2 ℄ = { { 1 . 2 , − 4 e − 3} , { − 2 . 4 , 1 . 0 8 } , { − 3 . 2 1 , 5 . 6 } } ;
int t [ 3 ℄ [ 3 ℄ = { { 1 , 1 , 1 , 1 } } / ∗ I n o m p a t i b i l i t é ∗ /

A ès aux omposantes
Un élément d'un tableau à double indi e est repéré par la syntaxe :

Nom_Tableau[indi e_ligne℄[indi e_ olonne℄;

Exer i e. E rire un programme qui dénit la matri e arrée M 10 × 10 suivante :

0 1 0
 
 .. 
 1 0 1 . 0 
 
 .. 
M = 0 1 .
 

 . .. .. ..
 ..

 . . . 0 

 0 1 
0 1 0
6.2. POINTEURS 41

6.2 Pointeurs
6.2.1 Adresse d'un objet-Opérateur &
Tout objet sto ké o upe un ou plusieurs o tets mémoire identiés par un numéro ou adresse
int i , j ;
i =2;
j= i ;

i 2 j 2

4831836000 4831836004

adresses

L'opérateur & permet de désigner l'adresse d'une variable. Ainsi &i est l'adresse de i et vaut 4831836000.
Après l'ae tation j=i ; les variables i,j ont les mêmes valeurs à des adresses diérentes.

6.2.2 Notion de pointeur -Opérateur *


Un pointeur est un objet destiné à ontenir l'adresse d'un autre objet d'un ertain type.
On dé lare un pointeur par :

type-pointeur *identifi ateur-pointeur;

Exemple. 1

float x =3.5;
float ∗p ; / ∗ p p o i n t e u r v e r s un o b j e t de type f l o a t ∗ /
p=&i ; / ∗ p o n t i e n t l ' adrese de x ∗ /
L'opérateur * permet d'a éder dire tement à la valeur de l'objet pointé . Ainsi :
Si p pointe vers x, alors *p est la valeur de x. Don on a la s héma :

x 3.5 *p

p 123655000
Toute modi ation de *p modie x.
Remarque. Un pointeur est toujours un entier (attention : il n'est pas de type int).
Considérons le programme :

1 22 dé .
42 CHAPITRE 6. TABLEAUX ET POINTEURS

#in lude < s t d i o . h>


int ∗ p1 , ∗ p2 , ∗ q ;
int a =10 ,b = 2 0 ;
main ( )
{
p1=&a ;
p2=&b ;
∗ p1=∗p2 +2; / ∗ joue l e même r  l e que a=b+2 ∗ /
p r i n t f ( " a = %d \n " , a ) ;
∗ p1+=3; / ∗ joue l e même r  l e que a+=3 ∗ /
p r i n t f ( " a = %d \n " , a ) ;
}

Exé ution :

a = 22
a = 25

Remarque. Les opérateurs & et * ont même priorité que les opérateurs unaires : !, ++, --. Dans une même
expression, les opérateurs unaires *, &, !, ++, -- sont évalués de droite à gau he.

6.2.3 Pointeurs et Tableaux


En C, il y a une relation étroite entre les pointeurs et les tableaux. Chaque opération sur les indi es d'un
tableau peut être exprimée à l'aide des pointeurs.

int t [10℄;
int ∗p ;

L'instru tion : p=t ; est équivalente à p=&t[0℄ ;


L'identi ateur t représente l'adresse de son premier élément, .a.d. &t[0℄.

t[0℄ t[1℄ ···

t←&t[0℄

De plus, après p=t ; on a :


6.2. POINTEURS 43

p+1 désigne t[1℄


p+2 désigne t[2℄

.
.
.
p+i désigne t[i℄
.
.
.

On peut dire aussi que p+i pointe vers t[i℄.

Remarques.
1. Puisque le nom d'un tableau t est l'adresse de son premier élément, on a :

*(t+1)7−→t[1℄
*(t+2)7−→ t[2℄
...
*(t+i)7−→ t[i℄
2. Attention : Il y a une dieren e essentielle entre un pointeur et le nom d'un tableau :
(a) Un pointeur est une variable. Don des opérations omme p=t ; ou p++ sont permises

(b) Le nom d'un tableau est en quelque sorte un pointeur onstant. Don t=p ; ou t++ sont impos-
sibles.
Exemple.
float A[20℄,X;
float *K;
...
K=A;
X=*(K+9); /* On met dans X A[9℄ */ Attention aux parenthèses
Le programme suivant opie les éléments positifs d'un tableau tab dans un tableau pos en utilisant le
formalisme pointeur :

#in lude < s t d i o . h>


int t a b [ 1 0 ℄ = { − 3 , 4 , 0 , − 7 , 3 , 8 , 0 , − 1 , 4 , − 9};
int p o s [ 1 0 ℄ ;
int I , J ; / ∗ i n d i e s ourants dans T e t POS ∗ /
main ( )
{
for ( J =0 , I =0 ; I <10 ; I ++)
i f ( ∗ ( t a b+I ) >0)
{
∗ ( p o s+J ) = ∗ ( t a b+I );
J++;
}
}

On peut par ourir les tableux en utilisant uniquement les pointeurs :


44 CHAPITRE 6. TABLEAUX ET POINTEURS

#in lude < s t d i o . h>


int t a b [ 1 0 ℄ = { − 3 , 4 , 0 , − 7 , 3 , 8 , 0 , − 1 , 4 , − 9 } ;
int p o s [ 1 0 ℄ ;
int ∗ p1 , ∗ p2 ,m;
main ( )
{
for ( p1=t a b , p2=p o s ; p1<t a b + 1 0 ; p1++)
i f ( ∗ p1 >0)
{
∗ p2=∗p1 ;
p2++;
}
m=p2−p o s ;
for ( p2=p o s ; p2<p o s+m; p2++)
p r i n t f ( "%d \n " , ∗ p2 ) ;
}

6.2.4 Transmission de paramètres par adresse


Soit le programme :

#in lude < s t d i o . h>


int a =1 ,b=−1;
void e h a n g e ( int ad1 , int ad2 )
{
int x;
x=ad1 ;
ad1=ad2 ;
ad2=x ;
}

main ( ) {
p r i n t f ( " avant appel a = %d \ t b = %d \n " , a , b ) ;
e hange ( a , b ) ;
p r i n t f ( " apres appel a = %d \ t b = %d \n " , a , b ) ;
}

Exé ution :

avant appel a = 1 b = -1
apres appel a = 1 b = -1

e hange n'ee tue pas de modi ation de ses paramètres ee tifs. On rappelle que par défaut, les paramètres
ee tifs d'une fon tion sont transmis par valeur.
6.2. POINTEURS 45

Solution : utiliser des arguments pointeurs et transmettre des adresses en paramètres ee tifs :

#in lude < s t d i o . h>


int a =1 ,b=−1;
void e h a n g e ( int ∗ p1 , int ∗ p2 )
{
int x;
x=∗p1 ;
∗ p1=∗p2 ;
∗ p2=x ;
}
main ( ) {
p r i n t f ( " avant appel a = %d \ t b = %d \n " , a , b ) ;
e h a n g e (&a ,& b ) ;
p r i n t f ( " apres appel a = = %d \ t b = %d \ n " , a , b ) ;

Cette fois- i, on obtient :

avant appel a = 1 b = -1
apres appel a = -1 b = 1

6.2.5 Tableaux à un indi e en arguments


1. Tableau de taille xe

On indique dans l'en-tête d'une fon tion qu'un argument est un tableau à une dimension de taille xe
de l'une des manières équivalentes suivantes :

type nom_fon tion(...,type nom[taille℄, ...)


type nom_fon tion(...,type nom[ ℄, ...)
type nom_fon tion(...,type *nom, ...)
Exemple : une fon tion qui remplit un tableau de 1

void f tn ( int t [10℄)


{
int i ;
for ( i =0; i < 1 0 ; i ++) t [ i ℄=1;
}

voi i 2 exemples d'appel de ette fon tion :

int t1 [ 1 0 ℄ , t2 [ 1 0 ℄ ;
...
f t n ( t1 ) ;
...
f t n ( t2 ) ;
...
46 CHAPITRE 6. TABLEAUX ET POINTEURS

2. Tableau dont le nombre d'éléments est variable

Lorsqu'un tableau à un indi e apparaît omme argument d'une fon tion le ompilateur n'a pas besoin
d'en onnaître la taille exa te. Dans e as il faut transmettre en plus la taille en paramètre ee tif.
Exemple : une fon tion qui al ule la somme des éléments d'un tableau quel onque en argument.

int som ( int t [ ℄ , int nb ) {


int s =0 , i ;
for ( i =0; i <nb , i ++) s=s+t [ i ℄ ;
return ( s ) ;
}

main ( ) {
int t1 [ 3 0 ℄ , t2 [ 1 5 ℄ ; t3 [ 1 0 ℄ ;
int s1 , s 2 ;
...
s 1=som ( t 1 , 3 0 ) ;
s 2=som ( t 2 , 1 5 ) + som ( t 3 , 1 0 ) ;
...
}
Chapitre 7

Gestion des  hiers


Ce hapitre est onsa ré à l'étude des fon tions qui permettent au programme d'é hanger des informations
ave des  hiers. Un  hier est un ensemble d'informations situé sur un support tel que disque dur, disquette,
... et .
On distingue deux sortes de  hiers :
• Fi hiers textes : un  hier vu omme assemblage de ara tères et pour lesquels les ara tères de ontrle
omme retour à la ligne sont interprétés en tant que tel lors de la le ture et de l'é riture.
• Fi hiers binaires : un  hier binaire est ara térisé par son ontenu qui peut être omposé d'objets de
type quel onque (int, double, tableau, et .)

7.1 Ouverture et fermeture d'un  hier


Pour traiter des données par l'intermédiaire des  hiers, il est né essaire de disposer de fon tions qui
permettent les  ouvrir  et de les fermerà partir d'un programme C.

7.1.1 La fon tion fopen


Cette fon tion ouvre un  hier, .a.d. le rend a essible à un programme. Sa syntaxe est :

fopen("nom-fi hier", "mode") ;

où :
mode spé ie le mode d'a ès au  hier (le ture, é riture, ...). Ce mode est diérent suivant le type de
 hier onsidéré.
Voi i les prin ipaux modes d'a ès :
"r" : Ouvrir un  hier existant en le ture
"w" : Ouvrir un  hier en é riture. ( réé s'il n'existe pas)
"a" : Ajouter des données à la n d'un  hier
fopen renvoie une valeur spé iale appelée ot de données : des informations sur le  hier rassemblées dans
une stru ture dont le type est FILE déni dans la bibliothèque stdio.h.

#in lude < s t d i o . h>


FILE ∗fl ; / ∗ l e ∗ d o i t ê t r e o l l é à haque v a r i a b l e

47
48 CHAPITRE 7. GESTION DES FICHIERS

d é l a r é e de type FILE ∗ /
main ( )
{
...
f l =f o p e n ( d a t a , " r " ) ; / ∗ on ouvre l e f i h i e r data en l e t u r e ,
l e f l o t ouvert e s t e s t s t o k é dans
l a v a r i a b l e p o i n t e u r f l ∗/
...
}

7.1.2 La fon tion f lose


Elle permet de fermer le ot qui a été asso ié à un  hier par la fon tion fopen. Sa syntaxe est :

f lose(flot) ;

où flot est le ot retourné par fopen orrespondant. La fon tion f lose renvoie un entier qui vaut 0 si
l'opération s 'est déroulé normalement et une valeur non nulle en as d'erreur.

#in lude < s t d i o . h>

main ( )
{
FILE ∗fl ;
...
f l =f o p e n ( d a t a , r ) ;
...
f lose ( fl ); / ∗ on ferme l e f l o t f l ∗ /
...
}

7.2 Fon tions de manipulation de  hiers


7.2.1 Les fon tion d'é riture/le ture formatées
• fprintf(...) : printf, permet d'é rire des données dans un  hier.
fon tion analogue à
fprintf(flot," haîne de ontrle",expr-1, ... ,expr-N)
où flot est le ot de données retourné par fopen. Les odes de format utilisés sont les mêmes que eux
de printf.
• fs anf(...) : fon tion analogue à s anf, permet de lire des données dans un  hier.
fs anf(flot," haîne de ontrle",arg-1, ... ,arg-N)
Les odes de format sont les mêmes que eux de s anf.

Exemple. Un programme qui é rit les ubes des 20 premiers entiers dans un  hier appelé result
7.2. FONCTIONS DE MANIPULATION DE FICHIERS 49

#in lude < s t d i o . h>


main ( )
{
FILE ∗ sortie ;
int i ;
s o r t i e =f o p e n ( r e s u l t , w ) ;
for ( i =0; i < 2 0 ; i ++)
fprintf ( sortie , le uble d e %i e s t %i n , i , i ∗i∗i );
f lose ( sortie );
}

Exemple. On lit 10 nombres réels sto kés dans un  hier data et on é rit leur somme dans le  hier result
#in lude < s t d i o . h>
main ( ) {
FILE ∗le t ,∗ sortie ;
int i ;
float x , s ;
l e t =f o p e n ( d a t a , r ) ;
s o r t i e =f o p e n ( r e s u l t , w ) ;
for ( i =0 , s =0; i < 2 0 ; i ++)
{
f s a n f ( l e t ,% f ,& x ) ;
s+=x ;
}
fprintf ( sortie , la somme des nombres e s t %f n , s ) ;
f lose ( le t );
f lose ( sortie );
}

7.2.2 Impression et le ture de ara tères


Similaires aux fon tions get har et put har, les fon tions fget et fput permettent respe tivement de
lire et d'é rire un ara tère dans un  hier.
− La fon tion fget retourne le ara tère lu dans le  hier :
fget (flot)
où flot est le ot retourné par fopen. Il est onseillé de dé larer en int la variable destinée à re evoir
la valeur de retour de fget .
− La fon tion fput é rit un ara tère dans un  hier :
fput ( ara tere,flot)
Exemple. Un programme qui lit ara tère par ara tère dans un  hier data ar et les é rit dans un  hier
datares et il s'arrête quand il ren ontre 'F'
#in lude < s t d i o . h>
main ( ) {
FILE ∗ fin , ∗ fout ;
50 CHAPITRE 7. GESTION DES FICHIERS

int ;

f i n =f o p e n ( d a t a a r , r ) ;
f o u t=f o p e n ( d a t a r e s , w ) ;
=f g e t ( f i n ) ;
while ( != ' F ' )
{
fput ( , fout ) ;
=f g e t ( f i n ) ;
}
f lose ( fin );
f los e ( fout ) ;
}

Vous aimerez peut-être aussi