Langage C

Mme khadija bouzaachane
Bref historique
Pourquoi utiliser
le langage C
Cycle de dveloppement du programme
Votre premier programme C
20/09/15
Programmer en langage C
Introduction : Bref historique
20/09/15
Introduction
Le langage C a t cr par Dennis Ritchie aux Bell

Telephone Laborateries en 1972: il a t conu pour
dvelopper le systme Unix.
En raison de sa puissance et de sa souplesse, le langage C
sest rapidement rpandue au-del des laboratoires Bell.
Les programmeurs ont commenc lutiliser pour crire
toutes sortes de programmes
Diverses organisations ont utilis leurs propres versions
du langage C. Consquence : limplmentation est devenu
un casse-tte pour les programmeurs.
Rponse ce problme : lAmerican National Standards
Institute(ANSI) form un comit en 1983 pour tablir le
C standard ANSI.
Introduction : Pourquoi utiliser le langage C
20/09/15
Introduction
Souple et puissant : Le langage C est utilis pour des projets

varis comme les systmes dexploitation, les traitements de
textes, les graphiques, les tableurs, les compilateurs pour
dautres langages.
Il existe un large choix de compilateurs et dutilitaires.
Avec la norme ANSI, le C est devenu un langage portable: un
programme C crit pour un type dordinateur(IBM) peut tre
compil pour tourner sur un autre systme avec trs peu ou
aucune modification.
Le langage C est modulaire: son code peut(et devrait) tre crit
sous forme de sous-programme appels fonctions. Si vous
passez des informations ces fonctions, vous obtenez un code
rutilisable.
C est un langage structur (offre plusieurs structures de
contrle) et typ (dclarations obligatoires).
Introduction : Cycle de dveloppement du

programme
Cration dun code source en utilisant un diteur

indiquent lordinateur les tches que vous voulez lui
faire excuter, il est cr laide dun diteur.
La plupart des systmes dexploitation contiennent un
diteur. Sous Unix vous pouvez utiliser, ed, ex, edit
emacs ou vi. Microsoft Windows vous offre le bloc-notes.
20/09/15
Introduction
Le code source est une srie de commandes qui
Introduction : Cycle de dveloppement

du programme
Compilation du code source

Votre ordinateur ne peut pas comprendre le code source. Il ne
Introduction
peut comprendre que des instructions binaires dans ce que

lon appelle du langage machine. Votre programme C doit tre
transform en langage machine pour pouvoir tre excut sur
votre ordinateur. Cette opration est ralise par un
compilateur qui transforme votre fichier code source en un
fichier contenant le code objet(les mmes instructions en
langage machine).
Chaque compilateur possde sa propre commande pour crer
le code objet.
Windows: C Microsoft, Turbo C, Turbo C++, Borland C, Borland C++.
Unix : utiliser la commande c.
Linux et Unix: la commande gcc.
20/09/15
Introduction : Cycle de dveloppement du

programme
Cration du fichier excutable

Une
20/09/15
Introduction
partie du langage C est constitue dune

bibliothque de fonctions contenant du code objet
destin des fonctions prdfinies. Ces fonctions sont
fournies avec votre compilateur. Si votre programme les
utilise, le fichier objet obtenu aprs compilation doit
tre complt par le code objet issu de la bibliothque de
fonctions. Cette dernire tape, appele liaison, fournit
le programme excutable (excutable signifie que ce
programme peut tre excut sur votre ordinateur)
Introduction : Cycle de dveloppement du programme
Programme source (.c)
Fichier en-tte (.h)

math .h
/*dclaration*/
Bibliothques prcompiles
(.lib)
Introduction
#include
#include <math.h>
..
Main()
{
..
}
..
Programme objet (.obj)
..
math.lib
Programme executable
(.exe)
20/09/15
Introduction : votre premier programme
Affichage
printf(Bonjour);
}
20/09/15
Bonjour
Introduction
#include<stdio.h>
Main()
{
Exemple
de programme en langage C
Structure dun programme en Langage C
Les mots-cls
Les types de base
Dclarations des variables simples
20/09/15
10
Exemple de programme en langage C

Elments de base du langage C
Programme principal
20/09/15
Bloc
#include <stdio.h>//standard input/output

#include <math.h>
#define NFOIS 5
main ()
{ int i;
float x, racx;
printf("Bonjour\n");
printf("je vais vous calculer %d racines carres\n",NFOIS);
for(i=0;i<NFOIS;i++)
{ printf("donnez un nombre:");
scanf("%f",&x);
if(x<0.0)
printf("le nombre %f ne possde pas de racine carre\n",x);
else
{ racx=sqrt(x);
printf("le nombre %f a pour racine carre :%f\n",x,racx);
}
}
printf("travail termin Au revoir");
}
11
main()
{ int i,a;
clrscr();
printf("Veuiller introduire un nombre:",a);
scanf("%d",&a);
for(i=a+1;i<=a+10;i++)
{
printf("%d\t",i);
}
getch();
#include<conio.h>
#include<stdio.h>
}
20/09/15
12

#include<conio.h>
#include<stdio.h>
#define a 4
main()
{
clrscr();
gotoxy(4,4);
printf("%d",a );
getch();
20/09/15
13
#include<stdio.h>
#include<conio.h>
main()
{ int i,n,j;
char T[20];
puts("entrer la taille:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("entrer
T[%d]=",i);
scanf("%c\n",&T[i]);
getch();
}
20/09/15
for(i=0;i<n;i++)
{
if(T[i]==T[i+1])
{
for(j=n;j>=i+2;j--)
T[j]=T[j-1];
n++;
T[i+1]='*';
}
}
for(i=0;i<n;i++)
printf("%c\t",T[i]);
getch();
}
14

Les directives destination du prprocesseur
#include <math.h>
#include <stdio.h>
#define NFOIS 5
Programme excut automatiquement avant la

compilation, il transforme le fichier source
partir dun certain nombre de directive
Il sagit de directive qui seront prises en compte avant la
traduction (compilation) du programme. Ces directives

doivent tre crites une par ligne, et il est prfrable de les
placer au dbut. Les deux premires directives demandent
dintroduire(avant compilation) des instructions(en
langage C) situes dans les fichier stdio.h et math.h. On
les appelles fichiers en-ttes.
La troisime directive dfinie une constante. Elle
demande de remplacer systmatiquement, dans toute la
suite du programme, le symbole NFOIS par 5
20/09/15
15

La fonction main()
est un bloc obligatoire dun programme C. Sa forme la plus simple
consiste saisir son nom, main, suivi de parenthse () vide et

dune paire daccolades {}. Lexcution du programme dbute la
premire instruction de main() et se termine avec la dernire
instruction de cette fonction.
La dfinition des variables

Une variable est un nom donn une zone mmoire pour stocker
les donnes en cours dexcution. En C une variable doit tre

dfinie avant son utilisation. Sa dfinition indique son nom au
compilateur et le type de donnes que lon pourra y stocker.
Sa dclarations est de la forme
Type nom_variable [=<valeur>];
Elle peut tre dclare lextrieur ou lintrieur de la fonction
main
20/09/15
16

Notion didentificateur
Un identificateur, comme son nom lindique, permet de
donner un nom une entit du programme (quil

sagisse dune variable ou dune fonction). Ils sont sujets
aux rgles suivantes :
1.
2.
3.
Ils sont forms dune suite de lettres (a `a z et A `a Z), de

chiffres (0 9) et du signe _. En particulier, les lettres
accentues sont interdites ;
le premier caractre de cette suite ne peut pas tre un chiffre ;
les identificateurs sont case-sensitive.
Ainsi, les noms var1, S_i, et InitDB sont des
identificateurs valides, tandis que i:j ou 1i ne le sont pas.
20/09/15
17

Pour crire des informations: la fonction printf
Linstruction printf("Bonjour\n"); appelle une fonction
prdifinie(printf) qui reoit un argument "Bonjour\n"

dlimiter par des guillemets pour dire que cest une
chane de caractres. La notation \n est
conventionnelle : elle reprsente un caractre de fin de
ligne, lorsquil est envoy lcran, elle provoque le
passage la ligne suivante.
Linstruction
printf("je vais vous calculer %d racines carres\n",NFOIS);
Ressemble la prcdente avec la diffrence quil reoit un
argument que lon nomme un format, cest comme un guide
qui prcise comment afficher les informations, dans notre
cas le code format %d prcise quil sagit dun entier.
20/09/15
18

Pour faire une rptition: linstruction for
En langage C, il existe plusieurs faon de raliser une
rptition, comme par exemple : for(i=0;i<NFOIS;i++), son

rle est de rpter le bloc dlimiter par les accolades, en
respectant les consignes suivantes :
Avant de commencer cette rptition raliser : i=0
Avant chaque nouvelle excution du bloc, examiner la condition:
i<NFOIS, si elle est satisfaite, excuter le bloc indiqu sa fin

raliser i++qui nest que i=i+1
Pour lire les informations: la fonction scanf

scanf("%f",&x): cette instruction nest quappel de la fonction
prdfinie scanf dont le rle est de lire une information au

clavier
%f: le format de la variable
&x: son adresse
20/09/15
19

Pour faire le choix: linstruction if
Les lignes
if(x<0.0)
1 printf("le nombre %f ne possde pas de racine carre\n",x);
else
{ racx=sqrt(x);
2 printf("le nombre %f a pour racine carre :%f\n",x,racx);
}
Constituent une instruction de choix base sur la

condition x<0.0, si cette condition est vrai, on excute
linstruction 1, si elle est fausse on excute
linstruction 2.
20/09/15
20

Les commentaires
/* un commentaire dune ligne*/
Int a, b, c; /* commentaire sur une partie dune ligne*/
/* un commentaire
Qui stend sur plusieurs ligne*/

//cette ligne est en commentaire
Conseils:
Ajouter de nombreux commentaires dans le code
source de votre programme, surtout sil contient des

instructions ou fonctions qui pourraient tre difficile
comprendre. Vous gagner un temps prcieux quand
vous aurez le modifier.
20/09/15
21
Les mots-cls
20/09/15
Un certains nombres de mots sont rservs pour le langage

C, a vit comme identificateurs, la liste exhaustive est la
suivante:
22
Les types de base : Les caractres
char c1 = a; // Dclaration dune variable c1 de type char
// a laquelle on affecte la valeur a

// A noter lutilisation du simple quotte
20/09/15
On utilise le mot-cl char pour dsigner une variable

de type char.
char Il sagit en fait dun entier cod sur 8
bits interprt comme un caractre utilis sur la
machine (il sagit en gnral du code ASCII de ce
caractre).
Exemple :
23
20/09/15
Le tableau suivant donne la liste des principaux codes

ASCII en dcimal
24
Caractres particuliers
les principaux sont rsums dans le tableau suivant :
Chanes de caractres
Les chanes de caractres sont vues comme un pointeur
sur des caractres et sont donc de type char *.

*
Exemple:
Il existe un certain nombre de caractres particuliers dont
char * chaine = "Hello World !";// une chaine de caractre
// noter lutilisation du double

// quotte
20/09/15
25
Les types de base : Entiers

Le type int peut tre prcis par des attributs :
De longeur :
short pour des entiers courts(gnralement de 8 ou 16 bits)
long pour des entiers longs(gnralement de 32 ou 64bits)
La longeur par dfaut est gnralement de 16 ou 32bits
De domaine
signed pour les entiers relatifs
unsigned pour les entiers naturels positifs ou nuls
20/09/15
26
/* dclaration la plus courante dune variable de type int */

int a = 14; // la variable a est initialise la valeur 14
/* Utilisation des prcisions (cas le plus gnral)*/
short int b; // b est cod sur 16 bits
int c; // c est cod sur 16 ou 32 bits
long int d; // d est cod sur 32 bits
// la possibilit de lcriture suivante dpend du compilateur
On utilise le mot-cl int.

int
Exemple :
long long int e; // e est cod sur 64 bits.
/* Prcision du signe */
unsigned long int n; //n est un entier non sign sur 32 bits
20/09/15
27

Le tableau suivant regroupe les types entiers standards
avec quelques informations supplmentaires :
20/09/15
28

Constante entire: donne inchange qui ne peut
varier pendant lexcution dun programme
Dclaration : #define Max 100
Elle se prsente sous forme dcimale, octale ou

hexadcimal
dcimale (criture en base 10) : cest lcriture usuelle.
Ex : 372 ;
octale (base 8) : on commence par un 0 suivi de
chiffres octaux. Ex : 0477 ;
hxadcimale (base 16) : on commence par 0x (ou 0X)
suivis de chiffres hxadcimaux (0-9, a-f). Ex : 0x5a2b,
0X5a2b, 0x5A2b.
20/09/15
29
Les types de base : Les flottants
Exemple : double Pi = 3,14159;
Le tableau suivant donne des informations pour chaque

type flottant.
20/09/15
On distingue trois types de flottants : float,

float double et
long double.
double
30
Les types de base : Les flottants

Une constante relle reprsente un nombre virgule
flottante(de type float ou double) sous forme
dcimale ou exponentielle.
Exemple :
20/09/15
31
Les types de base : Le type void

Toute variable C est type, de mme que toute
valeur de retour dune fonction. Mais il peut arriver
quaucune valeur ne soit disponible pour exprimer
lide de aucune valeur, pour cela on utilise le
mot-cl void.
void Ce type est utilis pour la dclaration
de fonctions qui nont pas de valeur de retour.
20/09/15
32
Les variables et les constantes sont les donnes

principales manipules par un programme.
Les dclarations introduisent les variables, fixent leur
type et parfois aussi leur valeur de dpart(initialisation);
Syntaxe de dclaration:
int x,y;
short compteur;
float prix,salaire;
double m;
char s;
20/09/15
33

Initialisation des variables
En C, il est possible dinitialiser les variables la
dclaration
Exemples:
int max=123;
char tab=c;
En utilisant lattribut const, la valeur dune variable
ne change pas au cours du programme: cest une

constante.
Exemple:
Const int max=765;

Const char newline=\n;
20/09/15
34
Le mot-cl typedef
Le mot-cl typdef permet de crer un synonyme
pour un type de donne existant. Par exemple
linstruction :
typedef int entier;
Cre le synonyme entier pour int. Vous pouvez ainsi

utiliser entier pour dfinir des variables de type int,
comme dans lexemple suivant:
entier compte;
20/09/15
35
Exercices
Quel type de variable convient le mieux pour stocker

les valeurs suivantes:
unsigned int age;
unsigned int poids;
Le poids
float rayon=3;
Le rayon dun cercle
long salaire_annuel;
Salaire annuel
float cout=29,95;
Le prix dun article
const int
note_max=100; #define
La note la plus haute dun test
note_max 100;
La temprature
float temperature;
Le gain dune personne
long gain=30000;
La distance dune toile en kilomtre double distance;
Lge dune personne
20/09/15
36
Exercices
Quels sont les noms de variables correctes :

a) 123variable
b) X
c) Score_totale
d) Poids_en_#s
e) One.0
Grand-cout
g) RAYON
h) rayon
i) Cela_est_une_variable_pour_stocker_la_largeur
f)
20/09/15
37
Dfinition
de variables
dfinition du domaine de valeur de cette variable et les
oprations lgales sur cette variable ; = grce au type.

