1

LANGAGE DE PROGRAMMATION C : 60H

 2

TABLE DES MATIERES

CHAPITRE I : Les concepts de base de la programmation en c

CHAPITRE II : Les instructions d’entrée/sortie (de communication)

CHAPITRE III : Les structures de contrôle

CHAPITRE IV : Les tableaux et les chaines de caractères

CHAPITRE V : Les fonctions c- Programmation Modulaire

CHAPITRE VI : Les structures (enregistrements logiques)

CHAPITRE VII : Les structures de données

VII.1 Les fichiers

VII.2 Les piles

CHAP 1 : LES CONCEPTS DE BASE DE LA PROGRAMMATION EN C

1.1 Introduction
L‟informatique (information-Automatique) est le traitement automatique des
données en vue d‟obtenir des Tra
D Ré
o ite sul
Résultats
n me tat
L‟automatisation d‟un traitement
n consiste à ntle scinder en une ssuite d‟actions
élémentaires suivant un ordre séquentiel
é aut et formant ainsi un programme.
et logique
e om
Programme :-Action ati 1
s
qu
-Action 2
e
-Action n

Le programme est écrit dans un langage de programmation spécifié.

Parmi ces langages, on distingue le langage machine et les langages évolués.

 3

Langage machine
Comme son nom l‟indique, il est le seul langage directement compréhensible par
l‟ordinateur; Il est constitué de deux caractères seulement qui sont : 0 et 1 où 1
indique la présence du courant et 0 indique son absence.

Ainsi toute instruction écrite dans ce langage est une suite de 0 et de 1, ce qui
demanderait un temps considérable pour écrire tout un programme.

Dans le but de s‟affranchir de cette étape extrêmement difficile, les langages évolués
ont pris naissance.

Les langages évolués

Appelés aussi langage de haut niveau, ils sont proches du langage naturel.

Ils ont un vocabulaire spécifique, formé d‟entités lexicales couramment utilisées en

langage naturel notamment l‟anglais.

Parmi les langages évolués, nous citons entre autres : Le pascal, le C, le VB, le JAVA,
le VC, le Clipper, le C++, etc

Afin de pouvoir exécuter par l‟ordinateur un programme P 1 écrit dans un langage

évolué, il faut d‟abord le traduire en un programme P2 écrit en un langage machine.
Progr
Progr
amm
amm TRADUCTION e P2
e P1
équiv
écrit
alent
dans
Tout à P1
un langage de programmation possède donc son propre traducteur.
écrit
langa
Un traducteur peut être : en
ge
langa
Un compilateur : il traduit le programme, une seule fois, qui peut être exécuté
évolu
ge
é
autant de fois qu‟onmachi
veut.
ne
Les langages pourvus d‟un compilateur sont par ex : le Pascal, le C, le
JAVA, etc

Dans ce cas, l‟opération de traduction est appelée compilation.

Un interpréteur : il traduit le programme à chaque fois qu‟on demande son

exécution.

Ex : Des langages qui utilisent :D Base, Clipper, etc

 4

1.2 Rappel

L„Algorithmique est une technique permettant de concevoir un ensemble d‟étapes

nécessaires à suivre pour résoudre un problème quelconque (donné).

De cette manière, un algorithme est un ensemble d‟étapes à suivre en vue de traiter

un problème informatique spécifié.

La programmation quant à elle consiste à écrire un algorithme dans un langage de

programmation.

Contrairement à l‟algorithme, un programme est un ensemble d‟actions (instructions) à

faire soumettre à l‟ordinateur.

1.3 Programmer en C
1.3.1 Introduction

Le langage de programmation a été créé en 1970 par Denny RITCHIE pour la

construction du système d‟exploitation UNIX.
Le langage C est un langage professionnel alors que le pascal est un langage
pédagogique

1.3.2 Squelette d‟un programme C

Contrairement au langage pascal tout programme C doit comporter le mot

clé « main » indiquant le programme principal (fonction principal)
Pour écrire un programme C, il faut suivre et respecter le squelette suivant :

1) Déclaration des bibliothèques standards (librairies standards)

Void main (void) ou ( )
{
2) Déclaration des variables à utiliser dans le programme
3) Instructions du programme
Begin
}
Où main : représente le programme principal (en pascal) ou fraction
principal (en C)
( ) : Servent à décrire les arguments du programme (de la fonction) c.-à-d. les
paramètres d‟entrée.

{ : C‟est l‟équivalent du begin en Pascal

} :C‟est l‟équivalent de end en Pascal

 5

Void : c‟est un type indéfini au niveau du C

RMQ :

Un programme C (sous-programme C) doit recevoir des arguments d‟entrées et doit

en retour constituer des résultats.

Contrairement au pascal, les procédures n‟existent pas en langage C

Tout sous-programme C est appelé fonction.

Exemple de programmation en C :

#include<stdio.h>

Void main (void)

{ /* programme qui affiche un message hello World.*/

printf(“Hello World.\n “) ;

RMQ:Printf est une fonction prédéfinie du langage C.Il est defini dans un fichier
particulier qu‟on appelle Bibliotheque standard d‟E/S (ou Librairie Standard d‟E/S) du
langage C.Ce fichier est appelé <stdio.h>

include: est une instruction prédéfinie (directive) qui permet d‟incorporer la copie d‟une
bibliothèque dans un programme de l‟utilisateur.

Toute instruction du langage C doit être terminée par un “;”

Le symbole # montre que le mot suivant est une directive du prépocesseur

(prépocesseur: est un petit programme qui est concu pour éliminer tous ceux qui ne
sont pas utiles au compilateur ,par exemple les commentaires.

1.3.3 Les Identificateurs

Définition: un identificateur est un nom que l‟on attribue à toute entitée manipulée dans
un programme (une étiquette ,une constante ,un type,une variable,un sous-programme)

Les identificateurs sont choisis librement par le programme .Neamoins,ils obéissent à

certaines règles:
 6

1.Un identificateur est une suite de caractères alphanumériques commençant

nécessairement par une lettre (miniscule a....z ou majuscule A.....Z)

Les caractères suivants peuvent être alphabétiques ,numériques (0 à 9) ou le caractère

de soulignement (le tiret du clavier sous le chiffre 6).Il est à noter que les lettres
accentuées et le ç ne sont pas admis dans l‟écriture des identificateurs (idf)

2.Tout identificateur doit être déclaré (défini) avant son utilisation et dans la partie
déclaration des variables.

1.3.4 Les types de données

Définition :un type de données est l‟ensemble des valeurs que la variable peut prendre

Ce type peut être standard (prédéfini) par le compilateur C ou bien défini par le
programmeur lui-meme.

Il existe ,en langage , plusieurs sortes de types:

 Les entiers dont les spécificateurs sont : int, shortint, longint;

 Les flottants (réels) dont les spécificateurs sont : float, double, longdouble;

 Les caractères dont le spécificateur est: char

Type Intervalle Taille

char 0....255 ou -128....+127 8 bits(1 octet)

Shortint -128....+127 1 octect

int -32768.....+32767 2 octets

longint - 4 octets
2.147.483.648.....+2.147.483.647

float 2.9E-39.....1.7E38 6 octets

double 5.0E-324.....1.7E308 8 octets

longdouble 3.4E-4932....1.1E4932 10 octets

 7

Rmq: A partir de ces différents types de base ,sont concus les types composés et les
types structurés:

 chaîne de caractères (types composés);

 le type énuméré;

 le type fichier;

 le type tableau;

 type enregistrement.

1.3.5 Déclaration des variables

Une variable est une donnée dont la valeur est modifiable,qui possède un type ,un
nom et une adresse.

La déclaration d‟une variable suit toujours la syntaxe suivante:

type variable nom1=valeur 1;

Elle doit toujours se trouver au début de la fonction qui la possède.

EX: Déclaration et initialisation des variables:shortint x=40,n=100,k;

float pi=3.14,moyenne;

char lettre= „v‟;

1.3.6 Déclaration des constantes

Définition: Les constantes sont des données dont la valeur ne peut être modifiée

Elle possède ,tout comme les variables,un type,un nom et une

adresse.Leur déclaration se fait en précédant le type de la constante du mot-clé:”const”

Ex: const float pi=3,14;

1.3.7 Déclaration des bibliothèques standards

Une bibliothèque standard appelée aussi librairie standard est un fichier particulier du
compilateur C,livrable avec le même compilateur et contenant des fonctions prédéfinies
du même compilateur.
 8

Une bibliothèque standard est incorporée dans un programme en utilisant une directive
appelée “include” .

Ex: #include<stdio.h>

void main()

printf (“rien.”);

1.3.8 Les opérateurs de manipulation de données

Les opérateurs permettent la manipulation des données du progrmme en les combinant

entre elles.La programmation fait distinguer plusieurs types d‟opérateurs:

a) Les opérateurs arithmétiques

Ils permettent le calcul de la valeur d‟une expression arithmétique.

Symbole Opérateur

+ Addition

- Soustraction

* Multiplication

/ Division entière

% Reste de la division

N.B : Pour pouvoir avoir un nombre réel ,on utilisera le casting .

→ y=(float) 10/3

b) Les opérateurs logiques

Ces opérateurs sont appliqués à des données de type booléen et renvoient un résultat
de type booléen.
 9

Opérateur logique Fonction

& & (et) Cet opérateur réalise une conjonction entre 2

Valeurs booléennes.

II(OU) Cet opérateur réalise une disjonction entre

deux valeurs booléennes

!(non)
C'est un opérateur unaire. Il réalise une
négation d‟une valeur booléenne.

c) Les opérateurs relationnels

Ils permettent de comparer deux valeurs de même type en un résultat booléen.

Symbole Relation

< inférieur

> Supérieur

<= inférieur ou égal

>= supérieur ou égal

== égalité

!= Différence
 10

1.3.9 Les séparateurs et les commentaires

10 Les séparateurs
Un séparateur est un caractère séparant 2 objets d‟un même programme (variable,
instruction,…).Les séparateurs existant sont :

-Le caractère « espace »qui permet de séparer 2 entités lexicales dans une même ligne

-Le caractère « \n» indiquant la fin d‟une ligne

-Le caractère «, »permettant de séparer 2 étiquettes dans la même rubrique

