Documente Academic
Documente Profesional
Documente Cultură
Programmation C
Filire : Licence fondamentale SMA/SMI S3,
Dpartement Mathmatique et Informatique
Prof : S.ELFIALI
Ce document prsente les bases du langage C.
Ce sera votre document de rfrence pendant
les sances de travaux dirigs et de travaux
pratiques.
Chapitre 1. Introduction
1. Prambule
1. Un programme informatique
Un programme informatique est une liste d'instructions crites dans un ou plusieurs
fichiers, destin tre excut par l'ordinateur afin de raliser une ou plusieurs tche(s), de
rsoudre un problme, de manipuler des donnes.
2. Un langage informatique
Le langage utilis par le processeur, c'est--dire les donnes telles qu'elles lui arrivent, est
appel langage machine. Il s'agit d'une suite de 0 et de 1 (du binaire). Toutefois le langage
machine n'est pas comprhensible facilement par l'humain.
2. Historique
Langage C a t cr en 1972 par Dennie Ritchie aux Laboratoires Bell/AT&T avec un
objectif de dvelopper une version portable du systme d'exploitation UNIX.
Il provient de deux langages : BCPL dvelopp en 1967 par Martin Richards et B
dvelopp en 1970 chez AT&T par Ken Thompson.
Il fut limit lusage interne de Bell jusquen 1978, date laquelle Brian Kernighan et
Dennie Ritchie publirent la dfinition classique du langage C (connue sous le nom de standard
K&R-C) dans un livre intitul The C Programming Language .
Le succs des annes qui suivaient et le dveloppement de compilateurs C par d'autres
maisons ont rendu ncessaire la dfinition d'un standard actualis et plus prcis. En 1983,
l'American National Standards Institute' (ANSI) chargeait une commission de mettre au point une
dfinition explicite et indpendante de la machine pour le langage C. Le rsultat tait le standard
ANSI-C. La seconde dition du livre The C Programming Language , parue en 1988, respecte
tout fait le standard ANSI-C et elle est devenue par la suite, la 'bible' des programmeurs en C.
3. Intrts du langage C
9
4. De ldition lexcution
Les tapes menant de ldition lexcution dun programme en C sont : ldition,
la compilation et ldition de liens.
LEdition du programme
Ldition, cest la rdaction du programme laide de lditeur de texte de CodeBlocks ou
dun autre traitement de texte : on parle alors de programme source .
En gnrale, ce texte sera conserv dans un fichier que lon nommera fichier source
dont lextension est .C .
La compilation
Elle consiste traduire le programme source en langage machine, en faisant appel
un programme nomm compilateur. Le fichier gnr, appel fichier objet, possde le mme
nom que le fichier source, mais son extension est .OBJ .
10
Ldition de liens
Il permet d'intgrer dans le fichier final tous les lments annexes (fonctions ou
librairies) auquel le programme fait rfrence mais qui ne sont pas stocks dans le fichier source.
Le fichier gnr est un fichier excutable qui contient tout ce dont il a besoin pour fonctionner
de faon autonome.
fichier source
compilateur
fichier objet
fichier excutable
diteur de liens
Rsultat
excution
11
12
La taille: c'est le nombre d'octets occups en mmoire, elle est en fonction du type.
Adresse
FF00
4.1 Mmoire
centrale
x
Nom
de la variable
15
4.2 Val
eur
Signification
caractre
caractre non sign
entier court
entier court non sign
Int
entier
unsigned int
long int
unsigned long int
Float
Double
long double
entier long
entier long non sign
flottant (rel)
flottant double
flottant double long
13
Valeurs limites
-128 127
0 255
-32 768 +32 767
0 65 535
-32 768 +32 767
-2 147 483 648 +2 147 483 647
0 65 535
0 4 294 967 295
-2 147 483 648 +2 147 483 647
0 4 294 967 295
3.4*10-38 3.4*1038
1.7*10-308 1.7*10308
3.4*10-4932 3.4*104932
double
int
struct
Break
else
long
switch
Case
enum
register
typedef
Char
extern
return
union
Const
float
short
unsigned
Continue
for
signed
void
Default
goto
sizeof
volatile
do
if
static
while
Identificateurs valides :
x
x1
_x
a#b
14
Exemples :
int x=-10, y, z=20 ;
char touche = A' ;
float hauteur, largeur;
2. Constantes littrales
Quand une valeur comme
littrale : littrale car on ne peut parler d'elle qu' travers sa valeur, et constante car sa valeur ne
peut tre change. Chaque littral possde un type associ. Par exemple,
3.1459
Caractre
Description
Dcimale
Octale
Hexadcimale
Dcimale
Imprimable
Exemples
-12, 20
015,027
0x1A5, 0xFFFF
15.25, 1.53e2, 314E-2
a' ..... 2'.....,' ..... (espace)
Non-imprimable
Chane de caractre
"Bonjour"
15
Exemples :
4. Oprateurs et expressions
Une expression peut tre une variable, une constante, un appel dune fonction (avec retour
de valeur) ou d'une combinaison de chacun de ces lments par des oprateurs. Toute expression
un type et une valeur.
Exemples :
b*b 4*a*c
'A' + 1
(-b + sqrt(b*b 4*a*c)) / (2*a)
Oprateurs arithmtiques
Fonction
Addition
Soustraction
Multiplication
Division
Modulo
Symbole
+
*
/
%
Remarques
16
Oprateurs de relation
Fonction
Symbole
Remarques
Plus grand que
>
Plus petit que
<
Plus grand ou gal
>=
Plus petit ou gal
<=
Egal
Attention! Trop souvent confondu avec loprateur daffectation =
==
Diffrent de
!=
Note : Ces oprateurs servent comparer des expressions. Le rsultat des oprations est VRAI ou FAUX.
Oprateurs logiques
Fonction
Symbole Remarques
ET
( (a>2) && (a<10) ) VRAI si a = 6, FAUX si a = 16
&&
OU
( (a<2) || (a>10) ) FAUX si a = 6, VRAI si a = 16
||
Ngation
!( (a<2) || (a>10) ) VRAI si a = 6, FAUX si a = 16
!
Note : Ces oprateurs servent tester ltat logique dune expression : VRAI ou FAUX, OUI ou NON, 0 ou 1. Une
valeur numrique peut galement tre teste : VRAI si diffrente de 0, FAUX si gale 0.
Oprateurs daffectation
Fonction
Symbole Remarques
Affectation simple
=
Ajoute et affecte
a += b; quivaut a = a + b ;
+=
Soustrait et affecte
a -= b; quivaut a = a - b ;
-=
Multiplie et affecte
a *= b; quivaut a = a * b ;
*=
Divise et affecte
a /= b; quivaut a = a / b ;
/=
Modulo et affecte
a %= b; quivaut a = a % b ;
%=
OU (bit) et affecte
a |= b; quivaut a = a | b ;
|=
OU exclusif (bit) et affecte
a ^= b; quivaut a = a ^ b ;
^=
ET (bit) et affecte
a &= b; quivaut a = a & b ;
&=
Dcale droite et affecte
a >>= b; quivaut a = a >> b ;
>>=
Dcale gauche et affecte
a <<= b; quivaut a = a << b ;
<<=
Note : Ces oprateurs modifient la valeur des variables.
Symbole
,
Remarques
int a, b; b = 3, a = 94;
Symbole
?:
Remarques
min = (a<b) ?a :b; si (a<b) est VRAI, min=a ;.sinon min=b ;
Oprateur conditionnel
Fonction
Evaluation conditionnelle
17
Note : Lutilisation de cet oprateur fait partie des thmes traits au chapitre 4.
Oprateurs unaires
Fonction
Incrmentation
Symbole
++
Remarques
c=a + (b++) ; b=b + 1 aprs excution de linstruction
c=a + (++b) ; b=b + 1 avant excution de linstruction
Dcrmentation
c=a + (b--) ; b=b - 1 aprs excution de linstruction
-c=a + (--b) ; b=b - 1 avant excution de linstruction
Conversion explicite
char a; int b; b=(int)a; une copie de la valeur de a est transforme en
(nom
int avant dtre dpos dans b.
Type)
Adressage indirect
*ptr=a ; copie la valeur de a ladresse pointe par ptr.
*
Adresse de
&a est ladresse de a.
&
Evalue grandeur mmoire
sizeof
sizeof(expr). sizeof(nom Type).
Plus unaire
force lvaluation dune expression avant une autre cause de son niveau
+
de priorit.
Moins unaire
-a est le complment 2 de a.
Note : Un oprateur unaire est un oprateur qui ncessite 1 seul oprande : a++.
Un oprateur binaire est un oprateur qui ncessite 2 oprandes : a + b.
Oprateurs primaires
Fonction
Parenthse
Expression dindice
Slecteur de membre
Slecteur de membre
Symbole
()
[]
->
.
Remarques
char tableau[8] ; tableau[3] = a + tableau[5] ;
Slection par pointeur : ptrstruct->mois = 12 ;
Slection par la structure : date.mois = 12 ;
Lorsque plusieurs oprateurs de mme niveau de priorit se trouvent dans une expression,
cest lassociativit (gauche droite ou droite gauche), qui dtermine si les oprations seront
effectues de droite gauche ou de gauche droite.
Type doprateur
Primaire
Unaire
Arithmtique
Arithmtique
De manipulation de bits
De relation
De relation
()
++
*
+
>>
>
==
Oprateurs
[ ] . ->
-- (nom Type) * & sizeof + / %
<<
< >= <=
!=
18
Associativit
gauche droite
droite gauche
gauche droite
gauche droite
gauche droite
gauche droite
gauche droite
8
7
6
5
4
3
2
1
De manipulation de bits
De manipulation de bits
De manipulation de bits
Logique
Logique
Conditionnel
Daffectation
Dvaluation squentielle
&
^
|
&&
||
?:
= +=
,
-=
*=
/=
|=
gauche droite
gauche droite
gauche droite
gauche droite
gauche droite
droite gauche
droite gauche
gauche droite
5. Les Instructions
Une instruction simple est soit une expression termine par un point virgule, soit
une instruction de contrle (traite au chapitre 4) soit un bloc dinstructions
dlimit par { et }.
Exemple : a=a +1;
Les instructions composes (ou blocs) qui permettent de considrer une succession
d'instructions comme tant une seule instruction :
o elles commencent par "{" et finissent par "}"
o laccolade ouvrante est lquivalente du dbut en algorithme
o laccolade fermante est lquivalente de la fin en algorithme
Exemple :
{
float tauxConversion=6.55957, valeurEnFranc;
int valeurEnEuro=50;
valeurEnFranc = valeurEnEuro * tauxConversion;
}
19
1. Fonction printf()
La fonction printf() permet dafficher du texte, des valeurs de variables ou des rsultats
d'expressions l'cran.
Syntaxe : printf(format[,arg1, arg2,,argn]).
Code de conversion
d ou i
U
O
x ou X
C
F
e ou E
S
Type
int
unsigned int
int
int
char
float ou double
float ou double
char*
Remarque
affich en octal
affich en hexadcimale
Exemple 1 :
int q = 100;
float p = 60.50;
char t =A;
printf("Quantite = %d\n",q);
printf("Prix = %f\n", p) ;
printf("Taille = %c\n",t) ;
printf("Prix total = %f", q*p);
ou bien
printf("Quantite = %d\nPrix = %f\nTaille = %c\nPrix total = %f",q,p,t,q*p);
Imprime
Quantite = 100
Prix = 60.500000
Taille = A
Prix total = 6050.000000
Le champ modificateur
Le champ modificateur est optionnel, il est constitu dune simple lettre (l, h ou L) place
devant le champ code de conversion qui spcifie short ou long.
:
:
:
:
long int.
unsigned long int.
short int.
long double.
21
Spcificateur de prcision
Par dfaut, les flottants sont affichs avec six chiffres aprs le point dcimal (aussi bien
pour la notation dcimale que pour la notation exponentielle).Il est possible de modifier cette
reprsentation en utilisant un point dcimal et un spcificateur de prcision.
Exemple 2 :
float val = 25.1234;
printf("%f",val);
printf("%.0f",val);
printf("%.1f",val);
printf("%.2f",val);
printf("%e",val);
printf("%.3e",val);
/* affiche : 25.123400 */
/* affiche : 25 */
/* affiche : 25.1*/
/* affiche : 25.12*/
/* affiche : 2.512340e+01*/
/* affiche : 2.512e+01*/
Le champ largeur
Le champ largeur permet de spcifier le nombre minimal de caractres afficher.
Exemple 3 :
int val1 = 125;
float val2 = 4.5;
printf("|%d|",val1);
printf("|%2d|",val1);
printf("|%5d|",val1);
printf("|%05d|",val1);
/* affiche : |125| */
/* affiche : |125| */
/* affiche : |--125| */
/* affiche : |00125| */
printf("|%8.2f|\n",val2);
/* affiche : |----4.50| */
Le champ drapeau
Exemple 4 :
int val1 = 125;
float val2 = 4.5;
printf("|%-5d|",val1);
printf("|%+05d|",val1);
/*affiche : |125--|*/
/*affiche : |+0125|*/
22
2. Fonction scanf()
La fonction scanf permet de lire des donnes au clavier et de les affecter des variables.
Syntaxe : scanf(format,arg1, arg2,,argn).
Remarques :
Chaque nom d'argument qui correspond un scalaire doit tre prcd de &
(oprateur dadresse), ceci indique que l'information saisie va tre place
l'adresse de la variable.
La chane de format ne doit comporter que des spcifications de format, sinon tout
autre caractre indiqu dans la chane de format doit tre saisi par lutilisateur.
Le code de conversion "f" sapplique aux donnes de type float et double dans le
cas de la fonction printf(). Par contre, pour la fonction scanf(), une distinction
simpose : "f" ne sapplique quaux donnes de type float ; pour les donnes de
type double, il faut utiliser le code de conversion "lf" qui signifie long float.
Exemples :
23
Tampon de scanf
Les informations tapes au clavier sont d'abord mmorises dans un emplacement
mmoire appel tampon (buffer). Elles sont mises la disposition de scanf aprs lactivation de la
touche <Entre>
Pour les nombres : scanf avance jusqu'au premier caractre diffrent d'un
sparateur (espace, tabulation, retour la ligne) puis scanf prend en compte
tous les caractres
a = 123 b = 45
a = 10 b = 20
scanf("%d%c",&a,&b);
200^z
==>
scanf("%d^ %c",&a,&b);
200^z
==>
a = 200 b = 'z '
scanf("%d",&a);
15@
==>
scanf("%c",&b); ==>
a = 15
b = \n
24
#include <stdio.h>
void main()
// Point d'entr du programme
{
/*Dbut du programme*/
float x, y;
printf("\t\t\tCalcul de la moyenne\n\n");
/*Affiche le titre*/
printf("Entrez le premier nombre : ");
scanf("%f", &x);
/*Lecture du premier nombre*/
printf("Entrez le deuxieme nombre : ");
scanf("%f", &y);
/*Lecture du deuxime nombre*/
printf("La valeur moyenne de %.2f et de %.2f est %.2f\n",x, y,(x+y)/2);
// Fin du programme
Commentaire :
Inclusion des fichiers : La premire ligne contient la directive #include suivi dun nom de
fichier a pour effet dinsrer le fichier spcifi entre < et >, ici stdio.h, dans le fichier source
lendroit o la directive est place. Le fichier den-tte stdio.h contenant les dclarations
ncessaires lutilisation des fonctions dentres-sorties standard. Le compilateur dispose ainsi
des informations ncessaires pour vrifier si lappel de la fonction (en l'occurrence printf et scanf)
est correct.
A propos de main() : Tout programme C doit contenir au moins une fonction appele
main. Le code quil contient est encadr par deux accolades, { et }. Lexcution du programme
dbute immdiatement aprs laccolade ouvrante et se termine lorsque laccolade fermante
correspondante est rencontre.
25
26
Diagramme syntaxique du if :
Dbut de if
Expression
non
!=0
oui
instruction1
instruction2 *
* facultatif
Fin de if
Exemples :
int qte_cmd ;
float prix, remise=0 ;
printf("La quantit commande : ") ;scanf("%d",&qte_cmd) ;
printf("Prix unitaire : ") ;scanf("%f",&prix) ;
if(qte_cmd > 100) remise = 0.1;
printf("Prix payer : %.2f",prix*qte_cmd*(1 remise) ) ;
char car ;
printf("Tapez une lettre minuscule non accentue : ");
scanf("%c",&car);
if (car == 'a' || car == 'e' || car == 'i' || car == 'o' || car == 'u' || car == 'y')
printf("la lettre %c est une voyelle",car);
else
printf("la lettre %c est une consonne",car);
27
Exercice 1 :
L'utilisateur saisit un caractre, le programme teste s'il s'agit d'une lettre majuscule, si oui
il affiche cette lettre en minuscule, sinon il affiche un message d'erreur.
Solution :
....................................................................................................................................................................................... .....
............................................................................................................................................................................................
............................................................................................................................................................................................
................................................................................................................................ ............................................................
............................................................................................................................................................................................
............................................................................................................................................................................................
............................................................................................................................................................................................
............................................................................................................................................ ................................................
............................................................................................................................................................................................
............................................................................................................................................................................................
............................................................................................................................................................................................
........................................................................................................................................................ ....................................
............................................................................................................................................................................................
...........................................................................................................................................................................................
............................................................................................................................................................................................
Exercice 2 :
Quel rsultat affiche le programme suivant :
#include<stdio.h>
void main()
{
int x = 3 ;
if (x < 0) ;
{
x = -x ;
printf("x = %d ", x);
}
if (x = 4) printf("x = %d", x);
}
Solution :
............................................................................................................................................................
B) Imbrication dinstructions if
Il est possible dimbriquer une instruction if lintrieur dune autre.
28
Syntaxe :
if (<expression1>) if (<expression2>) <instruction1> else <instruction2>
Exemple :
if (a < b) if (c < b) z = b ; else z = a ;
C)Linstruction if-else if
Il est frquemment utile dutiliser une srie dinstructions if-else if pour rpondre une situation
dans laquelle les choix sont multiples.
Syntaxe :
if (<expression1>) <instruction1>
else if (<expression2>) <instruction2>
else if (<expression3>) <instruction3>
...
[else <instruction_n+1>]
29
Chaque instruction est associe une condition et le dernier else, sil existe, correspond au cas o
aucune condition nest vraie.
Exemples :
if ( qte < 1000)
taux_remise = 5;
else if ( qte < 10000)
taux_remise = 10;
else
taux_remise = 15;
#include<stdio.h>
void main()
{
char c;
printf("Entrez une lettre non accentue : ");
scanf("%c", &c);
if (c >='A' && c<='Z')
printf("Cette lettre en minuscule est : %c",c+32);
else if (c >='a' && c<='z')
printf("Cette lettre en majuscule est : %c",c-32) ;
else
printf("Erreur ! Ce nest pas une lettre non accentue") ;
}
Exercice 3 :
Ecrivez un programme qui permet de saisir une valeur de type entire et indiquez
l'utilisateur si celle-ci est positive, ngative ou nulle.
Solution :
Remarque :
Le langage C offre la possibilit de remplacer linstruction conditionnelle if-else dans le
cas dune affectation conditionnelle de variable par loprateur conditionnel ?: et qui a
l'avantage de pouvoir tre intgr dans une expression.
Syntaxe :
expr1 ? expr2 : expr3
30
On value expr1:
Si elle n'est pas nulle (donc elle est vraie), alors la valeur de <expr2> est fournie
comme rsultat.
Sinon, la valeur de <expr3> est fournie comme rsultat.
Exemples :
int x = 5, y = 4, max;
if (x>y)
max=x;
else
max=y;
printf("Le max est : %d",max) ;
int x = 5, y = 4, max;
max = (x>y) ? x : y;
printf("Le max est : %d",max) ;
int x = 5, y = 4;
printf("Le max est : %d",(x>y) ? x : y) ;
Notes :
expression_const_1,expression_const_2,,expression_const_n
ment tre distinctes.
31
doivent
obligatoire-
Description :
L<expression> est value puis le rsultat est compar chacune des expressions
constantes spcifies aprs les diffrentes cases. Si l<expression> vaut l<expression_const_i>,
lexcution se poursuit par l<instruction_i> jusqu la fin du switch moins de rencontrer une
instruction break qui permet de la terminer. Si l<expression> ne correspond aucune
<expression constante> alors l<instruction_par_dfaut> qui sera excuter.
Diagramme syntaxique de switch :
Dbut de switch
Evaluer
lexpression
expression
==
expression_const_1 ?
non
oui
oui
non
oui
instruction_1
break ?
expression
==
expression_const_2 ?
break ?
non
oui
instruction_2
non
expression
==
expression_const_n ?
instruction_n
non
oui
break ?
instruction_par_dfaut
non
oui
Fin de switch
32
Exemples :
void main()
{
int jour;
printf("Entrez le numro dun jour de la semaine (1 7) : ");
scanf("%d",&jour);
printf("Le jour %d de la semaine est le ",jour);
switch (jour)
{
case 1 : printf("DIMANCHE");
break;
case 2 : printf("LUNDI");
break;
case 3 : printf("MARDI");
break;
case 4 : printf("MERCREDI");
break;
case 5 : printf("JEUDI");
break;
case 6 : printf("VENDREDI");
break;
case 7 : printf("SAMEDI");
break;
default: printf("Erreur!");
}
}
2. Instructions
void main()
{
int jour;
printf("Entrez le numro dun jour de la
semaine (1 7) : ");
scanf("%d",&jour);
printf("Le jour %d de la semaine est le ",jour);
if (jour == 1)
printf("DIMANCHE");
else if (jour == 2)
printf("LUNDI");
else if (jour == 3)
printf("MARDI");
else if (jour == 4)
printf("MERCREDI");
else if (jour == 5)
printf("JEUDI");
else if (jour == 6)
printf("VENDREDI");
else if (jour == 7)
printf("SAMEDI");
else
printf("Erreur!");
itratives
Les instructions itratives ou boucles sont ralises l'aide d'une des trois instructions de
contrle suivantes : do-while, while et for.
2.1 Instruction do-while <faire-tant que> :
La boucle do-while permet de rpter une instruction ou un bloc dinstructions, un certain
nombre de fois, tant qu'une condition est vrifie.
Syntaxe :
do
<instruction> /*ou <bloc dinstructions> */
while (<expression>);
33
Description :
La boucle do-while dbute par lexcution de l<instruction>, puis l<expression> est
value. Tant quelle est VRAIE, lexcution de l<instruction> est rpte ; lorsquelle devient
fausse, le programme quitte la boucle et passe aux instructions suivantes.
Diagramme syntaxique :
Dbut de
do...while
Instruction
oui
Expression != 0
non
Fin de
do...while
Remarques :
L<instruction> est excute au moins une fois, car le test de l<expression>
seffectue la fin de la boucle.
Exemples :
#define PI 22/7.0
void main ()
{
float rayon ;
do
{
printf("Donnez le rayon : ") ;scanf("%f",&rayon);
if(rayon < 0) printf("\aLe rayon doit tre positif\n") ;
}while (rayon < 0);
printf("Aire = %.2f",rayon*rayon*PI);
}
#include <stdio.h>
void main ()
{
char rep ;
do
{
.
printf("Vous-voulez continuer (o/n) : ") ;
scanf(" %c",&rep); /* rep = getche(); */
}while (rep == o || rep == O);
}
while (<expression>)
<instruction>; /*ou <bloc dinstructions>*/
Diagramme syntaxique :
Dbut de
while
Expression != 0
non
35
oui
Instruction
Fin de
while
Exemple :
#include <conio.h>
void main ()
{
int color = 1 ;
while (color <= 15)
{
textcolor(color) ;
cprintf("Couleur N %d\n\r", color++) ;
}
}
Exercice 4 :
Ecrire un programme qui demande un entier positif n et qui affiche la somme des n premiers
entiers.
Solution :
36
Exercice 5 :
Ecrire un programme qui calcule la somme des nombres positifs donns par l'utilisateur, le
programme lira des nombres tant qu'ils seront positifs.
Solution :
Description :
La boucle for sutilise avec trois expressions, spares par des points virgules :
expression_1 : est value une seule fois, au dbut de lexcution de la boucle .
Elle sert initialiser les donnes de la boucle.
expression_2 : est la condition dexcution de l<instruction> rpter. Elle est
value et teste avant chaque parcours de la boucle. Si son rsultat est
VRAI alors l<instruction> est excute sinon la boucle est termine.
expression_3 : est value aprs lexcution de l<instruction> rpter. Elle
utilise pour mettre jour les donnes de la boucle.
37
Diagramme syntaxique :
Dbut de
for
Expression_1
Expression_2 !=0
non
Fin de
for
oui
Instruction
Expression_3
Remarques :
Expression_1,
expression_2
et
expression_3
sont
facultatives.
Si
Quand tout le traitement peut tre spcifi dans les trois expressions du for,
linstruction rpter peut se rduire une instruction vide.
38
Exemples :
#include <stdio.h>
void main ()
{
int m,i ;
printf("Donnez le multiplicande compris entre 1 et 9 : ") ;
scanf("%d",&m);
printf("\n\t\t\tTable de multiplication par %d\n",m) ;
for (i=1; i <= 10 ; i++)
printf("%2d x %2d = %2d\n",m,i,m*i) ;
}
Exercice 6 :
Ecrire un programme qui affiche la somme des n premiers termes d'une progression arithmtique
de raison r et de premier terme m.
Par exemple, si n = 7, r = 3 et m = 23 alors somme = 23 + 26 + 29 + 32 + 35 + 38 + 41 = 224
Solution :
39
#include <stdio.h>
#include <conio.h>
void main ()
{
int m,n ;
for (m=1; m <= 9 ; m++)
{
clrscr();
printf("\t\t\tTable de multiplication par %d\n\n",m) ;
for (n=1; n <= 10 ; n++)
printf("\t\t\t\t%2d x %2d = %2d\n",m,n,m*n);
getch();
}
}
Lorsque lon imbrique des instructions for, il faut veiller ne pas utiliser le mme
compteur pour chacune des instructions.
40
#include <stdio.h>
void main()
{
int i = -1;
do
{
printf("La valeur du compteur vaut : %d\n", ++i);
if(i == 10) break;
}while(1) ;
}
Remarques :
Linstruction break ne peut tre utilise que dans le corps d'une boucle ou d'un
switch.
Laction de break ne sapplique qu la boucle la plus intrieure dans laquelle elle
se trouve. Elle ne permet pas de sortir de plusieurs boucles imbriques.
4.2 Linstruction continue
Elle relance immdiatement la boucle while, do, for, dans laquelle elle se trouve.
pour les boucles while et do, la condition darrt est immdiatement rvalue.
pour la boucle for, on passe lvaluation de l<expression_3>. C'est pour cette
raison que l'quivalence entre le for et le while n'est pas totale.
Exemple :
#include <stdio.h>
void main()
{
int i;
for(i=0; i<=20; i++)
{
if(i%2 == 0) continue;
printf("La valeur du compteur vaut : %d\n", i);
}
}
goto tiquette ;
tiquette :
void main()
{
int i,j,k;
for(i=1 ;i<=5 ;i++)
for(j=1;j<=5;j++)
for(k=1;k<=5;k++)
{
printf("i = %d; j = %d; k = %d",i,j,k);
if (i*j*k== 40) goto sortie;
}
sortie : printf("Fin du programme") ;
}
41
instruction ;
Remarque :
Il est dconseill de l'utiliser systmatiquement, elle n'est vraiment utile que dans des cas trs
extrmes.
prcdemment obtenue.
Vous constatez que si nous ne voulons pas tre oblig de demander deux fois les notes
lutilisateur, il nous faut les conserver en mmoire. Pour ce faire, il parat peu raisonnable de
prvoir 30 variables diffrentes. Le tableau va nous offrir une solution convenable ce problme.
1. Dfinition :
Un tableau reprsente un ensemble demplacements mmoire regroups dune faon
squentielle, qui portent le mme nom et contiennent le mme type de donnes. Chacun de ces
emplacements est appel lment du tableau.
Un tableau peut tre une ou plusieurs dimensions. Il ny a pas de limite au nombre de
dimensions.
donne
donne
lment 1
lment 2
lment 3
donne
lment N
42
float notes[NB_ETUDIANTS];
2.2 Initialisation dun tableau
Tout comme pour les variables simples, il est possible d'initialiser un tableau lors de sa
dclaration en mettant entre accolades les valeurs, spares par des virgules :
int Tab1[5]={10, 20, 13, 4, 5};
Tab1
10
20
13
float Tab2[5]={1.5,6.75};
Tab2
1.5
6.75
Tab3
10
75
43
44
int tab[3]={10,20,30} ;
&Tab[2]
&Tab[1]
&Tab[0]
FF07
FF06
FF05
FF04
FF03
FF02
30
Tab[2]
20
Tab[1]
10
Tab[0]
Tab
Remarques :
La notation &Tab[i] dsigne ladresse de llment Tab[i].
Exemple 2 :
#define NB_ELEVES 30
void main()
{
float notes[NB_ELEVES], som, moy;
int i, nbr;
printf("Donnez vos %d notes : \n\n", NB_ELEVES);
for(i=0, som=0; i<NB_ELEVES; i++)
{
printf("Note N%d : ",i+1);
scanf("%f",¬es[i]);
som += notes[i];
}
for(nbr=0, moy=som/NB_ELEVES, i=0; i<NB_ELEVES; i++)
if(notes[i] < moy) nbr++;
45
Exercice 1 :
Soit un tableau T ayant N lments. Transfrer les lments positifs de T dans un tableau
TPositif et les lments ngatifs ou nuls de T dans un tableau TNegatif. Afficher les tableaux
TPositif et Tnegatif.
46
i=0;
while( i<n && Tab[i]!=cible)
i++;
/* Sortie
i == n ou (i <n et Tab[i] == cible) */
2/
47
48
permutation), puis parcourir une seconde fois le tableau (de la 2me au dernier lment) pour
trouver le second plus petit lment (le second plus grand lment), le placer en 2 me position, et
ainsi de suite...
Supposons quon veut trier en ordre croissant le tableau suivant :
44
33
55
3
4
22
11
0
1
2
33
44
55
22
11
22
33
44
55
22
11
44
55
33
11
11
22
22
55
44
44
55
33
33
Rsultat
11
11
22
22
33
55
49
33
44
11
33
55
44
22
Programme :
#define Nmax 100
void main()
{
int tab[Nmax], n, i, j, temp;
do
{
printf("Donnez le nombre dlments (max. %d) : ",Nmax);
scanf("%d",&n);
}while(n<=0 || n>Nmax);
for(i=0; i<n; i++)
{
printf("Tab[%d] = ",i);
scanf("%d",&tab[i]);
}
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(tab[i]>tab[j])
{
temp = tab[i];
tab[i] = tab[j];
tab[j] = temp;
}
printf("Tableau Tri par ordre croissant : \n");
for(i=0;i<n;i++)
printf("Tab[%d] = %d\n",i,tab[i]);
}
50
Ligne 1
2 lignes
Ligne 2
4 colonnes
Reprsentation mmoire
3.3 Initialisation dune matrice
Une matrice peut tre initialise sa cration en fournissant la liste des lments ligne par ligne.
Exemples :
int MatA[2][4] = { {1, 2, 3, 4},
{5, 6, 7, 8} } ;
int MatA[][4]= { {1, 2, 3, 4},
{5, 6, 7, 8} } ;
int MatA[2][4] = {1, 2, 3, 4, 5, 6, 7, 8} ;
51
MatA
0
0
2
1
0
3
0
1
4
MatB
MatC
4
0
0
0
0
0
MatD
1
3
2
4
Mat
52
do
{
printf("Nombre de colonnes : ");
scanf("%d",&c);
}while(c<1 || c>COLMAX);
/********************** Lecture *****************/
for (i=0;i<l;i++)
for (j=0;j<c;j++)
{
printf("Mat[%d][%d] = ",i,j);
scanf("%d",&Mat[i][j]);
}
/*********************** Affichage ***************/
for (i=0;i<l;i++)
{
for (j=0;j<c;j++)
printf("%d\t",Mat[i][j]);
printf("\n");
}
}
53
54
B=
1 4 7
2 5 8
3 6 9
Exemple 2 :
A=
1 2 3
4 5 6
1 4
B= 2 5
3 6
55
exemple\0
Attention, il y a une diffrence avec la dclaration de texte3[], on pourra faire, par la
suite, texte4= "salut" mais on ne pourra pas faire texte3= "salut" , car un tableau
est analogue un pointeur constant (la dernire affectation reviendrait modifier la valeur de
ladresse associe texte3.
On portera galement attention aux diffrences dimpression dans les exemples suivants :
printf("%c",* texte4) ;/*affiche : e */
printf("%s", texte4) ;/*affiche : exemple */
fruit
fruit[0]
pomme\0
fruit[1]
abricot\0
fruit[2]
orange\0
57
fruit
pomme\0
abricot\0
Orange\0
4. Saisie de chane.
scanf({"%s",<adresse dbut de chaine>)
Effectue la saisie dune chane de caractres taps au clavier, jusqu la rencontre du
premier espace ou \n.
Attention
char * nom ;
scanf("%s",nom) ;
ne produira pas derreur de compilation, mais les caractres lus vont tre installs
nimporte o en mmoire, puisquaucune place mmoire na t rserve.
gets(<adresse dbut de chaine>)
Effectue la saisie dune chane de caractres taps au clavier, jusqu la rencontre du
premier \n. L\0 est rajout automatiquement.
gets renvoie ladresse de dbut de chane ou NULL si on est en fin de fichier.
5. Impression de chane.
printf({"%s",<adresse dbut de chaine>)
puts(<adresse dbut de chaine>)
58
c) Comparaison de chanes.
strcmp(<adresse chaine1>, <adresse chaine2>)
compare le contenu de la mmoire depuis <adresse chaine1> jusqu la rencontre
dun \0, au contenu de la mmoire partir de <adresse chaine2> jusqu la rencontre
dun \0. La valeur retourne est 0 si les chanes sont gales, une valeur ngative si chane1
prcde chane2 au sens lexicographique, ou une valeur positive si chane1 suit chane2 au sens
lexicographique.
d) Longueur de chane.
strlen(<adresse chaine1>)
La valeur retourne est la longueur de la chaine sans compter le caractre \0.
59
Nom
Adresse en hexa
val1
(9027 0FFE)
07
D0
val2
(9027 0FFA)
00
1E
84
80
val1 est cod sur 2 octets et son adresse est 9027 0FFE
val2 est cod sur 4 octets et son adresse est 9027 0FFA
60
Syntaxe : &<NomVariable>
Exemple :
printf ("Adresse de val1 : %lx", &val1);
printf ("Adresse de val2 : %p", &val2);
/* 90270FFE */
/* 9027:0FFA */
2. Notion de pointeur
Un pointeur est une variable contenant l'adresse d'une autre variable dun type donn. Il
permet donc daccder indirectement une variable.
Nom
Adresse en hexa
A :Variable
(9027 0FFE)
07
D0
90
27
0F
FE
2000
Variable pointeur
Variable pointe
61
Exemple :
int *ptr_i;
Note : Pour dclarer plusieurs pointeurs, il faut donc rpter l'toile devant chaque nom de
pointeur.
printf("Adresse de x : %p\n",&x) ;
printf("Valeur de ptr_i : %p\n",ptr_i);
10
x
ptr_i
Remarque : Une valeur usuelle pour linitialisation des pointeurs est la valeur NULL
(quivalente 0), qui reprsente un pointeur ne pointant vers rien.
62
Exercice 1 :
Quaffiche le programme suivant :
void main()
{
int A = 10 , B = 20 , C , D;
int *ptr1=NULL, *ptr2=NULL ;
ptr1 = &A;
ptr2 = &B;
C = *ptr1 + *ptr2;
ptr1 = &C;
++*ptr1;
D = *ptr1;
*ptr1 = *ptr2;
*ptr2 = D;
printf("A = %d \nB = %d \nC = %d \nD = %d", A, B, C, D);
}
6. Arithmtique de pointeurs
63
Exemple 1:
int i = 10 ;
int *ptr = &i;
printf("Valeur de ptr avant incrmentation : %p\n",ptr); /* 8E18 : FFF4 */
ptr++ ;
printf("Valeur de ptr aprs incrmentation : %p\n",ptr); /* 8E18 : FFF6 */
Exemple 2:
int i = 10 ;
int *ptr = &i;
printf("Valeur de ptr avant laddition : %p\n",ptr); /* 8E18 : FFF4 */
ptr = ptr + 2 ;
printf("Valeur de ptr aprs laddition : %p\n",ptr); /* 8E18 : FFF8 */
Exemple rcapitulatif
64
37
38
39
40
ptr--
41
42
43
44
ptr++
ptr-2
ptr+2
ptr
65
*ptr = 1;
}
Commentaires :
Comme nous lavons dj constat au chapitre 5, le nom dun tableau reprsente
ladresse de son premier lment. En dautre termes &tab[0] et tab sont une seule et
mme adresse.
ptr = tab ptr = &tab[0].
ptr + i : dsigne ladresse de llment dindice i de tab.
*(ptr + i) : dsigne llment dindice i de tab.
66
{
int tab[Nmax],i ;
for(i = 0; i < Nmax; i++)
scanf("%d", tab + i) ;
for(i = 0; i < Nmax; i++)
printf("%d\t", *(tab + i));
}
Remarques :
L'addition tant commutative, il est vrai que *(tab + i) == *(i + tab) ; on en dduit
quil ny a absolument aucune diffrence entre tab[i] et i[tab].
Aprs les instructions :
int tab[10], *ptr , i;
ptr = &tab[0] ;
*(ptr + i) peut scrire ptr[i] daprs ce quon a vu prcdemment.
*ptr + 2
*(ptr + 2)
*ptr++
ptr - tab + 1
++ptr + 3
Exercice 3 :
67
Ecrire un programme qui parcoure un tableau dentiers et qui affiche les indices des lments
nuls du tableau, sans utiliser aucune variable de type entier.
Exercice 4 :
Ecrire un programme qui ralise les oprations suivantes :
1) La lecture dun tableau.
2) Le tri par extraction.
3) Laffichage du tableau.
En utilisant la dclaration suivante : int tab[Nmax], *ptr1, *ptr2, n , temp;
t[0]
t
t[2][3]
68
Le programme suivant va nous permettre de dterminer la taille des lments dun tableau
deux dimensions :
void main()
{
int t[3][5];
printf("La taille de t[0][0] : %u\n", sizeof(t[0][0]) );
printf("La taille de t[0]
: %u\n", sizeof(t[0]) );
printf("La taille de t
: %u\n\n", sizeof(t) );
}
Affiche :
La taille de t[0][0]
La taille de t[0]
La taille de t
: 2
: 10
: 30
*(t + i) ou t[i] : tant le nom dun tableau de 5 entiers, il est converti en un pointeur vers
le premier lment de cette ligne, cest dire un pointeur de type int*.
Par consquent, les notations suivantes sont totalement quivalentes (elles correspond
la mme adresse et elles sont de mme type) :
t[0]
t[1]
t[2]
&t[0][0]
&t[1][0]
&t[2][0]
69
t
t+1
*(t[2] + 3)
t+2
t[2]
t[2] + 3
Le programme suivant affiche les adresses des lments dun tableau deux dimensions :
void main()
{
int t[3][5] ;
printf("&t[0][0]
printf("t[0]
printf("t
: %p\n", &t[0][0] );
: %p\n", t[0] );
: %p\n\n", t );
printf("&t[0][0] + 1
printf("t[0] + 1
printf("t + 1
: %p\n", &t[0][0]+1 );
: %p\n", t[0]+1 );
: %p\n\n", t+1 );
Affiche :
&t[0][0]
t[0]
t
: 8E19 : FFD8
: 8E19 : FFD8
: 8E19 : FFD8
/* FFD8 + 2 = FFDA */
/* FFD8 + A = FFE2 */
Remarque : Les expressions t[i]++ et t++ sont invalide car elles ne sont pas des objets.
Exemple dutilisation :
Le programme suivant permet de remplir et dafficher un tableau deux dimensions en
employant le formalisme pointeur .
70
#define LIGMAX 10
#define COLMAX 10
void main ()
{
int t[LIGMAX][COLMAX], i, j, l, c;
do
{
printf("Nombre de lignes : ");
scanf("%d",&l);
}while(l<1|| l>LIGMAX);
do
{
printf("Nombre de colonnes : ");
scanf("%d",&c);
}while(c<1 || c>COLMAX);
for(i=0;i<l;i++)
for(j=0;j<c;j++)
{
printf("t[%d][%d]= ",i,j);
scanf("%d",*(t+i)+j);
/*scanf("%d", t[i] + j );*/
}
for(i=0;i<l;i++)
{
for(j=0;j<c;j++)
printf("%d\t",*(*(t+i)+j) );/*printf("%d\t",*(t[i]+j) );*/
printf("\n");
}
}
71
void main()
{
/* dclaration des variables */
/* ... */
printf("Lecture du premier tableau : \n");
lecture_tableau(...);
printf("Lecture du deuxime tableau : \n");
lecture_tableau(...);
fusion_tableau(...);
printf("Affichage du tableau avant son tri : ");
affiche_tableau(...);
tri_tableau(...);
printf("Affichage du tableau aprs son tri : ");
affiche_tableau(...);
}
72
void
{
main()
lecture_tableau
...
lecture_tableau(...);
...
lecture_tableau(...);
...
fusion_tableau(...);
...
affiche_tableau(...);
tri_tableau(...);
...
affiche_tableau(...);
fusion_tableau
tri_tableau
permutation
permutation(...);
}
affiche_tableau
2. Dfinition de fonctions
La dfinition d'une fonction peut tre dcrite de la faon suivante :
type nom_fonction ([type_1 param_1,type_2 param_2, ... ,type_n param_n])
{
[<dclaration des variables internes la fonction>];
instructions;
[return expression];
}
La premire ligne de cette dfinition est appele len-tte de la fonction. Dans cet en-tte,
les diffrents lments sont les suivants :
<type> : est le type de valeur qui sera renvoye la fin de lexcution de la
fonction ("char", "int", "float", "double", "int *", ...).
o Si la fonction ne renvoie aucune valeur, on la fait alors prcder du mot-cl
void.
o Si aucun type de donne n'est prcis, le type int est pris par dfaut.
73
Type du paramtre
Paramtres formels
Type de retour
Fin de la fonction
}
En-tte de la fonction
Corps de la fonction
Remarque : Il est interdit de dfinir des fonctions lintrieur dune autre fonction.
a = min(2,3) ;
printf("Min = %d" ,a) ;
return result ;
75
Exemple :
#include<stdio.h>
int min(int a, int b) /* dfinition de la fonction min */
{
int result;
result = a < b ? a : b;
return result;
}
void main()
{
int a,b,c,d ;
scanf("%d%d%d",&a,&b,&c);
d = min(a,b);
printf("%d", min(d,c) ) ;
}
Notes :
Lors de lappel une fonction avec paramtres :
il doit y avoir autant de paramtres effectifs que des paramtres formels.
le type du paramtre effectif doit tre compatible avec celui du paramtre formel
associ.
4. Prototype de fonctions
76
Il est ncessaire que la fonction ait t dfinie ou dclare avant tout appel cette
fonction.
La syntaxe pour la dclaration est :
type nom_fonction (type_1 param_1, type_2 param_2, ...,type_n param_n); /* en_tte_fct ;*/
On parle de prototype de la fonction.
Exemples :
int min(int a, int b);
double pow(doube x, double y);
/* prototype de min */
/* prototype de pow */
Notez que les noms des paramtres sont facultatifs mais aident la lisibilit.
Exemples :
int som(int , int);
double pow(doube , double);
A quoi sert-il ?
La dclaration dune fonction permet au compilateur de vrifier que le nombre et le type
des paramtres formels sont en accord avec le prototype. Si ce contrle choue, le compilateur
signale une erreur.
De plus, la prsence dune dclaration permet au compilateur de mettre en place
dventuelles conversions des paramtres effectifs, lorsque la fonction est appele avec des
paramtres dont les types ne correspondent pas aux types indiqus dans le prototype.
Notes :
La dfinition de fonction peut aussi servir de prototype, si elle est dfinie avant
son utilisation.
Si la fonction nest pas dclare et elle est dfinie aprs son utilisation, alors le
compilateur ne contrle pas le nombre de paramtres, et considre que cette
fonction renvoie un int , cela dune part, dautre part, il utilise des rgles de
conversions systmatiques sur les paramtres effectifs : char et short vers int et
77
float vers double. Et par consquent les paramtres formels ne pourront pas tre de
types float, char ou short.
A viter !
5. Variables locales
Les variables dclares dans les fonctions sont dites locales. Elles ne sont modifiables et
accessibles que dans la fonction o elles sont dclares.
Dautre part, par dfaut, les variables locales sont temporaires. En effet, les emplacements
mmoire correspondants sont allous chaque entre dans la fonction o sont dfinies ces
variables et ils sont librs chaque sortie.
Note : les paramtres formels dune fonction sont traits de la mme manire que les
variables locales.
6. Variables globales
On appelle variable globale une variable dclare en dehors de tout fonction. Elle est
modifiable et accessible par toutes les fonctions qui suivent sa dclaration. Une variable globale
est systmatiquement permanente. Elle occupe un emplacement en mmoire qui reste durant
toute lexcution du programme.
Cet emplacement est allou une fois pour toutes au moment de ldition de liens. Elle est
initialise zro par le compilateur.
Exemple :
#include<stdio.h>
void affiche(void);
int x ;
void affiche(void)
{
printf("x = %d\n",x);
78
x++;
}
void main(void)
{
int i ;
for(i=0 ;i<3 ;i++)
affiche();
printf("x = %d\n",x);
}
Affiche
x
x
x
x
=
=
=
=
79
{
conflit_a();
printf(" a = %d, b = %d, c = %d\.n", a, b, c);
}
80
Affiche
Dbut du programme principal :
a = 10 et b = 20
dbut fonction :
A = 10 et B = 20
fin fonction :
A = 20 et B = 10
Fin du programme principal :
a = 10 et b = 20
Cet exemple montre que la transmission de paramtres par valeur reprsente un mode
dchange dinformation dans un seul sens.
Pour changer la valeur d'une variable de la fonction appelante, on procde comme suit:
la fonction appelante doit fournir l'adresse de la variable;
la fonction appele doit dclarer le paramtre comme pointeur.
On peut alors atteindre la variable l'aide du pointeur. On parle alors de passage de
paramtres par adresse.
Par consquent, pour changer les valeurs de deux variables, il suffit de transmettre en
paramtre leurs adresses :
#include<stdio.h>
void echange (int *, int *);
void main (void)
{
int n = 10, p = 20;
printf("avant lappel: n=%d et p=%d\n" , n , p);
echange(&n , &p);
printf("aprs lappel: n=%d et p=%d\n" , n , p);
}
void echange (int *a, int *b)
{
int temp;
printf("\tdbut echange: *a = %d et *b = %d\n" , *a , *b);
temp = *a;
*a = *b;
*b = temp;
printf("\tfin echange: *a = %d et *b = %d\n" , *a , *b);
}
81
Le paramtre formel correspondant peut tre dclar de deux manires diffrentes mais
quivalentes :
type *nom_tableau
type nom_tableau[]
Exemple :
#include<stdio.h>
#define Nmax 100
void affiche_tab(int t[], int n);
void lire_tab(int t[], int n);
/*
/*
/*******************************************************************/
void affiche_tab(int t[], int n)
/* void affiche_tab(int *t, int n) */
{
int i;
for (i = 0; i < n; i++)
printf("%d\t", *(t + i) );
}
/*******************************************************************/
void lire_tab(int t[], int n)
/* void lire_tab(int *t, int n) */
{
int i;
for (i = 0; i < n; i++)
{
printf("Elment %d = ", i+1);
82
scanf("%d", t+i );
/* scanf("%d ",&t[i]); */
}
}
/*******************************************************************/
void main(void)
{
int tab[Nmax], n;
printf("Donnez la nouvelle dimension du tableau : ") ;
scanf("%d",&n);
lire_tab(tab, n);
affiche_tab(tab, n);
}
type nom_tableau[][Mmax]
type (*nom_tableau)[Mmax]
Exemple:
#include<stdio.h>
#define Nmax 100
#define Mmax 100
void affiche_tab(int t[][Mmax],int n,int m);
void lire_tab(int t[][Mmax],int n,int m);
/*******************************************************************/
void affiche_tab(int t[][Mmax],int n,int m)
{
int i,j;
for(i=0; i<n; i++)
{
83
84
Avant tout travail sur un fichier, il faut louvrir dans un certain mode de travail. Quand les
travaux sont termins, il faut fermer le fichier.
2. Ouverture/fermeture de fichier.
a) Ouverture.
Syntaxe :
FILE * fopen(char * nom,char * mode)
FILE est un type descripteur de fichier
nom est une chane de caractres contenant le nom externe du fichier (nom systme).
85
mode indique le mode douverture, sous forme dune chane de caractres galement :
" r " lecture seule (erreur, si le fichier nexiste pas)
" w " criture seule(crasement, si le fichier existe)
" a" criture en fin de fichier
un + aprs le r ou w autorise la lecture.
Un t la fin du mode indique un fichier texte, un b un fichier binaire.
Si louverture choue, fopen renvoie NULL, sinon un pointeur vers un descripteur de
3. Lecture/criture de caractres.
86
Lecture de caractres.
int getc(FILE * f)
Retourne le caractre lu ou EOF (cest--dire la valeur -1).
Ecriture de caractres.
void putc(int c,FILE * f)
c est le caractre crire.
Exemple :
Copie dun fichier texte de nom entree dans un fichier texte de nom sortie ,
caractre par caractre.
int c ;
FILE *fentree, *fsortie ;
fentree=fopen(" entree ", "rt") ;
fsortie=fopen("sortie" , "wt");
while ((c=getc(fentree))!=EOF)
putc(c,fsortie);
4. Lecture/criture de lignes.
a) Lecture de lignes.
char * fgets(char * tampon, int taille,FILE * f)
Lit les caractres sur le fichier, les charge dans le tableau de caractres tampon, ou bien
jusqu ce quil ne reste quun seul caractre libre dans le tampon, et complte par \0.
Renvoie NULL en fin de fichier ou ladresse du tableau tampon sinon.
b) Ecriture de lignes.
int fputs(char * tampon,FILE * f)
87
5. Lecture/criture formates.
Lecture formate.
int fprintf(FILE * f, char * format,<liste de parametres>)
format est une chaine de caractres contenant des caractres afficher tels quels et des
spcifications de format, comme dans le printf. Le fonctionnement est analogue, sauf que
lcriture se fait dans le fichier f.
Ecriture formate.
int fscanf(FILE * f, char * format,<liste de parametres>)
fonctionnement est analogue celui de scanf.
6. Lecture/criture de blocs.
a) Lecture de blocs.
int fread(char * tampon, int taille,int nombre,FILE * f)
Le fread tente de lire nombre objets de taille taille, les installe, octet par octet dans
le tableau de caractres tampon, et renvoie le nombre dobjets effectivement transfrs.
b) Ecriture de blocs.
int fwrite(char * tampon, int taille,int nombre,FILE * f)
Le fwrite tente dcrire nombre objets de taille taille, octet par octet depuis le
tableau de caractres tampon, vers le fichier f et renvoie le nombre dobjets effectivement
transfrs.
7. Instructions de contrle.
a) Test de fin fichier.
88
int feof(FILE * f)
Renvoie 1 si fin de fichier, 0 sinon.
b) Erreur dE/S.
int ferror(FILE * f)
Renvoie 0 si pas derreur, 0 sinon.
Lerreur concerne la dernire opration dentre/sortie effectue.
c) Positionnement direct sur un octet.
A chaque fichier est associ un point de dplacement qui indique sur quel octet on est
positionn.
A louverture en lecture ou criture, on est positionn sur le premier octet. En append on
est positionn en fin de fichier.
En accs squentiel, la gestion du point de dplacement est automatique
En accs direct, ou lorsquon mlange les lectures et les critures, cest au programmeur
de se repositionner.
int fseek(FILE * f, long dep,int mode)
dep est un entier long indiquant un dplacement en octets partir dune certaine origine
dfinie par lentier mode, dont les valeurs possibles sont :
0 dbut du fichier
2 fin du fichier
1 position actuelle
Pour les valeurs 0 et 2, les dplacements sont positifs, alors que pour 1 le dplacement
peut tre sign.
N.B.
fseek renvoie 0 en cas de russite, 0 en cas dchec
d) Repositionnement en dbut de fichier.
void rewind(FILE * f)
89
quivaut
fseek(f,0L,0)
e) Position courante.
long ftell(FILE * f)
renvoie la valeur actuelle du point de dplacement .
90