rservation de lespace mmoire ncessaire au support
de la variable lors de lexcution ; = grce au type et la
classe mmoire.
initialisation de la variable laide dune constante dont
le type correspond celui de la variable ; = en faisant
suivre le nom par un symbole daffectation = et une valeur
compatible avec la variable.
association dune dure de vie la variable qui permet
lutilisation dans certaines parties du programme(rgles de
visibilit). = grce la classe mmoire et au lieu de
dfinition.
20/09/15
dfinition de variables sont couverts par le langage

C:
38
Dfinition de variables : classes mmoires
global
cette classe est celle des variables dfinies en dehors

dune fonction. Ces variables sont accessibles toutes les fonctions.
La dure de vie des variables de type global est la mme que celle
du programme en cours dexcution.
Local ou auto : cette classe comprend lensemble des variables
dfinies dans un bloc. Cest le cas de toute variable dfinie
lintrieur dune fonction. Lespace mmoire rserv pour ce type
de variable est allou dans la pile dexcution. Cest pourquoi elles
sont appeles aussi auto c..d automatique car lespace mmoire
associ est cr lors de lentre dans la fonction et il est dtruit lors
de la sortie de la fonction. La dure de vie des variables de type
local est celle de la fonction dans laquelle elles sont dfinies.
20/09/15
Une dfinition de variable est lassociation dun identifiant un

type et la spcification dune classe mmoire. La classe
mmoire sert expliciter la visibilit dune variable et son
implantation en machine. Les classes mmoire sont :
39

Static ce qualificatif modifie la visibilit de la variable, ou son
implantation :
dans le cas dune variable locale il modifie son implantation en attribuant
une partie de lespace de mmoire globale pour cette variable. Une
variable locale de type statique a un nom local mais a une dure de vie
gale celle du programme en cours dexcution.
dans le cas dune variable globale, ce prdicat restreint la visibilit du
nom de la variable lunit de compilation. Une variable globale de type
statique ne peut pas tre utilise par un autre fichier source participant
au mme programme par une rfrence avec le mot rserv extern.
extern ce qualificatif permet de spcifier que la ligne correspondante
nest pas une tentative de dfinition mais une dclaration. Il prcise
les variables globales (noms et types) qui sont dfinies dans un autre
fichier source et qui sont utilises dans ce fichier source.
20/09/15
40
Register ce qualificatif permet dinformer le compilateur que

les variables locales dfinies dans le reste de la ligne sont
utilises souvent. Le prdicat demande de les mettre si possible
dans des registres disponibles du processeur de manire
optimiser le temps dexcution. Le nombre de registres
disponibles pour de telles demandes est variable selon les
machines. Il est de toute faon limit (4 pour les donnes, 4 pour
les pointeurs sur un 680X0). Seules les variables locales peuvent
tre qualifies register.
20/09/15
41

Dclaration/dfinition
Classe mmoire
Int a;
main ()
{
Int b;
Static char c;
}
extern int b ;
Dfinition dune variable global
Int coucou(const int c)

{
register int a ;
if (b == 1)
}
20/09/15
Dfinition dune variable local main

dclaration dune variable qui est dfinie dans un autre
fichier(rien voir la variable b de main), variable globale
externe
paramtre constant, variable locale
variable locale coucou, mettre en registre si possible
rfrence la variable b externe
42
Instructions, Expressions et
Les structures de
Oprateurs
contrle
La
rcursivit
Les conversions de types
Principales fonctions dentres-sorties standard
20/09/15
43
Instructions, Expressions et Oprateurs
Les instructions :
Une
Les blocs:
La syntaxe du langage C
instruction reprsente une tche accomplir par

lordinateur. En langage C, on crit une instruction par ligne et elle
se termine par un point virgule( lexception de #define et
#include). Par exemple:
x=2+3;
est une instruction daffectation. Elle demande lordinateur
dajouter 2 et 3 et dattribuer le rsultat la
variable x.
Un bloc (ou instructions composes) est un groupe dinstructions
entre accolades:
{
printf("Hello");
printf("world!");
{printf("Hello");
printf("world!");}
}
20/09/15
44
Les expressions:
Lexpression simple est constitue dune seule variable, dune
constante. Par exemple:

PI //constante dont la valeur est dfinie par #define
Taux //variable
Une expression est une combinaison doprateurs et

doprandes(variables, constantes). Autrement tout ce qui
reprsente une valeur numrique. Une expression gnre
toujours un rsultat dun type bien dfini quon appellera le
type de lexpression.
Les expressions Simples
Les expressions complexes

Les expressions complexes sont constitues dexpressions plus
simples avec des oprateurs. Par exemple:

2+8
8+(5*taux)+(taux*taux)/cout
20/09/15
45
Les oprateurs: oprateur daffectation

daffectation est le signe(=). Dans le
programme C : x=y;
ne signifie pas x gal y. Elle indique lordinateur
daffecter la valeur de y x. Cette instruction doit tre
compose dune expression droite du signe gale, et
dun nom de variable gauche de ce signe:
variable=expression;
Exemple:
Loprateur
x=6+(y=4+5);
a=b=2;
20/09/15
46
Les oprateurs: oprateur daffectation

var += exp ; quivalent var = var + (exp) ;
var -= exp ;
var = var - (exp) ;
var *= exp ;
var = var * (exp) ;
var /= exp ;
var = var / (exp) ;
var %= exp ;
var = var % (exp) ;
Attention :
pas despace entre loprateur op et le gal =,
x *= y+1 est quivalent x = x*(y+1) et pas x = x*y+1.
20/09/15
Opration et affectation combines op=
47
Oprateurs arithmtiques
20/09/15
48
Remarques :
Les
oprandes de ces oprateurs arithmtiques peuvent

appartenir tout type arithmtique seul loprateur % requiert
des types entiers.
Le rsultat dune division dentiers est aussi un entier, Exemple :
6 / 4
// Resultat: 1
6 % 4
// Resultat: 2
6.0 / 4.0 // Resultat: 1.5
20/09/15
49
Les oprateurs unaires oprent sur une seule variable ou
oprande.
Concernant lincrmentation pr/postfixe, voici un petit
exemple: Supposons que la valeur de N soit gale 3 :
Incrmentation postfixe : X = N++ ;
Rsultat : N = 4 et X = 3
Incrmentation prfixe : X = ++N ;
Dcrmentation postfixe : X = N-- ;
Dcrmentation prfixe : X = --N ;
20/09/15
Remarques
50
Oprateurs de comparaison
renvoie la valeur 0 (faux) ou 1 (vraie). Il faut que les

oprandes soient du mme type arithmtique (ou des
pointeurs sur des objets de mme type).
Attention : il ne faut pas confondre loprateur dgalit
(==) avec celui daffectation (=).
Les diffrents oprateurs de comparaison sont dtaills
dans le tableau ci-dessous.
20/09/15
Toute comparaison est une expression de type int qui
51
20/09/15
52
20/09/15
#include <stdio.h>
void main ()
{
int x=14,y=1; // x est diffrent de y
if (x = y)
//erreur!!! il faudrait crire if (x == y)
printf("x est gal y (%i=%i)\n",x,y);
else
printf("x est diffrent de y (%i!=%i)\n",x,y);
}
53
Oprateurs logiques
20/09/15
Les oprateurs logiques, permettent de combiner le rsultat de

plusieurs expressions de comparaison en une seule expression
logique. Les oprandes des oprateurs logiques peuvent tre
nimporte quel scalaire. Toute valeur diffrente de 0 est interprte
comme vraie (et 0 correspond faux). Comme pour les expressions
de comparaisons les expressions logiques renvoient une valeur
entire (0 =faux ; 1=vraie).
Remarque :
les oprateurs && et || valuent les oprandes de gauche droite et
le rsultat est connu ds loprande de gauche. Ainsi, loprande de
droite nest value que si celle de gauche est vraie dans le cas de
loprateur && (respectivement fausse dans le cas de loprateur ||).
Exemple:
(i < max) && (f(14) == 1), la fonction f nest appele que si i < max.
54

Oprateurs logiques
Exemples
Lexpression : 32 && 40 vaut 1

Lexpression : !65.34 vaut 0
Lexpression : !!0 vaut 0
20/09/15
55
Oprateurs bit bit
20/09/15
Les oprateurs bits bits noprent que sur des entiers.

Les oprandes sont interprtes bits par bits (le bit 1
correspondant une valeur vraie, 0 est considr
comme une valeur fausse).
56
Oprateurs bit bit

dcimale et binaire) :
20/09/15
Exemples: chaque oprande est fournie sous forme
57
Oprateurs daccs la mmoire : &

expression qui dsigne un objet ou une expression.
&x renvoie ladresse mmoire de x et est donc
un pointeur vers x.
20/09/15
Loprande de loprateur dadresse & doit tre une
58
Autres oprateurs
Oprateur squentiel ( , )
Exprime des calculs successifs dans une mme expression. Le type
et la valeur de lexpression sont ceux du dernier oprande.

Exemple : x = 5 , x + 6. Lexpression a pour valeur 11
Oprateur conditionnel (? :)
<expression> ? <expr1>: <expr2>
<expression> est value. Si sa valeur est non nulle, alors la valeur
de <expr1> est retourne. Sinon, cest la valeur de <expr2> qui est

renvoye.
Exemple : max = a > b ? a : b
si a est le plus grand, alors affectation max du contenu de a sinon
affectation du contenu de b
20/09/15
<expr1> , <expr2>,., <exprN>
59
Autres oprateurs
20/09/15
60
Priorit et associativit des oprateurs

expression, les oprateurs respectent certaines lois de
priorit et dassociativit.
Exemples
La multiplication a la priorit sur laddition
La multiplication et laddition ont la priorit sur laffectation.
Tableau des oprateurs et priorit

La priorit est dcroissante de haut en bas dans le tableau.
La rgle dassociativit sapplique pour tous les oprateurs dun
Lors de lvaluation des diffrentes parties dune
mme niveau de priorit. (pour une associativit de gauche droite

et pour une associativit de droite gauche).
Dans une expression, les parenthses forcent la priorit.
20/09/15
61
Instructions, Expressions et
Oprateurs
Oprateurs
()
+ - ++ -- !
< <=
==
&&
||
?:
10
= += -= *= /= %=
20/09/15
Associativit
>
>=
!=
Priorit
62
Exercices
1)
Soit les dclarations suivantes :
Donner le type et la valeur de chacune des expressions suivantes

a) n+q
b) n+x
c) n%p+q
d) n<p
e) q+3 *(n<p)
x*(q==2)
g) x*(q=2)
h) (q-2)&&(n-10)
i) q&&n
f)
20/09/15
a) long 12
b) float 11,75
c) long 4
d) int 0
e) long 5
f) float 1,75
g) int 0
h) int 1
Int n=10, p=4;

Long q=2;
Float x=1.75;
63
Exercices
-1 si n est ngatif
0 si n est nul
1 si n est positif
n ? (n>0 ? 1: -1) : 0
20/09/15
2. n tant de type int, crire une expression qui prend la

valeur :
64
Les structures de contrle

On appelle structure de contrle toute instruction servant
contrler le droulement de lenchanement des
instructions lintrieur dun programme, ces instructions
peuvent tre des instructions conditionnelles ou itratives.
Parmi les structures de contrle, on distingue :

structures de choix
if.else (choix conditionnel)
switch (choix multiple)
structures rptitives ou itrative ou boucle
for
while
dowhile
Branchement inconditionnel
Break, goto, continue
20/09/15
65
Les structures de contrle : if-else

La construction if-else (si-sinon) est la construction
Forme 1
if (expression) instruction-1;
la forme if est ici dans sa forme la plus simple. Si expression est

vraie, instruction-1 est excute. Si expression est fausse,
instruction-1 est ignore.
20/09/15
logique de base du langage C qui permet d'excuter un

bloc d'instructions selon qu'une condition est vraie ou
fausse.
Syntaxe
66

Syntaxe
Forme 2
Forme 3
if (expression-1)
instruction-1;
else if (expression-2)
instruction-2;
else
instruction-3;
Les instructions if sont imbriques. Si expression-1 est vraie, instruction-1
est excute. Dans le cas contraire expression-2 est value si cette dernire est
vraie instruction-2 est excute. Si les deux expressions sont fausses, cest
instruction-3 qui est excut
20/09/15
if (expression) instruction-1;
else instruction-2;
Si expression est vraie, instruction-1 est excute, sinon cest instruction-2 qui est
excute.
67
Exemples:
if (salaire >45.000)
tax=0.30;
else
tax=0.25;
Exemple 2
if (age <18)
printf(mineur);
else if (age <65)
printf(adulte);
else
printf(personne age);
20/09/15
Exemple 1
68

#include <stdio.h>
void main ()
{ int i;
printf("Tapez un nombre entier positif ou negatif: ");
scanf("%d", &i);
if (i<0) {
i=-i;
printf("J'ai remis i une valeur positive.\n");
}
else {
printf("Vous avez tap un nombre positif.\n");
}
}
20/09/15
69
Les structures de contrle : Switch

Linstruction switch est linstruction de contrle la plus
souple du langage C. Elle permet votre programme
dexcuter diffrentes instructions en fonction dune
expression qui pourra avoir plus de deux valeurs.
On lappelle aussi linstruction daiguillage. Elle teste