« déclaration des étiquettes », ou 2 variables de même type dans la rubrique
« déclaration des variables », et

-Le caractère « ; »permettant de séparer 2 instructions

20 Les commentaires
Il est parfois utile d‟insérer dans un même programme des remarques permettant de
rappeler la signification de certaines variables ou les faits d‟une instruction.

Ces remarques appelées commentaires peuvent être placés en importe quel endroit du
programme et s‟étendre sur plusieurs lignes.

Pour insérer un commentaire sur une seule ligne, on utilise les caractères;//

Pour insérer un commentaire se trouvant sur plusieurs lignes, on utilise les caractères
/*……….

………….

………….*/

1.3.10 Opération d’affectation ou d’initialisation

Pour initialiser une variable ou une valeur a une variable, on utilise le symbole=.on peut
initialiser une variable dès la déclaration. Ex :

void main (void)

{int i=4;// définition d‟une variable de type int

float j, k=2.5; /*déclaration de deux variables de type float */}

 11

CHAP2 : LES INSTRUCTIONS D’E/S OU DE COMMUNICATION

Les instructions d‟E/S en C permettent de lire une donnée introduite au

clavier et / ou de l‟afficher à l‟écran.

De ce fait, elles permettent en échange entre l‟homme et l‟ordinateur

Entrée des données

HOMME ORDINATEUR

Sortie des données

2.1 Entrée des données ou lecture des données

Le langage C utilise en général la fonction « scanf »pour lire les données de tout type
provenant du clavier.
La syntaxe de cette fonction est la suivante : Scanf (« contrôle », adresse var1,…,
adresse var n)
La partie « contrôle »précise le format d‟entrée c.-à-d. le type de la donnée à lire.
La partie adresse var i représente l‟adresse de la variable i qui va contenir la donnée à
lire
A cet effet, on utilise l‟operateur & (e-commercial)
RMQ : Le format d‟entrée est indiqué par le caractère % suivi de la lettre indiquant le
type de la donnée (d, s,f,c).
De plus, le format d‟entrée doit être écrit entre « »
Ex : void main (void)
{int i; float x;
//Lecture d‟un entier: scanf (“%d”, &i)
// Lecture d‟un réel : scanf (« %f »,&x) ;
/*Lecture d‟un entier suivi de celle d‟un réel :
scanf (« % d % f »,&i,&x) */
 12

NB : Le langage C reconnait d‟autres fonctions de lecture de données telle que la

fonction :
. « getch () »qui réalise la lecture avec écho
. « getche () »qui réalise la lecture sans écho, etc.

2.2 Sortie ou affichage des résultats

Le langage C utilise en général la fonction « printf » pour éditer (afficher) le résultat à
l‟ecran. La syntaxe de cette fonction est la suivante : printf (« contrôle », var1,….,var n );
La fonction printf permet un affichage formaté.

Dans une fonction printf, on peut spécifier :

 Un ou plusieurs noms des variables ou d‟expressions

 Un texte

 Le format d‟affichage (de sortie)

RMQ :

Pour afficher un texte, la partie contrôle est optionnaire tandis que pour afficher une
valeur contenue dans une variable, la partie contrôle s‟avère obligatoire.la partie
contrôle précise le format d‟affichage c.-à-d. le type de donnée à éditer ou à afficher

EX1 : void main ()

{printf (« Bonjour » );

printf(« à tous »);

Exécution : sur l‟ecran,on aura : Bon

jour à
tous
EX2 :void main()

{int i=100;floot b=200;

printf( « voici les valeurs:\n »);

printf(“%d \n” ,i);

 13

printf “(%f \n” ,b);

Exécution : sur l‟écran , on aura :

Voici les valeurs :

100

200

Tableau de formatage

type Symbole utilize

int,shortint, longint D

char C

chaîne de caractères S

float,double F

EXERCICES

1. Ecrire un programme en c qui affiche les données suivantes :

x=100, y=400.85, v= „c‟

2. Ecrire un programme qui calcule de 2 entiers naturels.

3. Ecrire un programme qui réalise la permutation e 2 entiers naturels a et b

RESOLUTION

#include< stdio.h>
void main()¨
{int x=100;flooty =400.85;char v=c;
printf (« les données fournies sont:\n ») ;
printf(« x=%d \n »;x);
 14

printf (« y=%f et v=%c\n »;y,v) ;

}
Exécution : sur l‟écran, on aura : les données fournies sont : x=100
Y=400.85 et v=c

2.# incude<stdio .h>

void main ()

{int a,b,res // déclaration des variables à utiliser

printf(« saisie des variables a et b:\n » );

printf(« \na= »);scanf (« %d »,&a);

printf(« \n »b=);scanf (« %d »,&b);

//Traitement

res=a-b ;

//Edition du résultat

printf(« différence entre %d et %d est égale à %d »,a,b,res);

getch();

Différence entre les fonctions de printf et de scanf

1 contrairement au printf, le scanf n‟utilise jamais le symbole « \n »

Pour le printf,l‟ écriture suivante :printf (« x=%d »,x) est permise tandis que pour le
scanf,la même écriture,(« %d »,x),n‟est pas permise mais ça s‟écrit de la forme
suivante :(« %d »,&x)

3 #include< stdio.h>

void main ()

{int a,b, per; // déclaration des variables à utiliser

printf(« saisie des variables a et b:\n »);

printf (« \n a= »); scanf (« %d »,&a);

 15

printf(« \n b = »); scanf (« %d »,& b);

printf (« \n Avant permutation a=%d et b=%d »,a, b);

//Traitement

per=a;

a=b;

b=per; //édition du résultat

printf (« \n après permutation, a=d et b=%d »,a, b) :

}
 16

CHAPITRE 3: LES STRUCTURES DE CONTROLE

Les structures de controle sont des instructions qui permettent d‟exécuter les actions du
programme en obéissant a certaines conditions

3.1.Les structures alternatives

3.1.1.L‟instruction conditionnelle

L‟instruction if est une instruction structurée et peut prendre plusieurs formes.

a) if(condition) instruction;
Ex:
if(i!=j) printf(“ i et j ne sont pas égaux.”);
b) if(condition) { instruction1;

instruction2;

instruction n;

if(i==j) {printf(“i est égal à j.\n”);

printf(“i=%d”,i);

c) if(condition) A;

else B

ex: if(i<j) printf(“i est inférieur à j.\n”);

else{ printf(“i est supérieur à j.”);

i=j-1;

où Aet B représentent soit une instuction, soit un block d‟instuctions entre accolades.

RMQ: Dans la programmation,il est autorisé d‟imbriquer un if à l‟intérieur d‟un autre ou à

l‟interieur d‟un else
 17

Ex : if(a>b) if(a>b){if(n>0)z=a;

if(n>0) z=a; ≡ else z=b;

else z=b; }

else a=b-1; else a=b-1;

Dans une imbrication des if,le else qui suit immédiatement appartient au dernier if.

3.1.2 L’instuction swicth case...if

Cette instruction permet de faire un choix parmi plusieurs possibilités suivant la valeur
d‟une expression de choix appelée ”selecteur”

La syntaxe de cette instructin est la suivante:

Switch(variable_controle)

{case valeur 1: instruction1;

instruction 2;

Instruction n;

Break;

case valeur 2: instruction1;

instruction 2;

Break;

Sélecteurs

de Case valeur k: instruction1;

switch instruction 2;

Break;

Default instruction;
 18

Ex :int i;char x;

i=10;

Switch(i)

{ case 1:x=”A”;break;

case 2:x=”B”;break;

case 3:x=”C”;break;

defaut:x=”∆”;

RMRQ: 1)Les sélecteurs de switch sont nécessairement de type entier ou caractère ça

ne peut pas être ni un réel ni une chaîne de caractères

2)La variable de contrôle peut être soit une simple variable,soit une expression,soit une
fonction qui retourne une valeur.

3)L‟instruction break permet de sortir du bloc switch une fois terminée l‟exécution d‟un
sélecteur quelconque, sinon les instructions qui suivent le sélecteur choisi seront
exécutées automatiquement (de suite).

Exercices

1.Ecrire un programme C qui calcule le minimum entre 2 nombres a et b

2. Ecrire un programme C qui calcule le maximum entre 3 nombres a,b et c

3. Ecrire un programme C qui réalise la résolution de l‟équation du 2nd degré

4. Ecrire un programme C qui permute et affiche 3 nombres a,b et c de facon croissante

 19

Résolution

1.#include<stdio.h>

Void main(void)

{ int A,B,min,max;

//lecture des données

printf(“entrer les données A et B:\n”);

printf(“\n A=”);scanf(“%d”,&A);

printf(“\n B=”);scanf(“%d”,&B);

//traitement

if(A<B){min=A;max=B;}

else {min=B;max=A;}

//Edition des résultats

printf(“le minimum est:%d et le maximum est:%d”,min,max);

2. #include<stdio.h >

void main (void )

{ int A, B, C, Max ;

// Lecture des données

printf (« Entrez les données A, B et C:\n ») ;

printf ( « \n A= ») ; Scanf ( « %d »,&A ) ;

printf ( « \nB= »), Scanf( « %d »,&B ) ;

printf ( « \nC= »),Scanf(« %d »,&C ) ;

//Traitement

if ( A>=B ) Max=A ;
 20

else Max =B ;

if(Max >=C) Max=Max

else Max =C ;

//Affichage

printf (« Le maximum entre %d, %d, %d, est: %d \n », A, B, C ,Max) ;

4) #include<stdio.h>

Void main (void)

{ int A,B,C Per ;

textbackground(RED);// change de couleur

clrscr ; //efface l‟écran noir

// Lecture des données

printf(« Entrez les données A, B et C : \n ») ;

printf(« \nA= ») ;Scanf (« %d » ,&A) ;

printf(« \nB= ») ; Scanf(« %d »,&B) ;

printf(« \nC= ») ;Scanf(« %d »,&C) ;

// Traitement

if (A>B) {per=A ;A=B ; B=Per ; }

if(A>C) { per=A ; A=C ; C=per ; }

if(B>C){per=B ;B=C ;C=per ;}

// Affichage

printf(« La permutation de %d, %d et %d par ordre croissante est la suivante : %d, %d

et %d \n », A, B, C, A, B, C) ;

}
 21

3.2 Les structures répétitives

Les instructions répétitives appelées instructions itératives permettent d‟exécuter

une instruction plusieurs fois. Ce type d‟instruction est appelé Boucle.

Dans une boucle, le nombre de répétitions peut être connu, fixé à l‟avance comme il
peut dépendre d‟une condition permettant l‟arrêt et la sortie de cette boucle.

3.2.1 L’instruction « while »

Cette boucle est utilisée au cas où le nombre de répétitions est connu ou inconnu

Syntaxe : while ( condition )instruction ;

Ou while ( condition) { instruction 1 ;

instruction 2 ;

instruction k ;

Ex : int i =5 ;

while(i !=0)

{printf(« i=%d.\n »,i) ;

i=i/2 ;

printf(« fini.»)

Déroulement :
i=
5

i=
2

i=
1

Fi
ni
.
 22

3.2.2 L’instruction « do…while »

Dans la boucle do…while, on exécute une 1ère fois la séquence d‟instructions

puis on évalue la condition : Si elle donne un résultat vrai, la boucle est finie, Si elle
donne un résultat faux, on réexécute la séquence d‟instructions et ainsi de suite jusqu‟à
ce qu‟elle soit vérifiée pour permettre la sortie de le boucle.

Syntaxe: do instruction ; while ( condition ) ;

Ou

do{ instruction1 ;

instruction 2 ;

instruction k ;

while( condition ) ;

Exemple : int i=5

do { printf(« i=%d.\n »,i)

i=i/2 ;

while ( i==0) ;

printf(« fini. ») ;

Déroulement : i
=
5

i
=
2

i
=
1

f
i
n
i
.
 23

3.2.3 L’instruction « for »

Cette boucle est utilisée dans le cas où le nombre de répétitions est connu.

Syntaxe : for ( exp1 ; exp2 ; exp3)instruction ; ou for (exp1 ;exp2 ;exp3) { instruction1 ;

instruction 2 ;

instruction k ;

Initialisation du compteur La condition d‟arrêt La manière de modifier

le compteur

Exemple : int i ;

for (i=2 ; i<=4 ; i=i+1)

printf (« i=%d.\n »,i ) ;

Déroulement : i
=
2

i
0
RMQ : 1 / L‟expression exp1 peut comporter plusieurs initiations =
3
20/ L‟expression exp3 peut comporter plusieurs actions de fin de la
boucle for séparées par des virgules(,). Cela est aussi valable ipour
=
l‟expression exp2 qui peut comporter plusieurs conditions d‟arrêt reliées
entre elles par des expressions logiques. 4

Ex: int I,j;

for(i=2 , j=5 ; i<=4& & j!=2 ; i=i+1,j=j /2)

printf(“ i=%d j=%d.\n “,i,j) ; I

=
2) En C, la notation i=i+1 est équivalente a i++. De même, la notation i=i-13 est
équivalente a i--

I
=
 24

3) De la même manière que l‟instruction if, l‟imbrication des boucles est possible et
toujours fréquente dans la programmation.

EXERCICES

1. Ecrire un programme qui calcul le factoriel d‟un nombre n donné

2. Ecrire un programme qui calcul la somme des n premiers nombres naturels

3 .Ecrire un programme qui calcul le PGCD de 2 nombres entiers A et B

4. Dérouler le programme suivant :

#include<stdio.h>

#include<ctype.h>

void main(void)

int i,j ;

printf("\n déroulement du programme :") ;

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

for (j=i+1 ;j<4 ;j++)

printf("\n i=%d et j=%d",i,j) ;

printf("\n fin du déroulement du programme.")

getch() ;

Résolution

#include<stdio.h>

void main(void)

{
 25

int i,n,fact ;

printf("\n préciser le nbre n :") ;

scanf("%d",&n) ;

if(n<o) printf("\n saisie d‟un nombre négatif.")

else

{fact=1 ;i=1 ;

while (i<=n){fact=fact*i ;

i=i+1;

printf("\n Le factoriel du nombre %d est :%d",n,fact) ;

void main (void) ou bien void main (void) ou ()

{ longint som,i,n ; {int n,som=0 ;i=0 ;

printf("\n entrez le nombre naturel n.") ; print("\n entrez le nombre naturel.") ;

scanf("%d",&n) ; scanf("%d",&n) ;

som=0 ; while(i<n){som=som+i;

i=0 ; i++ ;

for(i=0 ;i<n ;i++) }

som=som+i ; printf("\n la somme de %d premiers

Nombres naturels est :%d",n, som) ;

printf("\n la somme de %d premiers nombres }

Naturels est :%d",n,som) ;

}
 26

4. Le déroulement du programme

i=0 et j=1 i j i
i=0 et j=2

i=0 et j=3 0 1

i=o et j=4 2

i=1 et j=2 3

i=1 et j=3 4

i=1 et j=4 5sortie

i=2 et j=3 1 2

i=2 et j=4 3

Fin du déroulement du programme 4

5sortie

2 3

5sortie

3sortie

Nb: sortie :La cdtion n‟est

pas vérifiée
 27

CHAP 4 : LES TABLEAUX ET LES CHAINES DE CARACTERES

4.1. Tableau a une dimension (=vecteur)

a)Déclaration : Syntaxe : NomType NomTableau[TailleTableau] ;

EX :1)int T[10] ; //Tableau de 10 entiers

0 1 2 3 4 5 6 7 8 9

34 8 96 12 31 0 18 9 58 20

Contrairement au langage Pascal où l‟indice d‟un tableau commence par 1,

l‟indice d‟un tableau déclaré en C commence par 0

2) float N [5]; //Tableau de 5 réels

3) char H [20];//Tableau de 20 caractères

b)Accès aux éléments du tableau

L‟accès à un élément du tableau se fait au moyen de son nom et des indices.

Ex : int T[10]; int x; ou

T[9]=20;

X=T [7];

L‟indice du tableau peut être donné par une une expression.

Ex : T [2*i+1]=100;

Rmq : Le compilateur C (ou le langage C) ne contrôle pas le dépassement de la

capacité du tableau (overflow en Pascal).

4.2. Tableau à 2 dimensions (=Matrice)

a)Déclaration

Syntaxe :NomType NomTableau[nombre de lignes] [nombre de colonnes];

Ex : int M[2][5]; //Tableau d‟entiers avec 2 lignes et 5 colonnes

 28

0 1 2 3 4

RMQ : L‟accès à un élément du tableau à 2 dimensions se fait en utilisant le nom du

tableau et les indices de la ligne et de la colonne.

Ex : M [0][1]=150;

On peut initialiser un tableau en langage C :

Ex : int M[2][5]={

{1, 2, 10, 20,40}

{-2, 0, 4, 10,50}

int T[10]={5,-2,-4,9,15,25,48,21,60,100}

//initialisation pour un vecteur.

1) Soient T1 et T2, 2 vecteurs d‟entiers.

Ecrire un programme qui recopie toutes les valeurs positives de T2 dans T1 et qui
complète T1 par des 0.

2) Soient 2 tableaux d‟entiers T1 et T2 de même dimensions N.

Ecrire un programme qui réalise la somme des éléments des 2 tableaux dans un 3ème
tableau T3 de même dimension.

3) Ecrire un programme qui réalise l‟entrée des données dans une matrice de M
et N et procède ainsi à leur affichage.

4)a)Proposer un programme qui calcule la somme des éléments de la 1ère

diagonale d‟une matrice carrée de dimension N.

b) Ecrire un programme qui calcule la somme des éléments de la 2 ème

diagonale d‟une matrice carrée de dimension N.

5) Proposer un programme qui construit le triangle de Pascal de degré n

 29

Résolution

1. #include<stdio.h>

void main()

float T2[100],T1[100];int i,j,N;

printf ("\n donner la dimension des vecteurs :");

scanf("%d",&N);

printf ("\n entrer les éléments de T2 :");

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

{printf("\n %d emet élément ",i+1) ;

scanf("%d",&T2[i]);

//Traitement

j=0;

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

if(T2[i]>=0){T1[j]=T2[i];

j=j+1;

//Affectation des zéros

while(j<N)

{T1[j]=0;j++;}

}
 30

Raisonnement

T2

10 -2 0 -8 11 12 15

T1

10 0 11 12 15 0 0

2 # include<stdio.h>

void main()

{ int t1[10],t2[10],t3[10],i,n;

printf( "\n Donner la dimension des tableaux");

scanf("%d",&n);

printf("\n Entrer les éléments du tableau t1");

for(i=0;i<n;i++) { scanf("%d";&t1[i]); printf(" ");}

printf("\n Entrer les éléments du tableau t2");

for(i=0;i<n;i++) {scanf("%d",&t2[i]); printf(" ");}

for(i=0; i<n; i++) t3[i]= t1[i]+ t2[i];

printf("\n les éléments du tableau t3 sont:");

for(i=0;i<n;i++) { scanf ("%d"; t3[i]); printf(" ");}

3 # include<stdio.h>

void main()

{ int P[100] [100] ,i,j,N,M;

printf("\n Entrer successivement le nombre de lignes N et le nombre de colonnes M. \n");

 31

scanf("%d %d ",N,M);

printf("\n Entrer les éléments de la matrice P");

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

{for(j=0; j<M; j++)

{scanf("%d %d ",&P[i] [j]); printf(" ");}

printf("\n");

printf("\n les éléments de la matrice P sont:");

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

{for(j=0; j<M; j++)

printf ("%d %d ", P[i] [j]); Printf("\n");}

4 # include<stdio.h>

void main()

{ int P[100] [100] ,i,j,N,som;

printf("\n Entrer la dimension de la matrice carrée :");

scanf("%d ",&N);

printf("\n Entrer les éléments de la matrice carrée");

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

{for(j=0; j<N; j++)

scanf("%d ",&P[i] [j]).

som=0

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

{for(j=0; j<N; j++)

if( i==j) som=som+ P[i] [j]);

 32

//Affichage du résultat

printf("\n La somme des éléments de la 1ère diagonale est: %d",som);

5 # include<stdio.h>

void main()

{ int P[100] [100] ,i,j,n;

printf("\n Préciser le degré du triangle de Pascal:");

Scanf("%d ",&n);

//traitement

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

for(j=0; j<=n; j++)

if( i=j) P[i] [j]=1

else

P[i] [j]=0;

for(i=1; i<=n; i++)

P[i] [0])=1 //1èrecolonne

For(i=2; i<=n; i++)

For(j=1; j<=i; j++)

P[i] [j]= P[i-1] [j]+ P[i-1] [j-1];

//Affichage
 33

4.3 LES CHAÎNES DE CARACTÈRES

Il n'existe pas de type spécial chaîne ou string en C. Une chaîne de caractères est traitée comme
un tableau à une dimension de caractères (vecteur de caractères). Il existe quand même des notations
particulières et une bonne quantité de fonctions spéciales pour le traitement de tableaux de caractères.

4.3.1 Déclaration et mémorisation

Déclaration

Déclaration de chaînes de caractères en langage algorithmique

chaîne <NomVariable>

Déclaration de chaînes de caractères en C

char <NomVariable> [<Longueur>];

Exemples

char NOM [20];

char PRENOM [20];
char PHRASE [300];

RMQ : Lors de la déclaration, nous devons indiquer l'espace à réserver en mémoire pour le stockage de
la chaîne.

La représentation interne d'une chaîne de caractères est terminée par le symbole '\0' (NUL). Ainsi, pour
un texte de n caractères, nous devons prévoir n+1 octets.

Malheureusement, le compilateur C ne contrôle pas si nous avons réservé un octet pour le symbole de
fin de chaîne; l'erreur se fera seulement remarquer lors de l'exécution du programme ...

4.3.2 Mémorisation

Le nom d'une chaîne est le représentant de l'adresse du premier caractère de la chaîne. Pour
mémoriser une variable qui doit être capable de contenir un texte de N caractères, nous avons besoin de
N+1 octets en mémoire:

Exemple: Mémorisation d'un tableau

char TXT[10] = "BONJOUR !";

 34

4.4 Les chaînes de caractères constantes

* Les chaînes de caractères constantes sont indiquées entre guillemets. La chaîne de caractères vide est
alors: ""

* Dans les chaînes de caractères, nous pouvons utiliser toutes les séquences d'échappement définies
comme caractères constants:

"Ce \n texte \n sera réparti sur 3 lignes."

* Le symbole " peut être représenté à l'intérieur d'une chaîne par la séquence d'échappement \":

Ex : "Affichage de \"guillemets\" \n"

* Le symbole ' peut être représenté à l'intérieur d'une liste de caractères par la séquence
d'échappement \' :

Ex : {'L','\'','a','s','t','u','c','e','\0'}
* Plusieurs chaînes de caractères constantes qui sont séparées par des signes d'espacement (espaces,
tabulateurs ou interlignes) dans le texte du programme seront réunies en une seule chaîne constante lors
de la compilation:

"un " "deux"

" trois"
sera évalué à

"un deux trois"

Ainsi il est possible de définir de très longues chaînes de caractères constantes en utilisant plusieurs
lignes dans le texte du programme.

Observation

Pour la mémorisation de la chaîne de caractères "Hello", C a besoin de six (!!) octets.

est un caractère constant, qui a une valeur numérique:

'x'

P.ex: 'x' a la valeur 120 dans le code ASCII.

"x" est un tableau de caractères qui contient deux caractères:

la lettre 'x' et le caractère NUL: '\0'

'x' est codé dans un octet

"x" est codé dans deux octets

4.5 Initialisation de chaînes de caractères

En général, les tableaux sont initialisés par l'indication de la liste des éléments du tableau entre
accolades:
 35

Ex : char CHAINE[] = {'H','e','l','l','o','\0'};

Pour le cas spécial des tableaux de caractères, nous pouvons utiliser une initialisation plus confortable en
indiquant simplement une chaîne de caractère constante:

char CHAINE[] = "Hello";

Lors de l'initialisation par l‟appel de [] vide, l'ordinateur réserve automatiquement le nombre d'octets
nécessaires pour la chaîne, c.-à-d.: le nombre de caractères + 1 (ici: 6 octets). Nous pouvons aussi
indiquer explicitement le nombre d'octets à réserver, si celui-ci est supérieur ou égal à la longueur de la
chaîne d'initialisation.

Exemples

Exercice 4.1

Lesquelles des chaînes suivantes sont initialisées correctement ? Corrigez les déclarations fausses et
indiquez pour chaque chaîne de caractères le nombre d'octets qui sera réservé en mémoire.

a) char a[] = "un\ndeux\ntrois\n";

b) char b[12] = "un deux trois";
c) char c[] = 'abcdefg';
d) char d[10] = 'x';
e) char e[5] = "cinq";
f) char f[] = "Cette " "phrase" "est coupée";
g) char g[2] = {'a', '\0'};
h) char h[4] = {'a', 'b', 'c'};
i) char i[4] = "'o'";
 36