si une expression prend une valeur parmi une suite
de constantes, et effectue le branchement
correspondant si cest le cas.
20/09/15
70
Syntaxe
20/09/15
switch (<condition>) {
case <valeur 1> : <action 1>; break;
case <valeur 2> : <action 2>; break;
default : <action n>;

}
71
Remarques :
expression est value ;
sil existe un nonc case avec une constante qui est gale la
valeur de lexpression, le contrle est transfr linstruction

qui suit cet nonc;
si un tel case nexiste pas, et si nonc default existe, alors le
contrle est transfr linstruction qui suit lnonc default ;
si la valeur de lexpression ne correspond aucun nonc case
et sil ny a pas dnonc default, alors aucune instruction nest
excute.
Le fonctionnement de cette instruction est le suivant :
Attention.
Lorsquil y a branchement russi un case, toutes les
instructions qui le suivent sont excutes, jusqu la fin du bloc

ou jusqu une instruction de rupture (break).
20/09/15
72
20/09/15
#include<stdio.h>
void main() {
int a,b,d;
char operateur;
Printf( Entrez un oprateur (+, -,* ou /):);
Scanf(%c,&operateur);
Printf( Entrez deux entiers:);
Scanf(%d,&a); Scanf( %d,&b);
switch(operateur){
case- : y=a-b; printf(%d,y);break;
case+ : y=a+b; printf(%d,y); break;
case* : y=a*b; printf(%d,y); break;
case/ : y=a/b; printf(%d,y); break;
default : printf(oprateur inconnu\n);break;
}
}
73
Les structures de contrle : while

Linstruction while permet de rpter des instructions,
tant qu'une condition est vrifie.
Syntaxe
while (condition)
une-instruction;
Forme 2
while (condition) {
Des instructions;
}
Forme 1
20/09/15
74
Les structures de contrle :while
La boucle while fonctionne de la faon suivante:

La condition est value,
2. si cette condition est fausse, linstruction while se termine,
3. si la condition est vraie les instructions sont excutes
4. lexcution reprend ltape 1.
1.
Exemple
#include <stdio.h>
void main ()
{ int i=1, N;
printf("N=\n"); scanf("%d",&N);
while (i <= N) {
printf("%d ", i); i = i+1;}
printf("\n");
}
20/09/15
75
Les structures de contrle :while
while imbriqu
20/09/15
#define MAX 4
int i=0,j;
while (i < MAX ) {
j=0;
while (j < MAX ) {
printf(" position : %d \t %d\n",i,j);
j++;
}
i++;
}
76
Les structures de contrle : do-while

L'instruction do-while, excute le bloc d'instructions
tant quune condition reste vraie. Dans cette boucle le
test de la condition seffectue la fin de la boucle.
Syntaxe
do
une-instruction;
while (condition)
Forme 2
do {
Des instructions;
} while (condition)
20/09/15
Forme 1
77
Les structures de contrle : do-while
Exemple :
20/09/15
#include <stdio.h>
#define MAX 4
void main()
{
int i=MAX;
do {
printf("Valeur de i : %i\n",i);
i++;
} while (i < MAX);
}
78
Les structures de contrle : for
for( [expression1] ; [expression2] ; [expression3 ])
{
liste dinstructions
}
Les crochets [ et ] signifient que leur contenu est facultatif
Dans la construction de for :
expression1 : effectue les initialisations ncessaires avant
lentre dans la boucle;
expression2 : est le test de continuation de la boucle ; le test
est valu avant lexcution du corps de la boucle;
expression3 : est value la fin du corps de la boucle.
20/09/15
A linstar des instructions while et do-while linstruction for