4.6 Accès aux éléments d'une chaîne

L'accès à un élément d'une chaîne de caractères peut se faire de la même façon que l'accès à un
élément d'un tableau. En déclarant une chaîne par:

char A[6];
nous avons défini un tableau A avec six éléments, auxquels on peut accéder par:

A[0], A[1], ... , A[5]

Exemple

4.7 Travailler avec des chaînes de caractères

Les bibliothèques de fonctions de C contiennent une série de fonctions spéciales pour le traitement de
chaînes de caractères. Sauf indication contraire, les fonctions décrites dans ce chapitre sont portables
conformément au standard ANSI-C.

4.7.1. Les fonctions de <stdio.h>

A côté des fonctions printf et scanf que nous connaissons déjà, nous y trouvons les deux
fonctions puts et gets, spécialement conçues pour l'écriture et la lecture de chaînes de caractères.

La fonction puts est équivalente a la fonction printf tandisque la fonction gets est équivalente a la fonction
scanf.

Ex : puts(TXT); //est équivalent à printf("%s\n",TXT);

puts("Bonjour"); //est équivalente a prinf(("Bonjour \n") ;

- Affichage de chaînes de caractères

Exemples

char TEXTE[] = "Voici une première ligne.";

puts(TEXTE);
puts("Voici une deuxième ligne.");

- Lecture de chaînes de caractères

gets (ligne) ;// est équivalente à scanf("%s",ligne) ;

 37

Exercices

Ecrire un programme qui lit 5 mots, séparés par des espaces et qui les affiche ensuite dans une ligne,
mais dans l'ordre inverse. Les mots sont mémorisés dans 5 variables M1, ..., M5.

Exemple

voici une petite phrase !

! phrase petite une voice
Resolution

#include <stdio.h>
main()
{
char M1[30], M2[30], M3[30], M4[30], M5[30];
printf("Entrez 5 mots, séparés par des espaces :\n");
scanf ("%s %s %s %s %s", M1, M2, M3, M4, M5);
printf("%s %s %s %s %s\n",M5, M4, M3, M2, M1);
return 0;
}

Exercice 2

Ecrire un programme qui lit une ligne de texte (ne dépassant pas 200 caractères) la mémorise dans une
variable TXT et affiche ensuite:

a) la longueur L de la chaîne.

b) le nombre de 'e' contenus dans le texte.

c) toute la phrase à rebours, sans changer le contenu de la

variable TXT.

d) toute la phrase à rebours, après avoir inversé l'ordre des

caractères dans TXT:

voici une petite phrase !

! esarhp etitep enu iciov

RESOLUTION

#include <stdio.h>
 38

main()
{
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I,J; /* indices courants */
int L; /* longueur de la chaîne */
int C; /* compteur des lettres 'e' */
int AIDE; /* pour l'échange des caractères */

/* Saisie des données */

printf("Entrez une ligne de texte (max.200 caractères) :\n");
gets(TXT); /* L'utilisation de scanf est impossible pour */
/* lire une phrase contenant un nombre variable de mots. */

/* a) Compter les caractères */

/* La marque de fin de chaîne '\0' est */
/* utilisée comme condition d'arrêt. */
for (L=0; TXT[L]; L++)
;
printf("Le texte est composé de %d caractères.\n",L);

/* b) Compter les lettres 'e' dans le texte */

C=0;
for (I=0; TXT[I]; I++)
if (TXT[I]=='e') C++;
printf("Le texte contient %d lettres \'e\'.\n",C);

/* c) Afficher la phrase à l'envers */

for (I=L-1; I>=0; I--)
putchar(TXT[I]); /* ou printf("%c",TXT[I]); */
putchar('\n'); /* ou printf("\n"); */

/* d) Inverser l'ordre des caractères */

for (I=0,J=L-1 ; I<J ; I++,J--)
{
AIDE=TXT[I];
TXT[I]=TXT[J];
TXT[J]=AIDE;
}
puts(TXT); /* ou printf("%s\n",TXT); */
return 0;
}
 39

Exercice 3

Ecrire un programme qui lit un texte TXT (de moins de 200 caractères) et qui enlève toutes les
apparitions du caractère 'e' en tassant les éléments restants. Les modifications se feront dans la même
variable TXT.

Exemple:

Cette ligne contient quelques lettres e.

Ctt lign contint qulqus lttrs.

RESOLUTION
#include <stdio.h>
main()
{
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I,J; /* indices courants */

/* Saisie des données */

printf("Entrez une ligne de texte (max.200 caractères) :\n");
gets(TXT);
/* Eliminer les lettres 'e' et comprimer : */
/* Copier les caractères de I vers J et incrémenter J */
/* seulement pour les caractères différents de 'e'. */
for (J=0,I=0 ; TXT[I] ; I++)
{
TXT[J] = TXT[I];
if (TXT[I] != 'e') J++;
}
/* Terminer la chaîne !! */
TXT[J]='\0';
/* Edition du résultat */
puts(TXT);
return 0;
}

4.8 Les fonctions de <string.h>

La bibliothèque <string> fournit une multitude de fonctions pratiques pour le traitement de chaînes de
caractères. Voici une brève description des fonctions les plus fréquemment utilisées.

Dans le tableau suivant, <n> représente un nombre du type int. Les symboles <s> et <t> peuvent être
remplacés par :
 40

* une chaîne de caractères constante

* le nom d'une variable déclarée comme tableau de char

* un pointeur sur char (voir chapitre 9)

Fonctions pour le traitement de chaînes de caractères

fournit la longueur de la chaîne sans compter le '\0' final

strlen(<s>)

strcpy(<s>, <t>) copie <t> vers <s>

strcat(<s>, <t>) ajoute <t> à la fin de <s>

compare <s> et <t> lexicographiquement et fournit un

strcmp(<s>, <t>)
résultat:

 négatif si <s> précède <t>

si <s> est égal à

 zéro
<t>

positif si <s> suit <t>

strncpy(<s>,<t>,<n>) copie au plus <n> caractères de <t> vers <s>

strncat(<s>,<t>, <n>) ajoute au plus <n> caractères de <t> à la fin de <s>

Remarques

- Comme le nom d'une chaîne de caractères représente une adresse fixe en mémoire, on ne peut pas
'affecter' une autre chaîne au nom d'un tableau:

Il faut bien copier la chaîne caractère par caractère ou utiliser la fonction strcpy respectivement strncpy:

strcpy(A, "Hello");

- La concaténation de chaînes de caractères en C ne se fait pas par le symbole '+' comme en langage
algorithmique ou en Pascal. Il faut ou bien copier la deuxième chaîne caractère par caractère ou bien
utiliser la fonction strcat ou strncat.

- La fonction strcmp est dépendante du code de caractères et peut fournir différents résultats sur
différentes machines (voir 8.5.).
 41

Exercice 4

Ecrire un programme qui demande l'introduction du nom et du prénom de l'utilisateur et qui affiche alors
la longueur totale du nom sans compter les espaces. Employer la fonction strlen.

Exemple:

Introduisez votre nom et votre prénom:

Mickey Mouse

Bonjour Mickey Mouse !

Votre nom est composé de 11 lettres.

RESOLUTION
#include <stdio.h>
#include <string.h>
main()
{
char NOM[40], PRENOM[40];
printf("Introduisez votre nom et votre prénom: \n");
scanf("%s %s", NOM, PRENOM);
printf("\nBonjour %s %s !\n", NOM, PRENOM);
printf("Votre nom est composé de %d lettres.\n",
strlen(NOM) + strlen(PRENOM));
/* ou bien
printf("Votre nom est composé de %d lettres.\n",
strlen(strcat(NOM,PRENOM)));
*/
return 0;
}

Exercice 5

Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2, les compare lexicographiquement
et affiche le résultat:

Exemple:

Introduisez la première chaîne: ABC

 42

Introduisez la deuxième chaîne: abc

"ABC" précède "abc"

Exercice 6

Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 et qui copie la première moitié de
CH1 et la première moitié de CH2 dans une troisième chaîne CH3. Afficher le résultat.

a) Utiliser les fonctions spéciales de <string>.

b) Utiliser uniquement les fonctions gets et puts.

Exercice 7

Ecrire un programme qui lit un verbe régulier en "er" au clavier et qui en affiche la conjugaison au présent
de l'indicatif de ce verbe. Contrôlez s'il s'agit bien d'un verbe en "er" avant de conjuguer. Utiliser les
fonctions gets, puts, strcat et strlen.

Exemple:

Verbe : fêter
je fête
tu fêtes
il fête
nous fêtons
vous fêtez
ils fêtent

4.9 Les fonctions de <stdlib>

La bibliothèque <stdlib> contient des déclarations de fonctions pour la conversion de nombres en chaînes
de caractères et vice-versa.

Chaîne --> Nombre

Les trois fonctions définies ci-dessous correspondent au standard ANSI-C et sont portables. Le symbole
<s> peut être remplacé par :

 une chaîne de caractères constante

 le nom d'une variable déclarée comme tableau de char
 un pointeur sur char (voir chapitre 9)

Conversion de chaînes de caractères en nombres

 43

retourne la valeur numérique représentée par <s> comme int

atoi(<s>)

atol(<s>) retourne la valeur numérique représentée par <s> comme long

atof(<s>) retourne la valeur numérique représentée par <s> comme double (!)

Règles générales pour la conversion:

 Les espaces au début d'une chaîne sont ignorés

 Il n'y a pas de contrôle du domaine de la cible
 La conversion s'arrête au premier caractère non convertible
 Pour une chaîne non convertible, les fonctions retournent zéro

Nombre --> Chaîne

Le standard ANSI-C ne contient pas de fonctions pour convertir des nombres en chaînes de caractères.
Si on se limite aux systèmes fonctionnant sous DOS, on peut quand même utiliser les
fonctions itoa, ltoa et ultoa qui convertissent des entiers en chaînes de caractères.

Conversion de nombres en chaînes de caractères

itoa (<n_int>, <s>, <b>)

ltoa (<n_long>, <s>, <b>)

ultoa (<n_uns_long>, <s>, <b>)

Chacune de ces trois procédures convertit son premier argument en une chaîne de caractères qui sera
ensuite attribuée à <s>. La conversion se fait dans la base <b>.

est un nombre du type int

<n_int>

<n_long> est un nombre du type long

<n_uns_long> est un nombre du type unsigned long

<s> est une chaîne de caractères

longueur maximale de la chaîne: 17 resp. 33 byte

<b> est la base pour la conversion (2 ... 36)

 44

Exercice 9

Ecrivez un petit programme utilisant la fonction ltoa qui sert à contrôler les résultats de l'exercice
3.3.

4.9 Les fonctions de <ctype>

Les fonctions de <ctype> servent à classifier et à convertir des caractères. Les symboles nationaux (é, è,
ä, ü, ß, ç, ...) ne sont pas considérés. Les fonctions de <ctype> sont indépendantes du code de
caractères de la machine et favorisent la portabilité des programmes. Dans la suite, <c> représente une
valeur du type int qui peut être représentée comme caractère.

Fonctions de classification et de conversion

Les fonctions de classification suivantes fournissent un résultat du type int différent de zéro, si la
condition respective est remplie, sinon zéro.

La fonction:
retourne une valeur différente de zéro,

isupper(<c>) si <c> est une majuscule ('A'...'Z')

islower(<c>) si <c> est une minuscule ('a'...'z')

isdigit(<c>) si <c> est un chiffre décimal ('0'...'9')

isalpha(<c>) si islower(<c>) ou isupper(<c>)

isalnum(<c>) si isalpha(<c>) ou isdigit(<c>)

isxdigit(<c>) si <c> est un chiffre hexadécimal

('0'...'9' ou 'A'...'F' ou 'a'...'f')

isspace(<c>) si <c> est un signe d'espacement

(' ', '\t', '\n', '\r', '\f')

Les fonctions de conversion suivantes fournissent une valeur du type int qui peut être représentée
comme caractère; la valeur originale de <c> reste inchangée:

retourne <c> converti en minuscule si <c> est une majuscule

tolower(<c>)
 45

toupper(<c>) retourne <c> converti en majuscule si <c> est une minuscule

CHAP 5 : LES FONCTION C - PROGRAMMATION MODULAIRE

5.1. Définition

a)Un module est une fonction (petit programme) spécialisée dans une tâche
quelconque.

Une fonction c est généralement spécialisée dans une seule tâche.

b) Un sous- programme est une fonction .Tous sous-programme retourne une valeur.

Cette valeur peut être définie (type +valeur) ou indéfinie c- à-d qu‟il n‟y a pas réellement
de valeur.

Une procédure Pascal est une fonction c qui retourne une valeur indéfinie.

c)Un programme c‟est un ensemble de modules (fonctions) dont une fonction

obligatoire porte le nom „‟main‟‟.

Fonction main

Programme C Fonction X

Fonction Y

d) Une fonction C peut avoir des : - arguments (=paramètres d‟entrée)

- Variables locales

- Variables globales (=partagées)

De plus, elle doit avoir un type et un nom.

e)*Une variable locale est une variable déclarée et utilisée dans une fonction.
 46

Une variable locale n‟est visible (accessible) que dans la fonction dans laquelle elle a
été déclarée.

*contrairement à la variable locale, une variable globale est visible dans tout le
programme dans lequel elle a été déclarée.

Par conséquent, elle est accessible dans toutes les fonctions qui composent ce
programme

*Une variable globale se déclare soit dans la fonction main, soit avant la fonction main

5.2 Squelette d’une fonction C

Une fonction C doit respecter le format syntaxique suivant :