permet dexcuter un certain nombre de fois un bloc dune ou
plusieurs instructions.
Syntaxe:
79
Remarques
souvent plusieurs initialisations spares par des
virgules.
For(i=0,j=1,k=5;.;)
Les expressions expression1 et expression3 peuvent
tre absente(les points-virgules doivent apparatre.

i=1; for(;i<=5;) {printf(%d fois\n,i);i++;}
Lorsque expression2 est absente, lexpression
En pratique, expression1 et expression3 contiennent
correspondante est considre comme vraie. Par

consquent, for(;;) est une boucle infinie
20/09/15
80
Remarques :par dfinition linstruction de for
est quivalente
expression1;
while(expression2)
{
instructions;
expression3;
}
20/09/15
for ( expression1 ; expression2 ; expression3 )

{
liste dinstructions
}
81
Les structures de contrle :for
Exemples
Programme pour calculer la somme de 1 100
Programme pour calculer la factorielle dun entier n:
Int n, i,fact;
For(fact=1,i=1;i<=n;i++)
fact*=i;
Printf(%d!= %d\n,n,fact);
20/09/15
Int n,total;
For(total=0,n=1;n<=100;n++)
total+=n;
Printf(la sommes des nombres de 1 100 est %d\n,total);
82
Les structures de contrle : break, goto et

continue
Instruction break
On a vu le rle de linstruction break; au sein dune
instruction de branchement multiple switch.

Linstruction break peut, plus gnralement, tre
employe lintrieur de nimporte quelle boucle (for ;
while ; do-while). Elle permet labandon de la structure
et le passage la premire instruction qui suit la
structure.
En cas de boucles imbriques, break fait sortir de la
boucle la plus interne.
20/09/15
83

continue
Instruction break : exemple
20/09/15
Evaluation:
Dbut tour 1
Bonjour
Dbut tour 2
bonjour
fin tour 2
Dbut tour 3
Bonjour
Aprs la boucle
#include <stdio.h>
void main( )
{ int i;
for (i = 1 ; i<=10 ; i++){
printf(dbut tour %d\n ,i) ;
printf( bonjour\n);
if (i ==3) break ;
printf(" fin tour%d\n", i) ;
}
printf(" aprs la boucle\n") ;
}
84

continue
Linstruction continue peut tre employe lintrieur
dune structure de type boucle (for ; while ; do-while ).

Elle produit labandon de litration courante et fait
passer directement litration suivante dune boucle.
Linstruction continue concerne la boucle la plus
proche.
20/09/15
Instruction continue
85

continue
Instruction continue
Exemple :
20/09/15
Evaluation:
Dbut tour 1
Dbut tour 2
Dbut tour 3
Dbut tour 4
Bonjour
Dbut tour 5
Bonjour
Void main()
{ int i;
for(i=1;i<=10;i++)
{ printf(dbut tour %d\n ,i) ;
if (i <4) continue ;
printf( bonjour\n);
}
}
86
Les structures de contrle : break,

continue et goto
Instruction goto
quelconque du programme.
Void main()
{ int i;
for(i=1;i<=10;i++)
{ printf(dbut tour %d\n ,i) ;
printf( bonjour\n);
if (i ==3) goto sortie ;
printf( fin tour%d\n", i);
}
Sortie:printf (" aprs la boucle\n") ;
}
20/09/15
Evaluation:
Dbut tour 1
Bonjour
fin tour 1
Dbut tour 2
bonjour
fin tour 2
Dbut tour 3
Bonjour
Aprs la boucle
Elle permet le branchement en un emplacement
87
La rcursivit
Rcursivit directe: une fonction comporte, dans sa
dfinition, au moins un appel elle-mme.

Rcursivit croise: lappel dune fonction entrane
celui dune autre fonction qui, son tour, appelle la
fonction initiale(le cycle pouvant dailleurs faire
intervenir plus de deux fonctions)
20/09/15
Le langage C autorise des appels de fonctions. Celleci peut prendre deux aspects:
88
La rcursivit
Exemple
20/09/15
#include <stdio.h>
int fact (int x)
{ printf (Computing fact %d\n, x) ;
if (x == 1)
return 1 ;
else
return x * fact (x-1) ;
}
Void main (){
printf (5! = %d\n, fact (5)) ;
}
89
Rgle de Conversion Implicite

Convertir les lments de la partie droite dune expression
La conversion de type est un outil trs puissant, elle

doit donc tre utilise avec prudence. Le compilateur
fait de lui-mme des conversions lors de lvaluation
des expressions. Pour cela il applique des rgles de
conversion implicite. Ces rgles ont pour but la perte
du minimum dinformation dans lvaluation de
lexpression. Ces rgles sont les suivantes:
daffectation dans le type de la variable ou de la constante le

plus riche.
Faire les oprations de calcul dans ce type.
Puis convertir le rsultat dans le type de la variable affecte.
20/09/15
90
1.
2.
3.
4.
5.
si lun des deux oprandes est du type long double alors le

calcul doit tre fait dans le type long double ;
sinon, si lun des deux oprandes est du type double alors le
calcul doit tre fait dans le type double ;
sinon, si lun des deux oprandes est du type float alors le
calcul doit tre fait dans le type float ;
si lun des deux oprandes est du type unsigned long int
alors le calcul doit tre fait dans ce type ;
si lun des deux oprandes est du type long int alors le
calcul doit tre fait dans le type long int ;
20/09/15
La notion de richesse dun type est prcise dans la norme

[ISO89]. Le type dans lequel le calcul dune
expression deux oprandes doit se faire est donn par les
rgles suivantes :
91
long double
double
Float
unsigned long long
long long
unsigned long
long
unsigned int
int
20/09/15
Hirarchie des conversions arithmtiques habituelles

est la suivante:
92
Conversion implicite
dune expression) dans un autre type avant de lutiliser
par une conversion implicite. Cette opration est
appele cast.
cast Elle se ralise de la manire suivante :
(type) expression
Prenons pour exemple lexpression : i = (int) f + (int) d ;
f et d sont convertis en int, puis additionns. Le rsultat
entier est rang dans i.
20/09/15
Il est possible de forcer la conversion dune variable (ou
93
Exemple
li = f + i ;
i est transform en float puis additionn f,

le rsultat est transform en long et rang dans li.
d = li + i ;
i est transform en long puis additionn li,

le rsultat est transform en double et rang dans d.
i=f+d;
f est transform en double, additionn d,

le rsultat est transform en int et rang dans i.
20/09/15
float f ; double d ; int i ; long li ;
94
Principales fonctions dentres-sorties

standard
Il sagit des fonctions de la librairie standard stdio.h
utilises avec les units classiques dentres-sorties,
qui sont respectivement le clavier et lcran.
Ces fonctions sont:
Putchar
Puts
Printf
Getchar
scanf
20/09/15
95

standard
La fonction getchar
caractre partir du clavier. La syntaxe dutilisation de
getchar est la suivante : var=getchar();
Notez que var doit tre de type char. Exemple :
#include <stdio.h>
void main() {
char c;
printf("Entrer un caractre:");
c = getchar();
printf("Le caractre entr est %c\n",c);
}
20/09/15
La fonction getchar permet la rcupration dun seul
96

standard
La fonction putchar
lordinateur. putchar constitue alors la fonction
complmentaire de getchar. La syntaxe dutilisation est
la suivante : putchar(var);
o var est de type char. Exemple :
#include <stdio.h>
Void main() {
char c;
printf("Entrer un caractre:");
c = getchar();
putchar(c);
}
20/09/15
permet laffichage dun seul caractre sur lcran de
97

standard
La fonction puts
Cette fonction affiche, sur stdout, la chane de
caractres ch puis positionne le curseur en dbut de

ligne suivante. puts retourne EOF en cas derreur.
Exemple :
#include <stdio.h>
void main() {
char * toto = "on est super content!";
puts(toto);
}
20/09/15
Syntaxe : puts(ch);
98

standard
La fonction printf est une fonction dimpression formate, ce
qui signifie que les donnes sont converties selon le format

particulier choisi. Sa syntaxe est la suivante :
printf("chane de contrle", expression1, . . . , expressionn);
La chane de contrle contient le texte afficher et les
spcifications de format correspondant chaque expression
de la liste. Les spcifications de format ont pour but
dannoncer le format des donnes visualiser. Elles sont
introduites par le caractre %. Le i-me format de la chane
de contrle sera remplac par la valeur effective de
expressioni.
20/09/15
La fonction dcriture lcran formatte printf
99

standard
Les diffrents formats de la fonction printf

format
Conversion en
criture
%d
int
dcimale signe
%ld
long int
dcimale signe
%u
unsigned int
dcimale non signe
%lu
unsigned long
dcimale non signe
%o
unsigned int
Octale non signe
%lo
unsigned long
Octale non signe
%x
unsigned int
Hxadcimal non signe
%lx
unsigned long
Hxadcimal non signe
20/09/15
100

standard

format
Conversion en
criture
%f
float
dcimale virgule fixe
%lf
Long float
dcimale virgule fixe
%e
Double
dcimale notation exponentielle
%le
Long double
dcimale notation exponentielle
%g
Double
dcimale, reprsentation la plus courte

parmi %f et %e
%lg
Long double
dcimale, reprsentation la plus courte

parmi %lf et %le
%c
unsigned char
caractre
%s
char*
Chane de caractres
20/09/15
101

standard

Exemple
printf("|% d|\n",14);
| 14|
printf("|% d|\n",-14); |-14|
printf("|%x|\n",0x56ab); |56ab|
printf("|%X|\n",0x56ab); |56AB|
printf("|%o|\n",14); |16|
printf("|%#o|\n",14); |016|
printf("|%10d|\n",14);
| 14|
printf("|%f|\n",1.234567890123456789e5);
printf("|%.4f|\n",1.234567890123456789e5);
20/09/15
|123456.789012|
|123456.7890|
102

standard

Exemple
printf("|%e|\n",1.234567890123456789e5); |1.234568e+05|
printf("|%.4e|\n",1.234567890123456789e5); |1.2346e+05||
printf("|%.4g|\n",1.234567890123456789e-5); |1.235e-05|
printf("|%.4g|\n",1.234567890123456789e-3); |0.001235|
printf("|%.8g|\n",1.234567890123456789e5); |123456.79|
20/09/15
103

standard
La fonction de saisie scanf

saisies au clavier, dans le format spcifi. Ces donnes
sont stockes aux adresses spcifies par les arguments
de la fonction scanf (on utilise donc loprateur
dadressage & pour les variables scalaires). scanf
retourne le nombre de valeurs effectivement lues et
mmorises .La syntaxe est la suivante :
scanf("chane de contrle", arg1, . . . , argn);
La chane de contrle indique le format dans lequel les
donnes lues sont converties. Comme pour printf, les
conversions de format sont spcifies par un caractre
prcd du signe %.
20/09/15
La fonction scanf permet de rcuprer les donnes
104

standard
Exemple
#include <stdio.h>
void main()
{
int i ;
printf("entrez un entier sous forme hexadecimale i = ");
scanf("%x",&i);
printf("i = %d\n",i);
}
20/09/15
La fonction de saisie scanf
105
Les
Enumration
Les Tableaux
Les Structures
Les Unions
20/09/15
106
Les numrations
Les numrations permettent de dfinir un type pour des
variables qui ne sont affectes qua un nombre fini de
valeurs. Un objet de type numration est dfini par le
mot-clef enum et un identificateur de modle, suivi de la
liste des valeurs que peut prendre cet objet :
enum modele {constante1, constante2,. . . ,constanten} ;
En ralit, les objets de type enum sont reprsents

comme des int. Les valeurs possibles constante1,
constante2,. . . ,constanten sont codes par des entiers de
0 n-1.
20/09/15
Les types drivs
107
Les numrations
20/09/15
Les types drivs
Le type enum boolean, Dans lexemple suivant,

associe lentier 0 la valeur FALSE et lentier 1 la
valeur TRUE.
#include <stdio.h>
enum boolean {FALSE, TRUE};
void main ()
{
enum boolean b1 = TRUE;
printf("b = %d\n",b1);
}
108
Les tableaux
Un tableau reprsente un ensemble demplacements mmoire qui
portent le mme nom et contiennent le mme type de donnes.

Chacun de ces emplacements est un lments du tableau.
On appelle tableau une variable compose de donnes de mme
type, stocke de manire contigu en mmoire(les uns la suite des
autres).
Un tableau est une suite des lments de mme taille. Par
consquent, la taille(en octet) du tableau est :
type de donne*le nombre dlments.
20/09/15
Les types drivs
Il est souvent ncessaire de mmoriser un grand nombre

dlments identiques. Il serait par exemple fastidieux de
dclarer 1000 variables relles reprsentant 1000 valeurs.
Pour cela on utilise des tableaux.
Dfinition
109
Les tableaux
Les tableaux une dimensions

Un tableau une dimension ne possde quun index. Un
<type simple> Nom_du_tableau[nombre_elements];

Type simple : dfinit le type dlment que contient le tableau
Nom du tableau : est le nom quon donne au tableau, ce nom suit
les mmes rgles quun nom de variable.
Nombre_elements : est une expression constante entire positive,
qui exprime la taille du tableau.
Les types drivs
index est le nombre entre crochets qui suit le nom du

tableau. Il indique le nombre dlments du tableau.
Dclarations
Exemple:
char caractere[12];
int entier[10];
float reel[8];
20/09/15
110
Les tableaux

Initialisation la dclaration
<type > Nom_du_tableau[nombre_elements]={c1,c2,cn};
Ou c1, c2,cn sont des constantes dont le nombre ne doit pas
dpasser le nombre _elements.
Exemple
#define Mois 12
int tableau[12];
int tab[4] ={100,200,300,400;}\\ initialisation
char voyelles[6]={a,e,i,o,u,y};
20/09/15
Les types drivs
Il est possible dinitialiser le tableau la dfinition :
111
Les tableaux

Accs aux composantes dun tableau
Pour accder un lment du tableau, il suffit de donner le nom
Les types drivs
du tableau, suivi de lindice de llment entre crochets :

Nom_du_Tableau [indice]
O indice est une expression entire positive ou nulle.
Un indice est toujours positif ou nul ;
Lindice du premier lment du tableau est 0 ;
Lindice du dernier lment du tableau est gal au nombre
dlments 1.
Exemples :
short A[5] = {12 , 23 , 34 , 45 , 56}; // A[0] = 12 ; A[1] = 23 ; A[2] = 34 ;
// A[3] = 45 ; A[4] = 56 ;
for( i = 0 ; i< 5 ; i++ )
printf(A[%d] = %d \t,i,A[i));
20/09/15
//Affichage des lments
// du tableau A
112
Les tableaux

Remarque
comme une simple variable, on peut :
la lire : scanf("%d", &TAB[i] ); // TAB[i] sera initialis par un
// entier saisi depuis la clavier

lcrire : printf("TAB[%d] = %d", i , TAB[i] ); //Le contenu de TAB[i]
//sera affich sur cran
la passer en argument une fonction : TAB[i] = pow(TAB[i],2);
// = TAB[i] 2
Les types drivs
Chaque lment ( TAB[i] ) dun tableau ( int TAB[20] ) est manipul
Pour initialiser un tableau (TAB1) par les lments dun autre tableau
(TAB2) : vitez dcrire TAB1 = TAB2 (incorrect)

On peut par exemple crire :
for( i = 0 ; i < taille_tableau ; i++ )
TAB1[i] = TAB2[i];
20/09/15
113
Les tableaux
20/09/15
Les types drivs
Les tableaux deux dimensions

En C, un tableau multidimensionnel est considr
comme un tableau dont les lments sont eux mme
des tableaux.
Un tableau deux dimensions se dclare donc de la
manire suivante :
int mat[10][20];
En faisant le rapprochement avec les mathmatiques,
on peut dire que mat est une matrice de 10 lignes et
de 20 colonnes.
114
Les tableaux
Les tableaux deux dimensions

On accde un lment du tableau par lexpression mat[i][j].
Pour initialiser un tableau plusieurs dimensions la
20/09/15
Les types drivs
compilation, on utilise une liste dont chaque lment est une

liste de constantes :
#include <stdio.h>
#define L 3 //nombre de lignes
#define C 2 //nombre de colonnes
short tab[L][C] = {{1, 2}, {14, 15}, {100, 200}};
void main() {
int i, j;
for (i = 0 ; i < L; i++) {
for (j = 0; j < C; j++)
printf("tab[%d][%d]=%d\n",i,j,tab[i][j]);}}
115
Les tableaux
Modification des lments dun tableau pass en

paramtre
20/09/15
Les types drivs
#include <stdio.h>
void print_tab(int tab[], int nb_elem) {...}
/* incrmente chaque composantes du tableau */
void incr_tab(int tab[], int nb_elem) {
int i;
for (i=0; i < nb_elem; i++) tab[i]++;}
#define TAILLE 4
void main() {
int t[TAILLE] = {1, 2, 3, 4};
incr_tab(t, TAILLE);
print_tab(t, TAILLE);}
116
Les structures
Les types drivs
Une structure est une suite finie dobjets de types

diffrents. Qui sont regroup au sein dune mme
entit.
Contrairement aux tableaux, les diffrents lments
dune structure noccupent pas ncessairement des
zones contigus en mmoire.
Chaque lment de la structure, appel membre ou
champ, est dsign par un identificateur.
struct enreg {
int numero;
int qte;
float prix;
};
20/09/15
117
Les structures
Lutilisation pratique dune structure se droule

de la faon suivante :
mme. Le modle gnral de cette dclaration
est le suivant :
struct nom_structure {
type_1 membre_1 ;
type_2 membre_2 ;
...
type_n membre_n ;
};
20/09/15
Les types drivs
1. On commence par dclarer la structure elle-
118
Les structures
20/09/15
Les types drivs
2. Pour dclarer un objet de type structure correspondant au modle

prcdent, on utilise la syntaxe :
struct nom_structure identificateur_objet ;
Ou bien, si le modle na pas encore t dclar au pralable :
struct nom_structure {
type_1 membre_1 ;
type_2 membre_2 ;
...
type_n membre_n ;
} identificateur_objet ;
3. On accde aux diffrents membres dune structure grce
loprateur membre de structure, not .. Le i-me membre de objet
est dsign par lexpression :
identificateur_objet.membre_i
119
Les structures
Struct enreg art1,art2;

Art1.numero=15;
/* dclaration*/
/*affectation*/
Printf(%f,art1.prix);
/* affiche la valeur du champ prix*/
Les types drivs
Chaque champ dune structure peut tre manipul

comme nimporte quelle variable de type
correspondant. Voici quelques exemples utilisant la
structure enreg:
Scanf(%f,&art2.prix);
/*lit une valeur qui sera affect

au champ prix de la structure art2 */
Art1.numero++;
20/09/15
/* incrmente de 1 la valeur du champ

numero de la structure art1*/
120
Les structures
Il possible daffecter une structure le contenu dune

structure dfinie partir du mme modle. Par
exemple nous pouvons crire:
Une telle affectation remplace :

art1.numero = art2.numero;
art1.qte = art2.qte;
art1.prix = art2.prix;
Les types drivs
art1=art2;
Initialisation dune structure au moment de sa

dclaration :
Struct enreg art1={100,290,3000};
20/09/15
121
Les structures
Structure comportant des tableaux:

Struct personne{ char nom[30];
employe.heures[4];/*5me lments du tableau heures*/
Les types drivs
char prenom[20];
float heures[31];
} employe, courant;
/*heures: nbre dheures du travail dans chaque jours du
mois*/
employe.nom[0];/* premier caractre du champ nom*/
Initialisation:
Struct personne ={Dupont, julea, {8, 7, 8, 6, 8, 0,0, 8}}
20/09/15
122
Les structures
Tableaux de structures
Les types drivs
struct point { char nom;

int x;
int y;
};
struct point courbe[50];
Cette structure sert reprsenter un point dun plan qui
serait dfini par son nom(caractre) et ses deux
coordonnes.
courbe[i].nom; courbe[i].x; courbe[i].y; /*reprsente le nom
du point de rang i, la valeur du champ x et la valeur du champ y*/
Initialisation :
Struct point courbe[50]={{A,10,25},{M,13,34},{R,2,6}};
20/09/15
123
Les structures
Structures comportant dautres structures:

Supposant que lintrieur de la structure employe et courant
struct date { int jour;
int mois;
int annee;};
Struct personne{ char nom[30];
char prenom[20];
float heures[31];
struct date date_embauche;
struct date date_poste;
} employe, courant;
20/09/15
Les types drivs
nous ayant besoin dintroduire deux dates: la date dembauche

et la date dentre. Si ces dates sont elles-mmes des structures
comportant trois champs correspondant au jour et lanne,
nous pouvons alors procder aux dclarations suivantes :
124
Les structures
La notation :
Employe.date_embauche.annee
Courant.date_embauche
Reprsente la date dembauche de la structure courant,

et nous pouvons faire laffectation:
Courant.date_embauche=employe.date_poste;
20/09/15
Les types drivs
Reprsente lanne dembauche correspondant la

structure employe. Il sagit dune valeur de type int.
125
Les structures
Exercice:
Ecrire un programme qui :
structure du type point dfini comme suit:

Struct point{
int num;
frloat x;
float y;
}
Le nombre dlments du tableau sera fix par une instruction
#define.
Les types drivs
lit au clavier des informations dans un tableau de
Affiche lcran lensemble des informations
prcdentes.
20/09/15
126
Les unions
20/09/15
Les types drivs
Il est parfois ncessaire de manipuler des variables

auxquelles on dsire affecter des valeurs de type
diffrents. Supposons que l'on dsire crire un package
mathmatique qui manipulera des nombres qui seront
implments par des int, tant que la prcision des
entiers de la machine sera suffisante et qui passera
automatiquement une reprsentation sous forme de
flottants ds que ce ne sera plus le cas. Il sera
ncessaire de disposer de variables pouvant prendre
soit des valeurs entires, soit des valeurs flottantes.
Ceci peut se raliser en C, grce au mcanisme des
unions.
127
Les unions
Une dfinition d'union la mme syntaxe qu'une
dfinition de structure, le mot cl struct tant
simplement remplac par le mot cl union.
Exemple:
char c;
int i;
}
union nombre{
Les types drivs
Union partage{
int i;
float f;
}
20/09/15
128
Les unions
on dclarera une variable p de type union partage par :

union partage p;
union nombre n;
cette variable pourra possder soit une valeur entire,

soit une valeur flottante, mais pas les deux la fois.
20/09/15
Les types drivs
cette variable pourra possder soit une valeur entire,

soit un caractre, mais pas les deux la fois.
on dclarera une variable n de type union nombre par
129
La
mmoire de votre ordinateur

Cration dun pointeur
Dfinition
Dclaration
Initialisation
Oprations lmentaires sur les pointeurs
Pointeurs et tableaux
Pointeurs et tableaux deux dimensions
Arithmtiques des pointeurs
Allocation dynamique
Allocation dynamique: Fonctions malloc et free
20/09/15
130
La mmoire de votre ordinateur
rate
Processeur
Mmoire(RAM)
100
Bus
Un octet = 8 bits
20/09/15
Adresses
1000
1004
1008
1009
1010
1014
1018
Les pointeurs
La comprhension des pointeurs, repose sur le

fonctionnement du mmoires de votre ordinateur.
Tout dabord un bref rappel sur le fonctionnement des
ordinateurs. Un ordinateur comporte un processeur et de
la mmoire. Les deux sont connects par un bus, c'est-dire un ensemble de lignes lectriques
131
La mmoire de votre ordinateur
20/09/15
Les pointeurs
La mmoire vive de votre ordinateur est constitue de

milliers demplacements mmoire rangs de faon
squentielle. Chaque emplacement a une adresse unique,
comprise entre 0 et une valeur maximale qui dpend de la
quantit de mmoire installe sur votre ordinateurs.
Lorsquune variable est dclare, le compilateur rserve un
emplacement mmoire (une srie de bits quon ne lit/crit
pas un par un mais par paquets de huit, ce que l'on appelle
un octet (byte).) avec une adresse unique pour stocker
cette variable(quon peut relire plus tard) .
Le compilateur associe ladresse au nom de la variable.
Quand le programme utilise le nom de la variable, il
accde automatiquement lemplacement mmoire
correspondant
132
La cration dun pointeur
20/09/15
Les pointeurs
Dans la figure prcdente nous avons dclar une variable

rate et nous lavons initialis 100. Le compilateur
rserv un emplacement mmoire ladresse 1004, quil
associe au nom de la variable.
Ladresse de cette variable rate est un nombre, ce qui nous
permet de lutiliser comme nimporte quel autre nombre
en langage C.
Si vous connaissez ladresse dune variable, vous pouvez
crer une autre variable pour y stocker ladresse de la
premire.
La premire tape consiste dclarer la variable dans
laquelle on stockera ladresse de rate.
133
La cration dun pointeur
Soit p_rate la variable dans laquelle on stockera

ladresse de rate, daprs le schma ci-dessous un
emplacement mmoire a t rserv pour p_rate
?
p_rate
1002
1003
1004
1005
100
rate
Ltape suivante consiste stocker ladresse de rate

dans la variable p_rate, celle-ci reprsente
maintenant lemplacement mmoire de la variable
rate
1001
1002
1003
1004 1005
1004
p_rate
20/09/15
Les pointeurs
1001
100
rate
134
Dfinition
Un pointeur est une variable qui contient l'adresse d'une

autre variable.
Dclaration
On dclare un pointeur par linstruction :
type *nom_du_pointeur ;
O: type est le type de la variable pointe,

lidentificateur nom_du_pointeur est le nom de la variable
pointeur et * est loprateur qui indiquera au compilateur
que cest un pointeur.
Exemple :
int *p; float *p_float; char *p_char;
On dira que :p est un pointeur sur une variable du type int ,
ou bien p peut contenir l'adresse d'une variable du type int
*p est de type int, cest lemplacement mmoire point par p.
20/09/15
Les pointeurs
135
Initialisation
Dclarer un pointeur nest pas suffisant, si vous ne
le faites pas pointer sur une variable, il est inutile.
Un pointeur doit contenir ladresse dune variable
en utilisant loprateur &, quand il est plac avant
le nom de la variable, loprateur dadresse renvoie
ladresse de cette variable. Son initialisation est une
instruction de la forme : pointeur=&variable;
Les pointeurs
20/09/15
136
Initialisation
Exemple 1 :
int A, B, *P; /*supposons que ces variables occupent
20/09/15
Les pointeurs
la mmoire partir de ladresse 1000 */

A = 10;
B = 50;
P = &A ;
// se lit : mettre dans P ladresse de A
B = *P ;
/* se lit : mettre dans B le contenu de
la variable pointe par P */
*P = 20;
/*mettre la valeur 20 dans la variable
point par P*/
P = &B;
// P pointe sur B
137
Exemple 1:
20/09/15
Les pointeurs
void main()
{ int v=12;
int u=10;
int *vP; /*pointeur sur int*/
vP = &v; /*affectation du pointeur */
u = *vP;
printf(u=%d v=%d\n,u,v);
*vP = 25;
printf(u=%d v=%d\n,u,v);
printf(*vP=%d,*vP);
}
138
Exemple 2 :
mmoire partir de ladresse 1000*/

// pour effacer lcran<conio.h>
clrscr( );
p = &a;
printf(Entrer une valeur : );
scanf(%f ,p); // on saisie la valeur 12.4
Les pointeurs
#include <stdio.h>
#include <conio.h>
Void main( )
{ float a , *p; /*supposons que ces variables sont reprsentes en
printf(\nAdresse de a = %d Contenu de a = %f ,p,*p);

*p += 0.4;
printf(a = %f
*p = %f
, a,*p);
getch( ); // pour lire un caractre <conio.h>}
20/09/15
139

Loprateur & : adresse de : permet dobtenir
ladresse dune variable.
Loprateur * : contenu de : permet daccder au
contenu dune adresse.
Si un pointeur P pointe sur une variable X, alors *P
peut tre utilis partout o on peut crire X.
Exemple :
Les pointeurs
int X=1, Y, *P Aprs linstruction, P = &X ; On a :

Y = X + 1
X += 2
++X
X++
20/09/15
quivalente
quivalente
quivalente
quivalente
Y = *P + 1
*P += 2
++ *P
(*P)++
140
Exemple :
#include <stddef.h>
int *t, x , *r;
short y = 10 , *pt = &y;
t = NULL ; /* Correct */
t = 0 ; /* Correct */
x=0;
t = x ; /* Incorrect ! bien que x vaille 0 */
r = &x ;
t = r ; /* Correct : p et q pointe sur des variables de mme type*/
t = pt ; /* Incorrect : p et pt pointe sur des variable de type diffrent */
20/09/15
Les pointeurs
Le seul entier qui puisse tre affect un pointeur dun type

quelconque P est la constante entire 0 dsigne par le
symbole NULL dfini dans <stddef.h>.
On dit alors que le pointeur P ne pointe nulle part.
141
Exercices
Trouvez les erreurs dans les suites dinstruction

suivantes :
b) p = x est incorrect. Pour que

p pointe sur x :p = &x
c) q = p incorrect. q et p deux
pointeurs sur des types
diffrent
Les pointeurs
a) int *p , x = 34; *p = x
b) int x = 17 , *p = x; *p = 17
c) double *q; int x = 17 , *p;
p = &x; q =p;
d) int x, *p; &x = p;
a) *p = x est incorrect parce