[entête : {type-valeur-retournée>< idf-fonction> (<liste des paramètres formels>)

[ corps de fonction : {<déclaration des variables locales à la fonction>

<instructions>

N.B : <Type-valeur-Retournée> représente le type de résultat qui doit être retournée par
la fonction.

Ce type peut être soit standard (int float ,char) soit personnalise(étudiant ,livre , etc)

<type-valeur-retournée>sera égale a Void si la ne retourne pas de valeur.

.La partie <liste des paramètres formels> doit comporter les types des paramètres
formels.

Ces paramètres doivent être sépares par des virgules (,) s‟ils sont plusieurs.

EX : Ecrire une fonction qui calcule le maximum entre deux nombres X et Y

// 1ere sans retourner une valeur (avec void)

Void Maximum1 (int X ,int Y) ;

{if (X>Y) printf („‟In le maximum est %d „‟,Y) ;

 47

//2ème solution, retournant une valeur (avec type)

int Maximum 2 (int X ,int Y)

{int max ;

If (X>Y) max=X

else max=Y ;

return (max) ; //retourne le résultat obtenu

5.3. Quelques spécificités des fonctions C

a)Une fonction C termine son exécution pour retourner à la fonction appelante :

 soit à la rencontre de „‟}‟‟ fin de la fonction.

 soit à la rencontre d‟une instruction ‟‟return‟‟

L‟instruction‟‟ return „‟peut se trouver à n‟importe quel niveau dans la partie instruction
de la fonction.

b) En C, toute fonction non définie préalablement dans un fichier source où elle est
utilisée doit faire l‟objet d‟une déclaration sous -forme d‟un prototype.

Autrement dit, une fonction A qui appelle une fonction B doit l‟annoncer en précisant
dans la partie déclaration l‟entête B (avant la fonction A). On précise toujours le
prototype de la fonction appelée dans la partie déclaration de la fonction appelante.

La syntaxe d‟un prototype est libérée comme suit :

<type-valeur_Retournée ><idf_fonction> (typearg1 arg1 ),….,<typeargn argn) ;

Exemple : Ecrire un programme qui affiche le maximum de deux nombres

#include<stdio.h>

#include<ctype.h>

void Max (int X,intY), ;↔Void max (int,int) ;

void main ()
 48

{int a, b ;

printf( “\n Entrer le 1er nombre :‟‟) ;

scanf(„‟%d „‟ ,&a),

printf („‟In Entrer le 2eme nombre :‟‟) ;

scanf( „‟%d‟‟,&b) ;

//Appel de la fonction Max

Max (a , b) ;

} getch ( ) ;

//définition de la fonction

void Max (intX,int Y)

{if (X>Y) printf („‟\n Le max est %d‟‟, X) ;

else printf („‟\n Le max est :%d‟‟,Y) ;

Son déroulement dans la mémoire centrale :

……….

100 a (2 octets)

200 b (2 octets)

………

100 x Max

200 y

……..
 49

c)En langage c, il existe un seul mode de la transmission par valeur c.-à-d. qu‟au
moment de l‟appel de la fonction, le paramètre effectif est recopié sur le paramètre
formel.

Les paramètres effectifs sont ces paramètres passés à la fonction au moment de son
appel tandis que les paramètres formels sont ces paramètres passés à la fonction au
moment de sa définition.

100
Formels
200

100
Effectifs
200

La syntaxe de l‟appel d‟une fonction est la suivante :<idf-fonction> (<liste arguments

effectifs>) ; // on ne précise pas le type

RMQ : - Manipuler une fonction c consiste à :

1. Ecrire le corps de définition de cette fonction

2. Indiquer le prototype de cette fonction
3. Appeler la fonction en respectant la correspondance des
paramètres effectifs et formels de cette fonction
- Si une fonction doit retourner une valeur, on doit récupérer sa valeur de

retour en utilisant le symbole d‟affectation « = »

- Si une fonction doit retourner plus d‟une valeur, on doit utiliser le mode de

transmission par adresse

 Dans le cas de transmission par adresse, le contenu des paramètres effectifs est
modifié car on travaille directement avec les paramètres effectifs et non avec les
paramètres formels.
 On rappelle que dans le cas de transmission par valeur, le contenu des
paramètres effectifs n‟est pas modifiable car on travaille avec les paramètres
formels et non avec les paramètres effectifs.
d) Comment une fonction retourne-t-elle une valeur ?
 50

Une fonction retourne une valeur grâce à l‟instruction return.

L‟instruction return permet de retourner à la fonction appelante.

Syntaxe : return(<expression>) ;

(i*4-5)

Ou return (<variable>) ;

(a)

Ou return (<valeur>) ;

(100)

Exemple : Ecrire un programme qui détermine le max de 2 nombres.

# include <stdio.h>

# include <ctype.h>

int Max ( int x , int y);

void main ( )

int a ,b ,max ;

printf ("\n Donnez a :") ;scanf ("%d",& a) ;

printf ("\n Donnez b :") ;scanf ("%d",& b) ;

max=Max (a,b) ;

printf ("\n Le max est :%d",max) ;

getch( ) ;

// Définition de la fonction
 51

int Max ( int x , int y)

int m ;

if ( x>y) m=x ; m=y ;

return (max) ; // retourne le résultat obtenu

5.4. Passage des arguments par adresse à une fonction

Dans le cas de transmission des arguments par adresse à une fonction, l‟adresse est
un argument de cette fonction.

Si on veut changer un argument x par une fonction après son appel, la solution est de
transmettre l‟adresse de x. En c, l‟instruction du genre : int *a ; signifie qu‟on a déclaré
une variable entière *a et que l‟adresse de cette variable se trouve contenu dans a .

1002
adresse

Lorsqu‟on écrit *a : on dit que l‟on accède à la case mémoire dont l‟adresse est dans a.

Si on a : int x ; et si on veut récupérer l‟adresse de x , on écrit & x.

Exemple : Ecrire une fonction qui réalise une permutation de deux nombres donnés.

# include <stdio.h>

# include <ctype.h>

void Permuter (int *x , int *y) ;

 52

int a ,b ;

printf("\n Donnez a : ") ; scanf (" %d" ,& a) ;

printf("\n Donnez b : ") ; scanf (" %d", & b) ;

// Appel de la fonction de traitement

Permuter ( & a, & b) ;

printf("\n Après permutation :") ;

printf ("\n a=%d et b=%d", a,b) ;

getch( ) ;

// Définition de la fonction

void Permuter (int *x, int *y) ;

int temp ;

temp=*x ;

*x=*y ;

*y=temp ;

5.5. Les tableaux en tant qu’arguments

En langage c, un tableau est transmis par son adresse.

Ceci permet d‟économiser l‟espace mémoire car le passage de l‟adresse nous évite de
recopier tout le tableau.

L‟adresse d‟un tableau est l‟adresse de l‟élément de l‟indice 0 de ce tableau

CONVENTION EN C : Soit le tableau T de 10 entiers : int T [10] ;

&T [0] ≡T
 53

&T[0]=adresse de l‟élément de l‟indice 0 et c‟est aussi l‟adresse du tableau T. &T[0] est

équivalent à T

&T[0]=T+0=T: adresse de l‟élément de l‟indice 0

&T[1]=T+1: adresse de l‟élément de l‟indice 1

&T[2]=T+2: adresse de l‟élément de l‟indice

&T[i]=T+i: adresse de l‟élément de l‟indice i

T[0]=*(T+0)=*T :valeur de l‟élément d‟indice 0

T[1]=*(T+1) :valeur de l‟élément d‟indice 1

T[i]=*(T+i : valeur de l‟élément d‟indice i

Exemple: Ecrire une fonction qui calcule la somme des éléments d‟un tableau T donné.

# include <stdio.h>

# include <ctype.h>

int somme ( int T [100] , int dim );

void main ()

{ int T[100] ;int i , taille , som;

printf (“\n Taille du tableau :‟‟);

scanf (“%d‟‟, & taille);

for (i= ,i<taille ;i++);

{ printf (“\n %dème élément : „‟, i+1 );

scanf (“%d‟‟ , T+i);

&T[i]

// Appel de la fonction de sommation

Som= somme (T,taillle ); T T[1oo]*T

 54

printf (“\n la somme obtenue est :%d‟‟,som);

getch();

// Définition de la fonction somme

int somme (int T[100] ,int dim )

{ int som= 0 , i=0 ;

while (i < dim ) { som = som+T[i];

i ++ ;

return (som);

5.6 Les étapes de la programmation

10) Déclaration des librairies standards

20) Déclaration des constantes (ex: # definie PI=3,14)

30) Déclaration des variables globales

40) Déclaration des types personnalisés (structurés).

50) Déclaration des prototypes des fonctions de l‟utilisateur

60) Fonction principale « main »

70) Définition des fonctions de l‟utilisateur

5.7 Récapitulation

Pour écrire correctement une fontion c, il faut toujours se poser des questions
suivantes :

* La fonction doit-elle retourner une valeur ?

Si non le type de la fonction sera « void »

 55

Si oui le type de la fonction sera le type de la valeur à retourner

* Dans le cas de oui, la fonction retourne-t-elle de combien de valeurs?

Si une seule valeur , on utilisera l‟instruction return pour retourner la valeur

Si plus d‟une valeur, on utilisera le mode de transmission par adresse et le type de la

fonction peut etre “void”

*La fonction a-t-elle besoin de combien de paramètres d‟entrées?

Si aucun paramètre d‟entrée , fournir une « liste vide “ d‟argument comme dans float
fact ()

{….

Sinon, Lister tous les arguments de la fonction entre parenthèses comme dans float
fact(int x, char m, float y) ;

Sinon , listé les argument de la fonction entre parenthèses comme dans :float fact (int
x , char m,float)

Exercices

Réécrire tous les programmes déjà faits jusqu‟à présent en utilisant des fonctions
 56

CHAP 6 : LES STRUCTURES (OU ENREGISTREMENTS)

Les structures sont généralement utilisées pour définir des types personnalisés de
l’utilisateur.

Exemple : Livre

Titre Champs de la structure (= propriétés)

Auteur

Année d’édition

Editeur

côte

6.1 Définition

Une structure est une collection de données qui ne sont pas forcément tous de même type.

6.2 Déclaration

En C, la déclaration d’une structure se fait en utilisant le mot clé « struct »et en énumérant tous
les champs composant la structure ainsi que leur type.

Les types simples jusqu’alors vus (int, float, char) nous permettent de définir les types
composés tels que les structures, etc.

Ex : struct livre {char titre [30] ;

char auteur [20] ;

int Année ;

char éditeur [40] ;

char côte [30] ;

Cette définition nous donne la définition d’une structure logique composée de 4

champs. Ceci n’est pas une déclaration des données ; donc il n’y a aucune réservation d’espaces
en mémoire.
 57

!)Pour déclarer une variable de type « structure livre », on procède comme suit :

Struct livre livre 1, livre 2 ; //déclaration de 2 variables de type structure livre

Type structuré idfs des variables

Ceci aboutit à la réservation d’espace mémoire puis il y a eu déclaration des variables :

Livre1 et livre 2.

6.3 Initialisation

L’initialisation d’une structure se fait champ par champ en utilisant l’opérateur d’accès à un
champ d’une structure «.».

Ex : // Initialisation de la variable livre1

printf (« livre1:\n ») ;

printf (« \n Donnez le titre : ») ;

gets (livre1.titre) ;

printf (« \n Donnez l’auteur : ») ;

gets (livre1.auteur) ;

printf (« \n Donnez l’année d’édition : ») ;

scanf (« %d », &livre année) ;

printf (« \n Donnez la maison d’édition : ») ;

gets (livre1.editeur) ;

printf (« \n Donnez la cote ») ;

gets (livre1.côte) ;

RMQ : 1) L’accès à un champ d’une structure se fait par : <idf variable.idf champ>

2) On peut regrouper plusieurs structures dans un tableau :

Ex : Soit un tableau T d’étudiants

Supposons qu’un étudiant soit décrit : matricule, nom, prénom, et la note.

 58

T o i

Matricule --------- Matricule ------------

Nom --------- Nom ------------

Prénom --------- Prénom -------------

Notes --------- Notes -------------

L’accès à un champ quelconque d’un étudiant i du tableau T se fait par :

T[i].nom= «NIATH» ;

3) Le champ d’une structure peut être de type simple ou composé (un tableau ou
une structure)

Dans le cas d’un tableau, l’accès se fait par : T[i].notes[j]=10.75 ; //Jième note de
l’étudiant (élément) i du tableau T

4) On peut aussi avoir une structure dans une autre :

Struct date { int jour ;

int mois ;

int année ;

struct livre {char titre [30] ;

char auteur [35] ;

char date dateEdition ;

struct éditeur [40] ;

struct livre livre3 ;

Livre3.dateEdition .jour=14 ;
 59

Livre.dateEdition.mois=07 ;

Livre.dateEdition.année=2000 ;

6.4 Définition d’un type personnalisé

En C, la définition d’un type personnalisé(ou structuré) se fait à l’aide de l’opérateur

« typedef ».

La syntaxe de définition d’un type personnalisé est la suivante :

< typedef ><idf_ancien_type><idf_nouveau_type> ;

Exemple : typedef int monType ;

monType X, Y ;

monType x,y ;

Pour définir un type structuré (ex : type livre, type employé, type étudiant), On procède de la
même manière en ajoutant le mot-clé struct pour signifier qu’il s’agit d’un type structuré.

Ex : // Définition du type livre

Typedef struct {char titre [30] ;

Char auteur [30] ;

Char année ;

Char éditeur ;

Livre ;

Livre livre1, P ;

//déclaration de 2 variables livre1 et P de type livre

 60

7.Les Fichiers
7.1. Définition
Un fichier est un ensemble des données structurées(type structuré)et qui sont stockées l’une
après l’autre sur une mémoire secondaire.

* Toutes le s données d’un fichier sont de même type (entier,réel,caractère,personalisé,etc).

* La taille d’un fichier est illimitée et elle peut même varier.

* un fichier a un nom physique unique dit nom externe du fichier.

C’est ce nom externe qui est utilisé pour stocker dans la mémoire secondaire .

Ex: a:\> exemple .dat

De plus,un fichier a un nom dit nom interne.C’est ce nom interne qui est utilisé pour manipuler le fichier
en mémoire centrale.

*A un instant donné un seul élément du fichier est accessible ,soit en lécture ,soit en écriture .

Cet élément est élément pointé par la tête de Lécture /Ecriture:

Fichier

Début fin

Tête de L/E(pointeur de fichier)

7.2. Fonctionnement de la tête de L/E

*Fichier avant
‘x’
‘a’

Lecture

‘a’ ‘x’
*Fichier après
 61

Fichier avant ‘a’ ‘b’

Ecriture de ‘y’

Ecriture

*Fichier après
‘a’ ‘b’ ‘y’

REMARQUE :

* Après chaque opération de Lecture/Ecriture, la tête de L/E avance automatiquement vers la position
suivante.

*Dans un programme C, on n’utilise pas le nom physique (non externe) pour manipuler le fichier, mais à
chaque fois qu’on veut faire une opération sur le fichier, on va utiliser une variable adresse de type
fichier. C’est cette même variable qui est appelée non interne du fichier.

* En mode lecture, les données sont lues séquentiellement dans l’ordre du stockage à partir du début
du fichier.

* En mode écriture, les données sont lues séquentiellement à partir de la fin actuelle du fichier.

* Les opérations possibles s sur un fichier sont :

- L’ouverture d’un fichier - lecture d’une données dans un fichier

-fermeture d’un fichier -l’écriture d’une données dans un fichier

7.3. Déclaration d’un fichier

Syntaxe :<FILE>*<nom_interne_fichier> ;/*déclaration d’un nom
interne (=pointeur à utiliser pour manipuler le fichier en mémoire centrale*/

Ex : FILE *f ;
 62

C’est ce nom interne qui est utilisé dans toutes les opérations de manipulation
d’un fichier.

7.4. Opérations élémentaires de manipulations du fichier

a. L’ouverture d’un fichier : « fopen »

L’opération d’ouverture d’un fichier est obligatoire avant toute utilisation de ce

fichier.

Cette opération est réalisée au moyen de la fonction « fopen ».

Le rôle de l’opération d’ouverture est de réaliser par la connexion (la liaison)entre

le nom physique du fichier et le nom interne du même fichier.

REMARQUE :

*Louverture précise toujours le mode d’utilisation : soit lecture seulement, soit

écriture seulement, soit les deux à la fois, etc.

* Louverture d’un fichier en mode lecture n’est possible que si et seulement si le

fichier existe déjà.

*lorsque le fichier n’existe pas, une opération en écriture seule, le contenu du

fichier est automatiquement écrasé (pertes des anciennes données) et avons un
nouveau fichier.

Syntaxe de la fonction « fopen »:

FILE*fopen (« < nom_externe_fichier>», « <mode d’ouverture> ») ;

Mode d’ouverture : « rb » : lecture seule

read binary

« ab » : ajout des éléments à la fin du fichier

Add
 63

« wb » : écriture seule

Write

« rb+ » : lecture et écriture

La fonction fopen appartient à la librairie standard <stdio.h>.

La fonction fopen retourne une adresse de type « FILE *».c’est de cet adresse,
appelée nom interne du fichier, qui permet l’accès au fichier.

NB : Si l’opération d’ouverture échoue, la fonction fopen retourne la valeur NULL.

EX : void main( )

{FILE*g ; « Nom interne du fichier se trouvant en mémoire secondaire(MS)

Nom externe

g=fopen (« a:\>etudiant.dat », « wb »);

Nom interne extension

if (g==NULL) { printf (“\n Echec d’ouverture du fichier. ») ;

{ exist(0) ;

else printf (« \n connexion réussie. ») ;

B.Fermeture d’un fichier : ˮfcloseˮ

La fermeture d‟un fichier est réalisée par la fonction ˮfcloseˮ.

L‟opération de fermeture d‟un fichier à un rôle inverse de l‟ouverture

c. à .d qu‟elle va rompre la liaison avec le fichier physique.

Syntaxe de la fonction : fclose (<nom _interne_fichier>)

Ex : fclose(g) ;
 64

C. Ecriture d‟un fichier : ʺfwriteʺ

L‟écriture dans un fichier est réalisée par la fonction ʺfwriteʺ

Syntaxe de la fonction : fwrite (<adresse de l‟objet à écrire >, <taille

de l‟objet à écrire>, <nombre d‟objets à écrire>, <nom_interne du
fichier >,

La fonction fwrite retourne un entier qui est le nombre des objets

réellement écrits dans le fichier.

d. Lecture dans un fichier ʺfreadʺ

La lecture d‟une donnée d‟un fichier est réalisée à l‟aide de la

fonction : ʺfreadʺ.

ʺfreadʺ est une fonction qui permet le transfert (la lecture) de 1ou
plusieurs objets d‟un fichier vers une case mémoire centrale. La
fonction fread retourne un entier qui représente le nombre d‟objets
lus à partir du fichier.

Syntaxe de la fonction fread (adresse de l‟objet>, < taille de l‟objet à

lire>, <nombre d‟objets à lire>, <nom_interne du fichier>)

 Adresse de l‟objet : représente l‟adresse de la case mémoire où

seront stockés les objets lus à partir du fichier.

Exercices

1. Soit un fichier des étudiants. On supposera qu‟un étudiant est

décrit par son matricule, son nom et son prénom. Propose un
programme qui crée un fichier de 10 étudiants.
2. Propose un programme liste (affiche) le contenu du fichier créé
précédemment sur c.

RMQ: pour détecter la fin d‟un fichier, il existe une fonction prédéfinie
appelée feof c.-à-d. file end of file qui retourne la valeur 1 lorsqu‟on a
rencontré la fin du fichier et 0 sinon.
 65

La fonction feof doit recevoir en argument le nom interne du fichier c-à-d la

variable interne du fichier.

Résolution des exercices

# include < stdio.h>

# include<stdlib.h>

# include< conio.h>

# include<string.h>

// Définition du type étudiant.

Type de f struct { int matricule ;

char nom [40] ;

char prénom [40] ;

} Étudiant ;

// Déclaration des prototypes des fonctions à utiliser

void CreerFichier (char * nomFichier) ;

void EditerFichier (char * nomFichier) ;

// Fonction main

void main ( )

{char nomFichier [40] ;

printf (ʺ\n Nom externe de votre fichier :ʺ) ;

scanf (ʺ%sʺ, nomFichier) ;

// Appel de la fonction de création du fichier

. CreerFichier (nomFichier) ;
 66

// Appel de la fonction d‟édition du fichier

. EditerFichier (nomFichier) ;

} getch ( ) ;

// Fonction de création d‟un fichier de 1o étudiants

void CreerFichier (Char * nomFichier)

{FILE * f ; int i, mat ; char nom [40], prénom [40] ; etudiant E ;

f = fopen (nomFichier, ʺWbʺ) ;

if (f==NULL) {printf (\n Echec de connexion.ʺ) ; exit (0) ;}

for ( i=0 ; i < 10 ; i++ ) { printf (ʺ\n Matricule:ʺ); scanf (ʺ%dʺ ,&mat );

{printf (ʺ\n Prénom:ʺ); scanf (ʺ%sʺ ; &prenom) ;

E. matricule = mat ;

Strcpy (E. nom, nom) ;

Strcpy (E. nom, prenom);

Fwrite (&E, sizeof (etudiant), 1, f);

// Rupture de la connexion

Fclose (f);

// Fonction d‟édition du contenu du fichier

void Editer (char * nomFichier)

{FILE * f ; etudiant E ; int i = 1 ;

F = fopen (nomFichier, ʺnbʺ) ;

If (f==NULL) { printf (ʺ\n Echec. ʺ); exit (0);}

 67

While (feof (f) ==0)

{fread (&E, sizeof (etudiant), 1, f);

printf (ʺ\n Information du %dième etudiant :ʺ,i) ;

printf (ʺ \n matricule : %dʺE. matricule) ;

printf (ʺ\n Nom :%sʺ, E.nom) ; printf (ʺ/n Prenom :%,sʺ,E.Prenom) ;

} i ++ ;

Fclose (f) ;

Accès direct à un élément du fichier: fseek

On peut faire un accès direct à un élément du fichier en précisant seulement sa

position. cette position doit être donnée en nombre d‟octets .cette position est en réalité
donnée sous- forme d‟un déplacent de la tête de lecture /écriture (pointeur de fichier).
ce déplacement est en nombre d‟octects par rapport :

 au début du fichier

 à la fin du fichier

 à la position courante

La flèche qui nous permet l‟accès direct à un élément du fichier est la fonction: fseek

Cette fonction doit recevoir trois arguments :

Syntaxe : fseek(<nom_interne_fichier >,< déplacement >,<mode d‟accès >) ;

Mode d‟accès : o : le positionnement de la tête de lecture/écriture par rapport au

début du fichier

1 : le positionnement de la tête de lecture/écriture par rapport à la

position actuelle

2 :le positionnement de la tête de lecture/écriture par rapport à la fin

du fichier
 68

Ex :

Début du fichier taille(enregistrement) :3 octets

Sens+f sens-f

Fseek(f,2*3,0) ;

Fseek (f,-6,1) ;

Fseek(f,-12,2) ;

Cette fonction fseek retourne une valeur :soit 0 si l‟opération est faite
correctement soit -1 s‟il ya une erreur

La fonction fseek est une fonction qui permet le positionnement (le déplacement de la
tête de lecture/écriture)

La lecture et l‟écriture doivent toujours être faites respectivement avec les fonctions
fread et fwrite .

Ex :

En considérant le fichier des étudiants créé précédemment, proposer une fonction qui
affiche les informations du 7éme enregistrement du fichier .

void afficher Etudiant (char *nomfichier)

{file*f ;long depla;Etudiant E ;

F=fopen(nom du fichier ,”rb”) ;

if (f== NULL) {printf(« \n Echec . »;exit(1);}

Depla=(7-1)*size of (Etudiant,1,f);(car comptage à partir de 0)

if (fseek(f,depla,0)==0)

{fread(&E.size of 9Etudiant ),1,f);

printf(“\n Matricule :%d”,E.matricule);

printf (« \n nom :%s »,E.prénom) ;

}
 69

else printf (« \n positionnement échoué. ») ;

fclose(f) ;

D’autres fonctions de manipulation de fichiers

a.la fonction « ftell »

cette fonction donne (retourne) la positon courante de la tête de lecture /écriture dans le
fichier cette position est donnée en nombres d‟octets par rapport au début du fichier

syntaxe :ftell(<nom interne du fichier>) ;

ex :

long depla

depla=ftell(f)

b.la fonction «rewind »

cette fonction déplace la tête de lecture/ecriture au debut du fichir

syntaxe :rewind (<nom-intense du fichier>) ;

ex: rewind(f) ;

c.la fonction « fileno »

cette fonction retourne le numéro d‟un fichier ouvert .ce numéro est appélé handle et
est utulisé par le système d‟exploitation (S.E) pour identifier tout fichier ouvert.

syntaxe :fileno <(nom interne du fichier>) ;(toujours de tpe interne)

ex ;long taille

FILE*f ;int num ;

Num=fileno(f) ;

d.la fonction «filelength »

cette fonction retourne un résultat de type long qui donne la taille d‟un fichier.

syntaxe :filelength(<numéro du fichier>) ;

 70

ex : long taille ;

FILE*f ;int num ;

Num=fileno(f) ;

taille=filelength(num) ;

e.la fonction “chsize”

cette fonction permet de modifier la taille du fichier.

Syntaxe :chsize(<nom interne du fichier>,<nouvelle taille>) :

Nouvelle taille est exprimée en octets

NB :La fonction chsize est généralement utilisée quand on veut réaliser les opérations
d‟insertion et de suppression dans un fichier .

EXERCICES

En considérant le fichier des étudiants crée récement :

1. Proposer un programme (une fonction ) qui permet de supprimer un étudiant de

matricule donné.

2. Proposer une fonction qui permet d‟insérer un nouvel étudiant à une position donné
du fichier

7.2.5 Les fonctions textes

Un fichier peut être ouvert soit en mode binaire soit en mode texte.

Les fichiers utilisés jusqu‟à maintenant ont été ouvert en mode binaire.

Un fichier binaire est un fichier contenant des données informatiques et ne pouvant être
ouvert que par le système d‟exploitation.

Par conséquent, un fichier texte est un fichier contenant des caractères :

Pour ouvrir un fichier en mode texte, nous devons remplacer le caractère ‟b‟ par le
caractère ‟t‟ dans tous les modes d‟ouverture qu‟on a déjà vu c.à.d
« t », « rt », « rt+ », « wt », « at »….
 71

Par défaut c.à.d si on ne précise pas le mode d‟ouverture, le mode d‟ouverture à

utiliser sera le mode texte

Pour lire et écrire dans un fichier texte, nous avons 2 fonctions intéressantes.‟‟fputc‟‟ et
„‟fgetc‟‟

a. La fonction ‘’fgetc’’

Cette fonction permet de repérer un caractère à partir d‟une fichier texte. Ce caractère
est retourné par la fonction elle-même.

Syntaxe : fgetc(<nom interne de fichier >) ;

Exemple : char c ;

FILE*f ;

C=fgetc(f) ;

RMQ : S‟il y a une erreur ou une fin de fichier, le caractère retourné sera EOF(End of
file)

b. La fonction ‘’fputc’’

Cette fonction permet d‟écrire un caractère dans un fichier texte. Elle retourne le
caractère écrit s‟il n‟y a pas d‟‟erreur et le caractère EOF en cas d‟erreur.

Syntaxe : fputc(<caractère à écrire >, <nom interne du fichier,) ;

Exemple : Char c=‟a‟ ;

FILE*f ;

fputc (c, f) ;

Exercices

1. Ecrire un programme qui recopie 5 lignes de caractère sur un fichier texte.

2. Soit un fichier texte. Proposer un programme qui compte le nombre de lignes dans ce
fichier.

3. Soit un fichier texte. Proposer un programme qui compte le nombre de caractère‟‟a‟‟

contenu dans ce fichier
 72

4.Proposer une fonction qui nous donne le nombre de mots dans un fichier.

5.Proposer une fonction qui compte le nombre d‟occurrence de mot ‟‟informatique‟‟ dans
un fichier texte

6.Proposer une fonction qui calcule le nombre de tous les mots miroirs ‟‟nos‟‟ dans un
fichier texte.

. Résolution

1 # include < stdio.h >

#include < string.h >

# include <conio.h >

# incude < stdib.h > pour FILE

Void main ( )

FILE *f ; char nom fichier [ 40] ; char c ; int nbligne ;

{ printif(„‟\n nom externe du fichier :‟‟) ;gets(nom fichier) ;

f=fopen(nom fichier,‟‟Wt‟‟) ;

if (f==NULL) { printif („‟\n Echec de connexion.‟‟) ; exit (20) ;}

nbligne=0 ;

While (nbligne < 5) { c=getche ( ) ;

Scanf

While ( cꜝ = \n) { fputc ( c,f ) ; c = getche ( ) ;}

} } fputc (c,f ) ;nbligne++ :

Fclose (f) ;
 73

4. int comptemots (char nom fichier[40])

{FILE *f ;char c ; int n=0 ;

F=fopen (nomFicher,‟‟rt‟‟) ;

If (f==NULL) { printif („‟\n Echec.‟‟ ) ; exit ( 30 ) ;}

C=fgetc ( f ) ;

While (feof ( f )==0 ) // While ( c =‟EOF‟ ) // dépasser les espaces blancs

{ While ( cꜝ = „ „ ) { c = fgetc (f) ;}

N++ ; // compteur de mots trouves

C= fgetc ( f ) ;

While ( c == „ „ ) { c = fgetc ( f ) ;

While ( c == „ „ ) { c = fgetc ( f ) ; }

fclose ( f ) ;

} return ( n ) ;

Résolution de l’exercice sur les fichiers binaires

1.# include < stdio.t >

# include < canio.h >

# include < stlib.h >

Void main ( )

{ FILE *f ; char nomFichier [40] ;

Int mat,n ; long { pos,taille ;Etudiant te,E ;etu,i,n

printif („‟\n Nom externe de votre fichier ; „‟) ;

 74

gets ( nomFichier ) ;

f = fopen ( nomFichier,‟‟rb+ „‟ )

if ( f = = NULL ) { printif („‟ \n Echec .‟‟) ;

} exit ( 8 ) ;

Printif ( „‟\n Matricule de l‟etudiant à supprimer :‟‟ ) ;

Scanf ( „‟%d‟‟ f mat ) ;

fread ( fte,sizeof ( etudiant ),1,f ) ;

While ( feof ( f ) = =0 )

{ if (te. Matricule = = mat )

{ pos = ftell ( f ) ;

n = fileno ( f ) ;

Taille = filelength ( n ) ;

etu = sizeof (etudiant)

„‟Décalage des éléments d‟à droite vers à gauche

for ( i =pos ; i < taille ; i = i+ etu )

{ fseek ( f,i + etu, o ) ;

fread ( f E, etu, 1,f ) ;

fseek ( f,i, 0 ) ;

fWrite ( f E, etu, 1 , f ) ;

„‟Modification de la taille du fichier

Chsize ( f, taille-etu ) ;

}
 75

fread ( fte ,sizeof (etudiant) ,1,f ) ;

fclose ( f ) ;

Résolution de l'exercice sur les fichiers textes

# incude < stdio.h >

#include < conio.h >

#include < stdlib.h >

#include <string .h >

Void main ( )

{file *g ;char nomfichier [30]

Int nb char c

Printf ("\n nom externe du fichier:")

gets (nomfichier) ;

g=fopen (nomfichier, "rt ")

If ( g== NULL ) { printf ("\n Echec. ");exit(42);}

C= fgetc (g); nb =0 ;

While (feof (g) == 0) {if (c=='a') nb ++; c=fgetc (g);}

Printf ("\n le nombre de caractères est :%d ", nb) fclose (g) ;