que le pointeur p nest pas
initialis
d)&x = p incorrect. &x nest pas

une variable (lvalue) et par
consquent ne peut pas
figurer gauche dune
affectation.
20/09/15
142
le nom T du tableau est un pointeur constant sur le premier lment
(1er entier) du tableau

T et &T[0] contiennent ladresse du premier lment (1er entier) du
tableau.
Les pointeurs
En C, il existe une relation trs troite entre tableaux et pointeurs.

Ainsi, chaque opration avec des indices de tableaux peut aussi tre
exprime laide de pointeurs. En effet, le nom dun tableau
reprsente ladresse de son premier lment :
Tableau une dimension (int T[N]) :
Tableau deux dimensions( int T[N][M]) :

le nom T est un pointeur constant sur le premier tableau dentiers
T[i] est un pointeur constant sur le premier lment (1er entier) du
ime tableau.
T et T[0] contiennent la mme adresse mais leur manipulation nest
pas la mme puisquils ne reprsentent pas le mme type de
pointeur.
20/09/15
143
Adressage et accs aux composantes dun

tableau une dimension
En dclarant un tableau A de type int (int A[N]) et un
20/09/15
Les pointeurs
pointeur P sur des variables entire (int *P), linstruction

P = A cre une liaison entre le pointeur P et le tableau A
en mettent dans P ladresse du premier lment de A (de
mme P = &A[0]).
A partir du moment o P = A, la manipulation du
tableau A peut se faire par le biais du pointeur P. En effet
p
pointe sur A[0]
*p dsigne A[0]
p+1 pointe sur A[1]
*(p+1) dsigne A[1]
..
p+(N-1)
pointe sur A[N-1] *(p+N-1) dsigne A[N-1]
144
Exemple ( Lecture et Affichage dun tableau

matrialis par un pointeur)
20/09/15
Les pointeurs
#include stdio.h
#define N 10
void main()
{ float t[N] , *pt ;
int i ;
printf("Entrez %d entiers\n", N) ;
pt = &t[0] ; /* ou pt = t */
for (i = 0 ; i<N; i++)
scanf("%f", pt+i) ;
/* pt+i pointe sur t[i] */
printf("\n Tableau lu : \n") ;
for (i = 0 ; i<N ; i++)
printf("%7.2f", *(pt+i)) ; /* *(pt+i) quivalente pt[i]*/
}
145
Exemple ( Lecture et Affichage dun tableau

20/09/15
Les pointeurs
/* Autre Solution sans dclarer la variable i */

#include <stdio.h>
#define N 10
void main()
{ float T[N] , *pt ;
printf("Entrez %d entiers\n", N) ;
for (pt = T ; pt<T+N; pt++)
scanf("%f", pt) ;
printf("\nTableau lu : \n") ;
for (pt = T ; pt<T+N; pt++)
printf("%7.2f", *pt) ;
}
146
Pointeurs et tableaux deux dimensions
p
pointe sur A[0][0] et * p
dsigne A[0][0]
p+1
pointe sur A[0][1] et * ( p + 1 )
dsigne A[0][1]
..
p+N
pointe sur A[1][0] et * ( p + N )
dsigne A[1][0]
p+N+1
pointe sur A[1][1] et * ( p + N + 1 )
dsigne A[1][1]
..
p + M * N-1 pointe sur A[M-1][N-1] et * ( p + M * N -1 ) dsigne
A[M-1][N-1]
20/09/15
Les pointeurs
En dclarant une matrice A de type int (int A[M][N]) et un

pointeur P sur des variables entires (int *P),
linstruction P = A[0] cre une liaison entre le pointeur P et la
matrice A en mettent dans P ladresse du premier lment de la
premire ligne de la matrice A ( P = &A[0][0]). A partir du
moment o P = A[0], la manipulation de la matrice A peut se
faire par le biais du pointeur P. En effet :
147
Exemple ( Lecture et Affichage dune matrice

20/09/15
Les pointeurs
#include <stdio.h>
#define M 4
#define N 10
void main()
{ short A[M][N] ;
short *pt ;
int i, j ;
/* lecture dune matrice */
pt = &A[0][0] ;
/* ou bien pt = A[0] ; */
for (i = 0 ; i<M ; i++)
{
printf("\t ligne n %d\n", i+1) ;
for (j = 0 ; j<N ; j++)
scanf("%i", pt + i * N + j ) ;
} for (i = 0 ; i<M ; i++)
{ for (j = 0 ; j<N ; j++)
printf("%d", *( pt + i * N + j ) ) ;
printf("\n") ; }}
148
Affectation par un pointeur sur le mme type :

Soient P1 et P2 deux pointeurs sur le mme type de
Addition et soustraction dun nombre entier :

Si P pointe sur llment A[i] dun tableau, alors :
Les pointeurs
donnes.
Laffectation : P1 = P2 ; fait pointer P1 sur le mme
objet que P2.
P+n pointe sur A[i+n] et P-n pointe sur A[i-n]
20/09/15
149
20/09/15
Les pointeurs
Incrmentation et dcrmentation dun pointeur :

Si P pointe sur llment A[i] dun tableau, alors aprs
linstruction :
P++ ; P pointe sur A[i+1]
P += n ; P pointe sur A[i+n]
P-- ; P pointe sur A[i-1]
P -= n ; P pointe sur A[i-n]
Comparaison de deux pointeurs :
On peut comparer deux pointeurs de mme type par :
<, >, <=, >=, == ou !=
La comparaison de deux pointeurs qui pointent dans le
mme tableau est quivalente la comparaison des
indices correspondants.
150
Autres dclarations des pointeurs :
20/09/15
Les pointeurs
En C, il existe dautres dclarations des pointeurs. En effet :

Tableau de pointeurs :
int *Tab[20] ;
dclare un tableau Tab de 20 pointeurs dentiers.
Pointeur de tableaux :
int (*pt)[30] ;
dclare un pointeur pt sur des tableaux de 30
composantes.
Pointeur de pointeurs :
int **pt ;
dclare un pointeur pt qui pointe sur des pointeurs
dentiers.
151
La dclaration dun tableau dfinit un tableau statique
(il possde un nombre fig demplacements). Il y a
donc un gaspillage despace mmoire en rservant
toujours lespace maximal prvisible.
Il serait souhaitable que lallocation de la mmoire
dpend du nombre dlments saisir. Ce nombre ne
sera connu qu lexcution : cest lallocation
dynamique.
Les pointeurs
20/09/15
152
Fonction dallocation dynamique de la mmoire

Bibliothque <stdlib.h>
char *malloc(taille) ;
Chacune des fonctions malloc, calloc ou realloc, prend une
zone dune taille donne dans lespace mmoire libre

rserv pour le programme (appel tas ou heap) et
affecte ladresse du dbut de la zone une variable
pointeur.
Sil ny a pas assez de mmoire libre allouer, la fonction
renvoie le pointeurNULL.
20/09/15
Les pointeurs
//allocation dun bloc

char *calloc(taille, sizeof(type)) ;//allocation & initialisation dun
//bloc
char *realloc(char *, taille); //modification de la taille dun bloc
void free(char *) ;
//libration dun bloc
153
malloc
<pointeur> = <type> malloc(<taille>);
<pointeur>
<taille> est la taille, en octets, de la zone mmoire allouer
dynamiquement, <taille> est du type unsigned int, donc on
ne peut pas rserver plus de 65536 octets la fois
La fonction malloc retourne ladresse du premier
Les pointeurs
<type> est un type pointeur dfinissant la variable point par
octet de la zone mmoire alloue. En cas dchec, elle

retourne NULL.
20/09/15
154
free
Si on na plus besoin dun bloc de mmoire rserv
20/09/15
Les pointeurs
dynamiquement par malloc, alors on peut le librer

laide de la fonction free.
free(<pointeur>);
Libre le bloc de mmoire dsign par le pointeur
<pointeur>
155
Exemple (Allocation dynamique, Saisie et

Affichage dun tableau )
20/09/15
Les pointeurs
#include <stdio.h>
#include <stdlib.h>
void main()
{short *pt;
int N , i;
printf("Entrez la taille N du tableau \n") ;
scanf("%d", &N) ;
pt = ( short * ) malloc( N * sizeof( short ) );
if (pt == NULL)
{printf("Mmoire non disponible") ;
system("pause");
}
156
Exemple (Allocation dynamique, Saisie et

Affichage dun tableau )
Les pointeurs
printf("Saisie du tableau : ");

for ( i = 0 ; i < N; i++)
scanf("%d", pt + i ) ;
printf("Affichage du tableau ") ;
for ( i= 0 ; i < N; i++)
printf("%d\t", *( pt + i ) ) ;
free( pt );
}
20/09/15
157
Annexe A:
Explication de lexemple 1
Les pointeurs
20/09/15
158
Annexe A:
Gestion dynamique des tableaux

EXEMPLE :
20/09/15
Les pointeurs
/* Dclaration d'un pointeur sur des entiers p et de la taille du

tableau N */
int* p=NULL;
int N;
/* Saisie de la taille du tableau par l'utilisateur */
scanf ("%d",&N);
/* Allocation dynamique de la zone mmoire occupe par le
tableau */
p = (int*)malloc (N*sizeof(int));
159
Pointeurs et structures
Les pointeurs membres dune structure

Un pointeur qui est membre dune structure se dclare
Struct data {
int *valeur;
int *taux;
} premier;
Les pointeurs
de la mme faon quun pointeur qui ne lest pas, en

utilisant loprateur indirect(*), exemple:
Soit cout et interet de variable de type int tel que :

int cout, interet;
Linitialisation du pointeur valeur et taux suit la syntaxe
suivante :
premier.valeur=&cout;// (*premier.valeur=cout;)
premier.taux=&interet; // (*premier.taux=interet;)
20/09/15
160
Les pointeurs vers une structure

Soit la structure personne dfinie par:
Struct point{
On dclarera une variable de type pointeur vers cette
Les pointeurs
int num;
float x;
float y;
structure de la faon suivante :

struct point *p;
Pour initialiser ce pointeur, il faut dclarer une structure
sur le modle struct point, sur laquelle il va pointer :

Struct point pnt;
p=&pnt;
20/09/15
161
Les pointeurs vers une structure

Pour accder aux membres de la structure point, on utilise soit
loprateur (.) :
Les pointeurs
(*p).num=1;
(*p).x=1.2;
(*p).y=2.5;
soit (->) comme suit:

p ->num=1;
p ->x=1.2;
p ->y=2.5;
20/09/15
162
Pointeurs et tableaux de structures

Soit la structure dfinie par:
Nous pouvons dclarer un tableau appartenant au type part

struct part data[50];
Nous pouvons ensuite dclarer un pointeur vers une structure de

type part, et linitialiser pour pointer sur la premire structure du
tableau data:
Les pointeurs
struct part{
int nombre;
char nom[10];
};
struct part *p_part;

p_part=&data[0];// ou bien crire p_part=data;
Nous obtenons un tableau de structures de type part et un pointeur

vers le premier lment du tableau. On affiche le contenu du premier
lment avec linstruction:
printf( %d %s , p_part->nombre , p_part ->nom);
20/09/15
163
Pointeurs et tableaux de structures :exemple
20/09/15
Les pointeurs
#include<stdio.h>
#define max 4
Struct part{
int nombre;
char nom[10];
}data[Max]={1,smith,
2, jones,
3, Adams,
4,Wilson
};
Struct part *p_part;
int count;
void main(){
P_part=data;
For(count=0;count<Max;count++)
{ printf(A ladresse %d : %d %s\n,p_part,p_part->nombre,p_part->nom);
p_part++;}}
164
Dfinition
Exemple
de dfinition et dutilisation dune fonction en C

Exemple de fonction sans rsultat
Le cas des fonctions sans paramtres
Rgles
Une fonction peut en appeler une autre
En langage C, les paramtres sont transmis par valeur
Passage des paramtres par adresse
Passage de tableau en paramtre
Passage de structure en paramtre
Fonctions rcursives
Fonctions prdfinies : math.h
20/09/15
165
Dfinition
Une fonction est un bloc de code C indpendant, rfrenc

par un nom, qui ralise une tche prcise et qui peut
renvoyer une valeur au programme qui la appele :
Une fonction est rfrence par un nom: ce nom est unique et en
20/09/15
Les fonctions
lintroduisant dans la source de votre programme, vous pouvez

excuter le code de la fonction. une fonction peut tre appele par
une autre fonction.
Une fonction est indpendante : une fonction peut effectuer avec
ou sans changes avec une autre partie du programme.
Une fonction ralise une tche particulire : cela peut tre lenvoi
dune ligne de texte vers limprimante, un tri, ou le calcul dune
racine carre.
Une fonction peut renvoyer une valeur au programme appelant:
Quand ce programme appelle la fonction, le code de cette fonction
est excut. Ces instructions peuvent renvoyer une information au
programme.
166
Dfinition : Syntaxe
liste-d'instructions
}
Les fonctions
type identificateur ( liste de-dclarations-de-paramtres )

{
liste-de-dclarationsoption(optionnel)
type identificateur ( liste-de-dclarations-de-paramtres );

porte le nom de prototype de fonction.
20/09/15
167
Dfinition : Smantique
20/09/15
Les fonctions
Type :est le type de la valeur rendue par la fonction ;

identificateur :est le nom de la fonction ;
Liste de dclarations-de-paramtres : est la liste
(spars par des virgules) des dclarations des
paramtres formels.
La liste-de-dclarationsoption : permet si besoin, de
dclarer des variables qui seront locales la fonction,
elles seront donc inaccessibles de l'extrieur.
La liste-d'instructions: est l'ensemble des instructions
qui seront excutes sur appel de la fonction. Parmi
ces instructions, il doit y avoir au moins une
instruction du type : return expression ;
168
Dfinition: Appel dune fonction
Syntaxe :
Expression :
Smantique :
Les expressions de liste-d'expressions sont values,
puis passes en tant que paramtres effectifs la

fonction de nom identificateur, qui est ensuite excute.
La valeur rendue par la fonction est la valeur de
l'expression appel de fonction.
20/09/15
Les fonctions
identificateur ( liste-d'expressions )
169
Exemple de dfinition et dutilisation dune fonction en C
20/09/15
Les fonctions
#include <stdio.h>
/***** le programme principal (fonction main) *****/
void main()
{
/* dclaration de fonction fexple */
float fexple (float, int, int) ; /* prototype de la fonction cube */
float x = 1.5 ;
float y, z ;
int n = 3, p = 5, q = 10 ;
/* appel de fexple avec les arguments x, n et p */
y = fexple (x, n, p) ;
printf ("valeur de y : %e\n", y) ;
/* appel de fexple avec les arguments x+0.5, q et n-1 */
z = fexple (x+0.5, q, n-1) ;
printf ("valeur de z : %e\n", z) ;
}
170
20/09/15
Les fonctions
/*************** la fonction fexple ****************/

float fexple (float x, int b, int c)
{
float val ; /* dclaration dune variable "locale" fexple
val = x * x + b * x + c ;
return val ;
}
171
20/09/15
Les fonctions
#include<stdio.h>
/* dclaration de la fonction cube*/
long cube(long x); /* prototype de la fonction cube */
/****************************************************/
long input, reponse;
void main()
{
printf("entrez une valeur entire : ");
scanf("%ld",&input);
reponse=cube(input);
printf("\n\n le cube de %ld est %ld\n", input, reponse);
}
172
/* dfinition de la fonction */
20/09/15
Les fonctions
long cube(long x) /* en-tte de la fonction cube*/

{
/*attention pas de ; */
long x_cube; /* variable locale la fonction cube */
x_cube= x*x*x;
return x_cube;
}
173
Exercice
20/09/15
Les fonctions
Quels seront les rsultats fournis par ce programme :

main()
{ int arrondi (float) ; /* prototype de la fonction arrondi */
float v1 = 1.6, v2 = 2.8 ;
int p ;
p = arrondi (v1) ; printf (%d\n, p) ;
p = arrondi (v2) ; printf (%d\n, p) ;
printf (%d %d\n, arrondi(v1+v2), arrondi(v1) + arrondi(v2) ) ;
}
int arrondi (float r)
{ float y ;int n ;
y = r + 0.5 ;
n=y;
return n ;
}
174
Autre exemple
/*dfinition dune fonction, nomme max, qui fournit en
rsultat la plus grande des trois valeurs entires reues en
paramtres*/
20/09/15
Les fonctions
int max (int a, int b, int c)

{ int m ;
m=a;
if ( b>m ) m = b ;
if ( c>m ) m = c ;
return m ;
}
175
Autre exemple
20/09/15
Les fonctions
/*programme principal*/
void main()
{ int max (int, int, int) ; /* prototype de notre fonction max */
int n, p, q, m ;
n=3;p=5;q=2;
m = max (n, p, q) ;
printf (max de %d %d %d : %d\n, n, p, q, m) ;
m = max (5*n, n+p, 12) ;
printf (valeur : %d\n , m) ;
}
176

Soit la dfinition de fonction nomme optimist :
Son en-tte montre quelle comporte un paramtre entier

(nomm nfois) ; cette fois, il est prcd du mot void qui
indique que la fonction ne fournit pas de rsultat.
Si lon examine les instructions du corps de la fonction, on
constate quelles affichent un certain nombre de fois le
mme texte : il fait beau. Pour effectuer son travail, notre
fonction a eu besoin dune variable locale (i).
20/09/15
Les fonctions
void optimist (int nfois)

{ int i ;
for (i=0 ; i<nfois ; i=i+1)
printf (il fait beau\n) ;
}
177
Remarques:
Aucune instruction return ne figure dans la dfinition
20/09/15
Les fonctions
de notre fonction.
y = optimist (k) ; /* incorrect */
lappel de cette fonction ce fait laide dune instruction
de la forme :
optimist (k) ; /* instruction simple provoquant
lappel de optimist laquelle on
transmet en paramtre, la valeur de k */
178
20/09/15
Les fonctions
void main()
{ void optimist (int) ; /* prototype de la fonction optimist */
int n = 2, p = 1 ;
optimist (n) ;
optimist (p) ;
optimist (n+p) ;
}
void optimist (int nfois)
{ int i ;
for (i=0 ; i<nfois ; i=i+1)
printf (il fait beau\n) ;
}
179

Si une fonction ne possde aucun paramtre, son entte et sa dclaration (prototype) doivent comporter le
mot void, la place de la liste des paramtres.
Exemple :
Sa dclaration (prototype) serait:
int fexple1 (void) ;
Les fonctions
int fexple1 (void)
Len-tte dune fonction ne recevant aucun paramtre

et ne fournissant aucun rsultat est:
void fexple2 (void)
Son prototype est:

void fexple2 (void) ;
20/09/15
180
Lappel dune fonction sans paramtres doit

comporter des parenthses vides.
Exemple:
et non simplement : fexple1
Exemple :
#include<stdio.h>
Void affiche(void);
Void main()
{ affiche();}
Void affiche(void)
{ printf(bonjour);}
20/09/15
Les fonctions
Lappel de fexple1 scrira : fexple1()
181
Rgles
Arguments muets et arguments effectifs

Les noms des arguments figurant dans len-tte de la
20/09/15
Les fonctions
fonction se nomment des arguments muets , ou

encore arguments formels ou paramtres formels
(de langlais : formal parameter). Leur rle est de
permettre, au sein du corps de la fonction, de dcrire ce
quelle doit faire.
Les arguments fournis lors de lutilisation (lappel) de la
fonction se nomment des arguments effectifs (ou
encore paramtres effectifs ).
182
Rgles: Linstruction return
Linstruction return peut mentionner nimporte

quelle expression. Ainsi, nous pourrons dfinir la
fonction fexple dune manire plus simple :
{ return (x * x + b * x + c) ;}
Linstruction return peut apparatre plusieurs

reprises dans une fonction, comme dans cet autre
exemple :
Les fonctions
float fexple (float x, int b, int c)
double absom (double u, double v)
{ double s ;
s=a+b;
if (s>0) return (s) ;
else
return (-s);
}
20/09/15
183
Rgles : Prototype
soit parmi les diffrentes dclarations situes au dbut dune

fonction (y compris main) ; il nest alors connu que dans la
dite fonction ; ctait le cas dans les exemples rencontrs
jusquici ;
soit avant toutes les dfinitions de fonctions, un niveau
global (comme les variables globales dont nous parlerons un
peu plus loin) ; dans ce cas, il est utilisable par toutes les
fonctions du programme.
20/09/15
Les fonctions
Linstruction de dclaration du prototype sert fournir au

compilateur les informations ncessaires la traduction
des diffrents appels de la fonction (sans quil dispose des
instructions de dfinition de cette fonction).
En ce qui concerne son emplacement, le prototype peut
figurer :
184
Rgles : Initialisation des variables locales
void affiche (void)

{ int n = 10 ;
printf (%d, n) ;
n=n+1;
}
Les fonctions
Les variables locales peuvent tre initialises lors de

leur dclaration. Dans ce cas, il faut savoir que la
valeur indique est place dans la variable, non pas au
moment de la compilation, mais chaque appel de la
fonction. Par exemple, avec cette dfinition :
on obtiendra laffichage de la valeur 10, chaque appel

de affiche.
20/09/15
185
Une fonction peut en appeler une autre
Rien nempche quune fonction appelle, son tour, une

autre fonction, comme dans ce canevas :
void main()
20/09/15
Les fonctions
{ int f1 (float) ; /* prototype de f1 */

.....
f1 (...) ; /* appel de f1 */
.....
}
int f1 (float)
{ void f2 (int) ; /* prototype de f2 */
.....
f2 (...) ;
.....
}
186
En langage C, les paramtres sont transmis

par valeur
20/09/15
Les fonctions
void main(){
void echange (int a, int b) ;
int n=10, p=20 ;
printf (avant appel : %d %d\n, n, p) ;
echange (n, p) ;
avant appel :
10 20
printf (aprs appel : %d %d, n, p) ;
dbut echange : 10 20
}
fin echange :
20 10
void echange (int a, int b)
aprs appel :
10 20
{ int c ;
printf (dbut echange : %d %d\n, a, b) ;
c=a;a=b;b=c;
printf (fin echange : %d %d\n, a, b) ;
}
187

par valeur
La fonction echange reoit deux valeurs correspondant ses
deux paramtres muets a et b. Elle effectue un change de ces
deux valeurs. Mais, lorsque lon est revenu dans le programme
principal, aucune trace de cet change ne subsiste sur les
paramtres effectifs n et p.
En effet, lors de lappel de echange, il y a eu transmission de la
valeur des expressions n et p. On peut dire que ces valeurs ont
t recopies localement dans la fonction echange dans des
emplacements nomms a et b. Cest effectivement sur ces copies
qua travaill la fonction echange, de sorte que les valeurs des
variables n et p nont, quant elles, pas t modifies. Cest ce
qui explique le rsultat constat.
Les fonctions
20/09/15
188

par valeur
Solutions :
dune variable. La fonction recevra, certes, toujours une
copie de cette adresse, mais elle pourra ventuellement
agir sur ce qui se trouve cette adresse. Ceci est possible
grce aux pointeurs.
Utiliser des variables globales.
20/09/15
Les fonctions
Transmettre en paramtre la valeur de ladresse
189
Pour changer la valeur dune variable de la fonction

appelante, on procde comme suit :
la fonction appelante doit fournir ladresse de la variable;
pointeur.
Exemple:
void add(int a, int b, int *c) {
/* c repre lentier o on veut mettre le rsultat */
*c = a + b;}
void main() {
int i=10,j=14,k;
/* on passe les valeurs de i et j comme premiers paramtres */
/* on passe ladresse de k comme troisime paramtre */
add(i,j,&k);}
20/09/15
Les fonctions
la fonction appele doit dclarer le paramtre comme
190
20/09/15
Les fonctions
/*passage darguments par valeur et par adresse */

#include<stdio.h>
void par_valeur(int a, int b, int c);
void par_adresse(int *a, int *b,int *c);
void main(){
int x=2, y=4, z=6;
par_valeur(x,y,z);
par_adresse(&x,&y,&z); }
void par_valeur(int a, int b, int c)
{a=0;b=0;c=0;}
void par_valeur(int *a, int *b, int *c)
{*a=0;*b=0;*c=0;}
191
Les fonctions
void main(){
void echange (int *a, int *b) ;
int n=10, p=20 ;
printf (avant appel : %d %d\n, n, p) ;
echange (&n, &p) ;
printf (aprs appel : %d %d, n, p) ; avant appel :
10 20
}
dbut echange : 10 20
fin echange :
20 10
void echange (int *a, int *b)
aprs appel :
20 10
{ int c ;
printf (dbut echange : %d %d\n, *a, *b) ;
c = *a ; *a = *b ; *b = c ;
printf (fin echange : %d %d\n, *a, *b) ;
}
20/09/15
192
Tableau une dimension de taille fixe
20/09/15
Les fonctions
void main()
{ int i ;
int t[5] = { 1, 1, 1, 1, 1 } ; /* initialisation du tableau */
void affiche (int [5]) ; /* prototype de la fonction affiche */
printf (tableau t avant appel de affiche : ) ;
for (i=0 ; i<5 ; i=i+1) printf (%d , t[i]) ;
printf (\n) ;
affiche (t) ; /* appel de affiche, laquelle on transmet en paramtre le tableau t
*/
printf (tableau t aprs appel de affiche : ) ;
for (i=0 ; i<5 ; i=i+1) printf (%d , t[i]) ;
}
void affiche (int v[5])
{ int i ;
for (i=0 ; i<5 ; i=i+1)
v[i] = i+1 ;}
193
Tableau une dimension de taille fixe

Le mcanisme
Pour le compilateur, un nom de tableau (par exemple t) est
20/09/15
Les fonctions
identique son adresse, cest--dire ladresse de son

premier lment (ici, &t[0]) ;
lappel affiche (t) provoque la transmission la fonction
affiche, de la valeur du paramtre t cest--dire en fait de
ladresse du tableau t (il y a bien toujours mcanisme de
transmission par valeur, mais cette valeur se trouve tre celle
dune adresse) ;
dans la fonction affiche, chaque appel, le symbole t est
remplac par sa valeur, cest--dire en loccurrence ladresse
reue en paramtre ; ainsi, une affectation telle que : v[i] = 0 ;
est traduite en : affecter au i-me entier, partir de ladresse
v, la valeur 0.
194
Tableau une dimension de taille variable
20/09/15
Les fonctions
/* Initialise les lments dun tableau */

void init (int tab[], int n)
{ int i;
for (i = 0; i < n; i++)
tab[i] = i;
}
void main()
{ int i, n = 5;
int *tab;
tab = (int*)malloc(n * sizeof(int));
init(tab,n);
for(i=0;i<n;i++) printf( %d\n,*tab++);
}
195
Tableau deux dimensions de taille fixe
20/09/15
Les fonctions
void mat (int t[5][4])

{ int i, j ;
for (i=0 ; i<5 ; i++)
for (j=0 ; j<4 ; j++)
t[i][j] = 1 ;
}
Voici quelques exemples dutilisation de cette fonction :
void main ()
{ int tab [5] [4] ;
mat (tab) ;
}
196

Tableau deux dimensions de taille variable
len-tte de mat pourra ventuellement ne pas

prciser le nombre de lignes :
void mat (int t[][3])
En revanche, il nest pas possible de lcrire :

void mat (int t[][])/* en-tte incorrect */
20/09/15
Les fonctions
197
20/09/15
Les fonctions
#include<stdio.h>
#include<conio.h>
struct data{
float montant;
char fnom[20];
char lnom[20];
}rec;
void affiche_rec(struct data x);
void main(){
printf("Entrez le montant du don\n");
scanf("%f",&rec.montant);
printf("Entrez le nom et le prnom du donateur\n");
scanf("%s %s", rec.lnom,rec.fnom);
printf("**********************\n");
affiche_rec(rec);
}
void affiche_rec(struct data x)
{ printf("\n le donateur %s %s a donn %.2f dh\n", x.lnom, x.fnom, x.montant);
}
198
Les fonctions
#include<stdio.h>
#define MAX 4
struct personne{
int numero;
char nom[10];
} data[MAX]={{1,"Smith"},{2,"Jones"},{3,"Adams"},{4,"Wilson"}};
void affiche_str(struct personne [MAX]);
void main(){
affiche_str(data);
}
void affiche_str(struct personne x[MAX])
{int i;
for(i=0; i<MAX;i++)
printf("%d \t %s \n", x[i].numero,x[i].nom);
}
20/09/15
199
Fonctions rcursives
Le langage C autorise la rcursivit des appels de

fonctions. Celle-ci peut prendre deux aspects :
rcursivit directe : une fonction comporte, dans sa
Les fonctions
dfinition, au moins un appel elle-mme,

rcursivit croise : lappel dune fonction entrane celui
dune autre fonction qui, son tour, appelle la fonction
initiale (le cycle pouvant dailleurs faire intervenir plus
de deux fonctions).
Exemple
long fac (int n)
{
if (n>1) return (fac(n-1)*n) ;
else return(1) ;
}
20/09/15
200
Pour utiliser les fonctions de cette librairie, il faut

inclure la librairie par la directive #include <math.h>
Les fonctions
20/09/15
201
Les fonctions
20/09/15
202
Dfinition
Dclarations
Chanes de
caractres constantes(chanes littrales)

Tableaux de caractres
Chanes et pointeurs
Ordre alphabtique et lexicographique
Manipulation des chanes de caractres
20/09/15
203
Dfinition
20/09/15
Les chanes de caractres
Les variables de types char ne peuvent recevoir quun seul

caractres.
Un nom ou une adresse sont des exemples de chanes de
caractres.
Une chane de caractres est une suite de caractres
alphanumriques (du texte) qui se termine par le caractre
nul \0.
Elle est reprsent sur une suite doctets se terminant par
un octet supplmentaire li au symbole \0. Celui-ci
indique une fin de chane.
Une chane de caractres est considre comme un tableau
de caractres.
Il nexiste pas de type de donnes pour les chanes de
caractres.
204
Dclarations
Sous forme de tableau
Sous forme de pointeur

Char *<nomchaine>;
Exemples
Char nom[20];
Char *prenom;
20/09/15
char <nomchaine> [<longueur>];
205
Chanes de caractres constantes(chanes

littrales)
Sont reprsentes entre guillemets.
La chane vide est not .
Dans une chane, les caractres de contrle peuvent

tre utiliss.
Exemples:
ce \n texte \n sera rparti sur 3 lignes.

Affichage de \ guillemets \ \n
un deux trois sera value comme un deux trois
20/09/15
206
Tableaux de caractres
Pour stocker une chane de six caractres, il faut

dclarer un tableau de type char avec sept lments:
La septime case est rserve pour le caractre nul \0,
mme sil est reprsent par deux caractres, il est

interprt comme un seul caractre et sa valeur ASCII
est 0.
Initialiser le tableaux des caractres

Char chaine[10]={b,o,n,j,o,u,r,\0};
char chaine[7];
Char chaine[10]=bonjour;
Char chaine[]=bonjour;
Char chaine[7]=bonjour; /*erreur pendant lexcution*/
Char chaine[6]=bonjour; /*erreur pendant la compilation*/
20/09/15
207
Chanes et pointeurs
20/09/15
Une chane de caractres est stocke dans un tableau de type

char, et la fin de cette chane est reprsente par le caractre
nul. Pour dfinir une chane, il suffit donc de pointer au
dbut de cette chane. On peut donc reprsent le dbut de la
chane par un pointeur vers une variable char :
char *message;
Cette instruction dclare le pointeur message vers une
variable de type char, mais le pointeur ne pointe encore sur
rien. Si on crit:
char *message=bonjour tout le monde;
La chane sera stocker quelque part dans la mmoire(avec un
caractre nul la fin).
Voici une instruction quivalente la prcdente:
char message[]=bonjour tout le monde ;
208
Chanes et pointeurs
La fonction malloc:
La fonction malloc() est une fonction qui permet de rserver
char *p; p=malloc(1); p=a;

char *pt; pt=malloc(100);
Remarques:
char *ch1=une chane; char *ch2=une autre chane;
ch1=ch2;/* ch1 et ch2 pointent sur la mme chane*/
de lespace mmoire. On lui transmet en argument le nombre

doctets ncessaires, elle se charge de trouver et de rserver
un bloc de mmoire libre.
Exemple :
char ch1[20]=une chane;

char ch2[20]=une autre chane;
Char ch3[30];
ch1=ch2; /* impossible affichage derreur*/
ch3= bonjour; /* impossible affichage derreur*/
20/09/15
209
Ordre alphabtique et lexicographique
Ordre alphabtique des caractres:

Pour le code ASCII, on a lordre suivant :
Il sagit dune relation dordre est infrieur sur
lensemble des caractres.

Exemple:
0 est infrieur Z et not : 0< Z[(ASCII(0=48), ASCII(Z=90)]
Ordre lexicographique des chanes de caractres:

Il se base sur lordre alphabtique des caractres.
La chane vide prcde toutes les autres chanes.
,0,1,2,,9,,A,B,Z, ,b,,c
Exemples:
ABC prcde BCD car A <B
Abc prcde abc
ab prcde abcd car prcde cd
ab prcde ab car [(ASCII( =12), ASCII(a=97)]
20/09/15
210
Fonction de <stdio.h>
Affichage de chanes de caractres
printf(%s,ch);
char *ch1;
puts(ch1); quivalente printf(%s,ch1);
Lecture de chanes de caractres

char lieu[30];
printf(entrez le lieu de naissance);scanf(%s,lieu);
char chaine[80];
char ch[]=bonjour tout le monde;
printf(entrez une chaine); gets(chaine);

Contrairement scanf, la fonction gets permet de saisir des
chanes de caractres contenant des espaces et des tabulations.
20/09/15
211
Fonctions de <string.h>
int strcmp(const char * chaine1, const char * chaine2);
char * strcat (char *destination, const char *source);
char * strcpy (char *destination, const char *source);
char * strncpy (char *destination, const char *source,
size_t n);
char * strchr(const char * chaine, int caractre);
char * strrchr(const char * chaine, int caractre);
20/09/15
size_t strlen(const char * chaine);
212
La fonction strlen calcule la longueur d'une chane de caractres
en octets, le caractre nul n'tant pas compt.

le nombre de caractres compts est retourn au programme par
la fonction, cela sous forme de valeur entire.
Exemple :
c=strlen("bonjour");
c aura la valeur 7.
Concatnation de chanes de caractres
Longueur d'une chane de caractres
On peut concatner deux chanes de caractres en accrochant
l'une d'elles la fin de l'autre. Cette opration s'effectue via la

fonction strcat.
Exemple:
Strcat(ch1,ch2);
20/09/15
213
La fonction strcmp compare deux chanes caractre par
caractre, jusqu' ce que soit dtecte une diffrence ou que soit

atteint le caractre nul. La comparaison s'effectue dans l'ordre
alphanumrique. En d'autres termes, on vrifie chaque fois si
les deux caractres comparer occupent ou non la mme place
dans la table des caractres utiliss. Ici, un caractre est
considr comme suprieur un autre s'il occupe une place plus
leve dans la table des caractres, et infrieur s'il occupe une
place moins leve. Ainsi, dans la table ASCII le caractre 'Z' est
plus grand que 'A' mais plus petit que 'a'.
20/09/15
Comparaison de chanes de caractres
214
Comparaison de chanes de caractres
suivantes :
si la valeur est infrieure 0, alors la chane dont l'adresse est
donne par le premier paramtre de la fonction est infrieure
l'autre chane
si la valeur est gale 0, alors les deux chanes sont gales
si la valeur est suprieure 0, alors la chane dont l'adresse est
donne par le premier paramtre de la fonction est suprieure
l'autre chane.
La valeur transmise au programme peut tre stocke dans une
variable de type int.
Exemple:
int result;
result=strcmp(ch1,ch2);
20/09/15
Cette fonction retourne une valeur entire avec les conventions
215
Copie de chanes de caractres
qui permet de copier une chane entire de caractres dans une
autre. Cette fonction admet comme paramtres les deux chanes
de caractres. Elle retourne 1 si la copie s'est effectue
correctement, sinon elle renvoie 0.
Exemple:
strcopy(ch1,ch2);
strncpy, est similaire strcopy, on notera que:
si la chane source a moins de n caractres non nuls, strncpy
rajoutera n - strlen(source) caractres nuls la suite, pour
complter;
si la chane source fait au moins n caractres, la fonction
n'insrera pas de caractre nul en fin de chaine (i.e.
destination ne sera pas une chane de caractres valide).
20/09/15
La fonction strcpy() (prononcez string copy) est une fonction
216
Les fonctions strchr & strrchr recherche le caractre dans la
chane et renvoie la position de la premire occurrence dans le

cas de strchr et la position de la dernire occurrence dans le cas
de strrchr.
Exemple :
#include <stdio.h>
#include <string.h>
void main() {
char *str="E.N.A.C.", c = '.', *ptr;
if ( (ptr = strrchr(str, c)) != NULL)
printf("Le caractere %c est en position %d\n", c, ptr-str);
else
printf("Pas trouve\n"); }
___________________________________________
/* rsultat de l'excution */
Le caractere . est en position 7
20/09/15
Recherche dans une chane
217
20/09/15
#include <stdio.h>
#include <string.h>
void main() {
char *str = "E.N.A.C.", c = 'A', *ptr;
if ( (ptr = strchr(str, c)) != NULL )
if (ptr)
printf("Le caractere %c est a la position %d\n", c, ptr-str);
else
printf("Le caractere %c n'est pas trouve dans %s\n", c, str
}
/* rsultat de l'excution*/
Le caractere A est a la position 4
218
20/09/15
#include <stdio.h>
#include <string.h>
void main() {
char str[10];
char *ptr = "ABCDEFGHIJ";
strcpy(str, ptr); printf("%s\n", str);
} /* rsultat de l'excution: ABCDEFGHIJ*/
#include <stdio.h>
#include <string.h>
void main() {
char str[10]; char *ptr = "ABCDEFGHI";
strncpy(str, ptr, 3);
str[3] = '\0';
printf("%s\n", str); } /* rsultat de l'excution: ABC */
219
#include <string.h>
#include <stdio.h>
void main() {
char m1[60] = "Ecole Nationale";
char *m2 = " de l'Aviation Civile";
strcat(m1, m2); printf("%s\n", m1); }
/* rsultat de l'excution: Ecole Nationale de l'Aviation Civile*/
20/09/15
#include <stdio.h>
#include <string.h>
void main() {
char *str = "E.N.A.C.";
printf("%d\n", strlen(str));} /* rsultat de l'excution: 8 */
220
Introduction
Dfinition
et proprits
Mmoire tampon
Types de Fichiers
Dclaration dun fichier
Ouverture de fichiers
Fermeture de fichiers
La fonction dcriture en fichier
La fonction de saisie en fichier
Lecture et criture par caractre
Positionnement dans un fichier
20/09/15
221
Introduction
20/09/15
Fichiers
Le langage C offre la possibilit de lire et dcrire des

donnes dans un fichier. Pour des raisons defficacit, les
accs un fichier se font par lintermdiaire dune
mmoire-tampon (on parle de buffer), ce qui permet de
rduire le nombre daccs aux priphriques (disque...).
Pour pouvoir manipuler un fichier, un programme a besoin
dun certain nombre dinformations : ladresse de lendroit
de la mmoire-tampon o se trouve le fichier, la position
de la tte de lecture, le mode daccs au fichier (lecture ou
criture)
Ces informations sont rassembles dans une structure,
dont le type est FILE *. Ce type est dfini dans <stdio.h>.
Un objet de type FILE * est appel flot de donnes (stream
en anglais).
222
Dfinition et proprits
Ouverture du fichier
Fichiers
Un fichier est une suite de donnes conserves en permanence

sur un support externe(disquette, disque dur,). Ces donnes
regroupent, le plus souvent, plusieurs composantes(champs)
dune structure.
En C, les fichiers sont considrs comme une suite doctets(1
octet=caractre).
Principe de manipulation dun fichier:
Lecture, criture et dplacement dans le fichier
Fermeture du fichier
Deux techniques pour manipuler un fichier

Laccs squentiel : pour atteindre linformation souhait, il faut
passer par la premire puis la deuxime et ainsi de suite.

Laccs direct : consiste se dplacer directement sur linformation
souhait sans avoir parcourir celles qui la prcdent.
20/09/15
223
Mmoire tampon
Laccs au fichier se fait par lintermdiaire dune
zone mmoire de stockage appel mmoire
tampon(buffer).
Le buffer une zone de la mmoire centrale qui
stocke une quantit, assez importante, de donnes
du fichier.
Son rle est dacclrer les entres/sorties un
fichier.
Fichiers
20/09/15
224
Types de Fichiers
Fichiers
Fichier de texte : est une suite de lignes, chaque ligne

est une suite de caractres termine par le caractre
spcial \n.
Fichier binaire : est une suite doctets pouvant
reprsenter toutes sortes de donnes.
Fichiers standards : se sont des fichiers spciaux
prdfinis
qui souvrent automatiquement lorsquun
programme commence sexcuter :
Stdin (standard input): entre standard(par dfaut, li au
clavier)
Stdout (standard output): sortie standard(par dfaut, li
lcran)
Stderr stderr (standard error) : affichage des messages
derreur (par dfaut, lcran).
20/09/15
225
Dclaration dun fichier
Adresse de la mmoire tampon,

Position actuelle dans le tampon,
Fichiers
FILE *<pointeurfichier>;
Le type file est dfini dans <stdio.h> en tant que
structure. A louverture dun fichier, la structure FILE
contient un certain nombre dinformations sur ce
fichier telles que :
Nombre de caractres dj crits dans le tampon,

Type douverture du fichier,
Pour travailler avec un fichier dans un programme, il

faut ranger ladresse de la structure FILE dans le
pointeur de fichier et tout accs ultrieur au fichier se
fait par lintermdiaire de ce pointeur.
20/09/15
226
Lorsquon dsire accder un fichier, il est ncessaire
avant tout accs douvrir le fichier laide de la
fonction fopen.
Cette fonction, de type FILE * ouvre un fichier et lui
associe un flot de donnes. Sa syntaxe est :
fopen("nom-de-fichier","mode");
Smantique des paramtres
Fichiers
Le premier argument de fopen fournit donc le nom du
fichier.
Le second argument, mode, est une chane de caractres
qui spcifie le mode daccs au fichier.
20/09/15
227
Les spcificateurs de mode daccs diffrent suivant
le type de fichier considr.
On distingue
contrle (retour la ligne...) seront interprts en tant

que tels lors de la lecture et de lcriture ;
20/09/15
Fichiers
les fichiers textes, pour lesquels les caractres de
228
Les diffrents modes daccs sont

"r" ouverture dun fichier texte en lecture
"w" ouverture dun fichier texte en criture
"r+" ouverture dun fichier texte en lecture/criture
"w+" ouverture dun fichier texte en lecture/criture
Fichiers
"a" ouverture dun fichier texte en criture la fin
"a+" ouverture dun fichier texte en lecture/criture la fin
20/09/15
229
Conditions particulires et cas derreur

Si le mode contient la lettre r, le fichier doit exister, sinon cest
20/09/15
Fichiers
une erreur(la fonction fopen retourne NULL).

Si le mode contient la lettre w, le fichier peut ne pas exister.
Dans ce cas, il sera cr, et si le fichier existait dj, son ancien
contenu est perdu.
Si le mode contient la lettre a, le fichier peut ne pas exister.
Comme pour le cas prcdent, si le fichier nexiste pas, il est
cr ; si le fichier existe dj, son ancien contenu est conserv.
Si un fichier est ouvert en mode criture la fin toutes les
critures se font lendroit qui est tait la fin du fichier lors de
lexcution de lordre dcriture. Cela signifie que si plusieurs
processus partagent le mme FILE*, rsultat de louverture
dun fichier en criture la fin, leurs critures ne scraseront
pas mutuellement.
230
Utilisation typique de fopen
Fichiers
#include <stdio.h>
FILE *fp;
..
if ((fp = fopen("donnees.txt","r")) == NULL)
{
fprintf(stderr,"Impossible douvrir le fichier donnes en
lecture\n");
exit(1);
}
20/09/15
231
Fermeture de fichiers : la fonction fclose
Fichiers
La fonction fclose permet de terminer la manipulation

dun fichier ouvert par la fonction fopen.
Sa syntaxe est :
fclose(nom_du_fichier)
nom_du_fichier
o nom_du_fichier est de type FILE* retourn par la
fonction fopen correspondante.
La fonction fclose retourne
0 si lopration sest droule normalement et
EOF si il y a eu une erreur.
Exemple :
FILE *fp;
fp = fopen("donnees.txt","r")
fclose(fp);
20/09/15
232
La fonction dcriture en fichier: fprintf
La fonction fprintf, analogue printf, permet dcrire

des donnes dans un flot.
Sa syntaxe est :
fprintf(nom_du_fichier, "format", expression1, . . . ,
o nom_du_fichier est le flot retourn par la fonction

fopen.
Les spcifications de format utilises pour la fonction
fprintf sont les mmes que pour printf
Puisque
Fichiers
expressionn);
printf(...) fprintf(stdout,...)
Expressioni est une expression dlivrant une valeur

crire.
20/09/15
233
La fonction de saisie en fichier : fscanf
La fonction fscanf, analogue scanf, permet de lire des

donnes dans un fichier.
Sa syntaxe est semblable celle de scanf :
fscanf(nom_du_fichier, "format", adresse1, . . . ,
o nom_du_fichier est le flot de donnes retourn par

fopen.
Les spcifications de format sont ici les mmes que celles
de la fonction scanf.
Adressei : adresse des variables affecter partir des
donner.
Un format et une adresse doivent tre fournis pour
chaque variable.
20/09/15
Fichiers
adressen);
234
Programme: Exemple
20/09/15
Fichiers
#include<stdio.h>
Void main(){
FILE *pf;
int i=100;
char=c;
float t=1.234;
pf=fopen(essai.txt,w+); /*ouverture et mise jour*/
fprintf(pf,%d %c %f ,i,c,t);
fscanf(pf,%d %c %f,&i,&c,&t);
fprintf(pf,%d %c %f,i,c,t);
fclose(pf);
}
235
Lecture et criture par caractre : fgetc et

fputc
Similaires aux fonctions getchar et putchar les

fonctions fgetc et fputc permettent respectivement de
lire et dcrire un caractre dans un fichier.
La fonction fgetc retourne le caractre lu dans le
fichier et la constante EOF lorsquelle dtecte la fin du
fichier. Sa syntaxe est :
Fichiers
int fgetc(pf); /*o pf est de type FILE* */
La fonction fputc crit un caractre dans le flot de

donnes . Sa syntaxe est :
fputc(int caractere, FILE *flot)
Elle retourne lentier correspondant au caractre lu

(ou la constante EOF en cas derreur).
20/09/15
236
Exemple
20/09/15
Fichiers
#include <stdio.h>
#include <stdlib.h>
#define ENTREE "entree.txt"
#define SORTIE "sortie.txt"
Void main() {
FILE *f_in, *f_out;
int c;
// Ouverture du fichier ENTREE en lecture
if ((f_in = fopen(ENTREE,"r")) == NULL)
fprintf(stderr, "\nErreur: Impossible de lire %s\n",ENTREE);
// Ouverture du fichier SORTIE en ecriture
if ((f_out = fopen(SORTIE,"w")) == NULL)
fprintf(stderr, "\nErreur: Impossible decrire dans %s\n",SORTIE);
// Recopie du contenu de ENTREE dans SORTIE
while ((c = fgetc(f_in)) != EOF)
fputc(c, f_out);
// Fermeture des flots de donnees
fclose(f_in);
fclose(f_out);
}
237
Exemples
#include <stdio.h>
void main ()
{
FILE *TheFic;
FILE *TheFic1;
char BigBuf[256];
Fichiers
TheFic = fopen ("esai.txt", "r"); /*doit tre cr avant compilation*/

TheFic1 = fopen ("esai1.txt", "w");
if (TheFic == NULL)
printf ("Impossible d ouvrir le fichier \n");
/*char *fgets(char *, int , FILE *) ;*/
while (fgets (BigBuf, sizeof BigBuf, TheFic) != NULL)
/* char *fputs(char *, FILE *) ; */
fputs (BigBuf, TheFic1);
fclose (TheFic);
fclose (TheFic1);
}
20/09/15
238
Positionnement dans un fichier : fseek,

rewind et ftell
fseek
Les diffrentes fonctions dentres-sorties permettent
20/09/15
Fichiers
daccder un fichier en mode squentiel : les donnes

du fichier sont lues ou crites les unes la suite des
autres.
Il est galement possible daccder un fichier en mode
direct, cest--dire que lon peut se positionner
nimporte quel endroit du fichier.
La fonction fseek permet de se positionner un endroit
prcis.
239

rewind et ftell
fseek
a pour prototype :
int fseek(FILE *pf, long deplacement, int origine);
dans le fichier. Il sagit dun dplacement relatif par

rapport origine, compt en nombre doctets.
La variable origine peut prendre trois valeurs :
1.
2.
3.
20/09/15
Fichiers
La variable deplacement dtermine la nouvelle position
SEEK_SET (gale 0) : dbut du fichier ;

SEEK_CUR (gale 1) : position courante ;
SEEK_END (gale 2) : fin du fichier.
240

rewind et ftell
rewind
int rewind(FILE *flot);
permet de se positionner au dbut du fichier. Elle est
ftell
long ftell(FILE *flot);
Fichiers
quivalente fseek(flot,0, SEEK_SET) ;
retourne la position courante dans le fichier (en nombre
doctets depuis lorigine).
20/09/15
241

Langage C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Langage C

Enviado por

Direitos autorais:

Formatos disponíveis

Mme khadija bouzaachane

Introduction : Bref historique

Le langage C a t cr par Dennis Ritchie aux Bell

Introduction : Pourquoi utiliser le langage C

Souple et puissant : Le langage C est utilis pour des projets

Introduction : Cycle de dveloppement du

Cration dun code source en utilisant un diteur

Le code source est une srie de commandes qui

Introduction : Cycle de dveloppement

Compilation du code source

peut comprendre que des instructions binaires dans ce que

Introduction : Cycle de dveloppement du

Cration du fichier excutable

partie du langage C est constitue dune

Introduction : Cycle de dveloppement du programme

Programme source (.c)

Fichier en-tte (.h)

Programme objet (.obj)

Introduction : votre premier programme

Exemple de programme en langage C

#include <stdio.h>//standard input/output

Exemple de programme en langage C

Elments de base du langage C

Exemple de programme en langage C

Structure dun programme en Langage C

Programme excut automatiquement avant la

Il sagit de directive qui seront prises en compte avant la

traduction (compilation) du programme. Ces directives

Elments de base du langage C

Structure dun programme en Langage C

consiste saisir son nom, main, suivi de parenthse () vide et

La dfinition des variables

les donnes en cours dexcution. En C une variable doit tre

Elments de base du langage C

Structure dun programme en Langage C

donner un nom une entit du programme (quil

Ils sont forms dune suite de lettres (a `a z et A `a Z), de

Elments de base du langage C

Ainsi, les noms var1, S_i, et InitDB sont des

identificateurs valides, tandis que i:j ou 1i ne le sont pas.

Structure dun programme en Langage C

prdifinie(printf) qui reoit un argument "Bonjour\n"

Elments de base du langage C

Structure dun programme en Langage C

rptition, comme par exemple : for(i=0;i<NFOIS;i++), son

i<NFOIS, si elle est satisfaite, excuter le bloc indiqu sa fin

Pour lire les informations: la fonction scanf

Elments de base du langage C

prdfinie scanf dont le rle est de lire une information au

Structure dun programme en Langage C

Constituent une instruction de choix base sur la

Elments de base du langage C

Structure dun programme en Langage C

Qui stend sur plusieurs ligne*/

source de votre programme, surtout sil contient des

Elments de base du langage C

Elments de base du langage C

Un certains nombres de mots sont rservs pour le langage

Les types de base : Les caractres

char c1 = a; // Dclaration dune variable c1 de type char

// a laquelle on affecte la valeur a

Elments de base du langage C

On utilise le mot-cl char pour dsigner une variable