Vous êtes sur la page 1sur 241

Mme khadija bouzaachane

Bref historique
Pourquoi utiliserle langage C
Cycle de développement du programme
Votre premier programme C

22/02/10 Programmer en langage C 2


Introduction : Bref historique
 Le langage C a été créé par Dennis Ritchie aux ‘Bell
Telephone Laborateries’ en 1972: il a été conçu pour
développer le système Unix.
 En raison de sa puissance et de sa souplesse, le langage C

Introduction
s’est rapidement répandue au-delà des laboratoires Bell.
 Les programmeurs ont commencé à l’utiliser pour écrire
toutes sortes de programmes
 Diverses organisations ont utilisé leurs propres versions
du langage C. Conséquence : l’implémentation est devenu
un casse-tête pour les programmeurs.
 Réponse à ce problème : l’American National Standards
Institute(ANSI) à formé un comité en 1983 pour établir le
C standard ANSI.

22/02/10 Programmer en langage C 3


Introduction : Pourquoi utiliser le langage C
 Souple et puissant : Le langage C est utilisé pour des projets
variés comme les systèmes d’exploitation, les traitements de
textes, les graphiques, les tableurs, les compilateurs pour
d’autres langages.

Introduction
 Il existe un large choix de compilateurs et d’utilitaires.
 Avec la norme ANSI, le C est devenu un langage portable: un
programme C écrit pour un type d’ordinateur(IBM) peut être
compilé pour tourner sur un autre système avec très peu ou
aucune modification.
 Le langage C est modulaire: son code peut(et devrait) être écrit
sous forme de sous-programme appelés fonctions. Si vous
passez des informations à ces fonctions, vous obtenez un code
réutilisable.
 C est un langage structuré (offre plusieurs structures de
contrôle) et typé (déclarations obligatoires).
22/02/10 Programmer en langage C 4
Introduction : Cycle de développement du
programme

 Création d’un code source en utilisant un éditeur


Le code source est une série de commandes qui

Introduction
indiquent à l’ordinateur les tâches que vous voulez lui
faire exécuter, il est créé à l’aide d’un éditeur.
La plupart des systèmes d’exploitation contiennent un
éditeur. Sous Unix vous pouvez utiliser, ed, ex, edit
emacs ou vi. Microsoft Windows vous offre le bloc-notes.

22/02/10 Programmer en langage C 5


Introduction : Cycle de développement
du programme
 Compilation du code source
 Votre ordinateur ne peut pas comprendre le code source. Il ne
peut comprendre que des instructions binaires dans ce que l’on

Introduction
appelle du langage machine. Votre programme C doit être
transformé en langage machine pour pouvoir être exécuté sur
votre ordinateur. Cette opération est réalisée par un compilateur
qui transforme votre fichier code source en un fichier contenant
le code objet(les mêmes instructions en langage machine).
 Chaque compilateur possède sa propre commande pour créer le
code objet.
○ Windows: C Microsoft, Turbo C, Turbo C++, Borland C, Borland C++.
○ Unix : utiliser la commande c.
○ Linux et Unix: la commande gcc.

22/02/10 Programmer en langage C 6


Introduction : Cycle de développement du
programme

 Création du fichier exécutable


Une partie du langage C est constituée d’une
bibliothèque de fonctions contenant du code objet

Introduction
destiné à des fonctions prédéfinies. Ces fonctions sont
fournies avec votre compilateur. Si votre programme les
utilise, le fichier objet obtenu après compilation doit
être complété par le code objet issu de la bibliothèque de
fonctions. Cette dernière étape, appelée liaison, fournit
le programme exécutable (exécutable signifie que ce
programme peut être exécuté sur votre ordinateur)

22/02/10 Programmer en langage C 7


Introduction : Cycle de développement du programme

Fichier en-tête (.h) Programme source (.c)


……………….. #include…
#include <math.h>
math .h
…..

Introduction
/*déclaration*/
Main()
{
…..
}

Bibliothèques précompilées
(.lib)

Programme objet (.obj)


…………………..

math.lib
Programme executable
(.exe)
22/02/10 Programmer en langage C 8
Introduction : votre premier programme

#include<stdio.h>

Introduction
Main()
{
Affichage Bonjour
printf(‘’Bonjour’’);
}

22/02/10 Programmer en langage C 9


Exemple de programme en langage C
Structure d’un programme en Langage C
Les mots-clés
Les types de base
Déclarations des variables simples

22/02/10 Programmer en langage C 10


Exemple de programme en langage C
#include <stdio.h>//standard input/output
#include <math.h>

Eléments de base du langage C


#define NFOIS 5
main ()
{ int i;
float x, racx;
printf("Bonjour\n");
printf("je vais vous calculer %d racines carrées\n",NFOIS);
for(i=0;i<NFOIS;i++)

Programme principal
{ printf("donnez un nombre:");
scanf("%f",&x);

Bloc
if(x<0.0)
printf("le nombre %f ne possède pas de racine carrée\n",x);
else
{ racx=sqrt(x);
printf("le nombre %f a pour racine carrée :%f\n",x,racx);
}
}
printf("travail terminé Au revoir");
}
22/02/10 Programmer en langage C 11
Exemple de programme en langage C
#include<conio.h>
#include<stdio.h>

Eléments de base du langage C


main()
{ int i,a;
clrscr();
printf("Veuiller introduire un nombre:",a);
scanf("%d",&a);
for(i=a+1;i<=a+10;i++)
{
printf("%d\t",i);
}
getch();
}
22/02/10 Programmer en langage C 12
Exemple de programme en langage C
#include<conio.h>

Eléments de base du langage C


#include<stdio.h>
#define a 4
main()
{
clrscr();
gotoxy(4,4);
printf("%d",a );
getch();
}

22/02/10 Programmer en langage C 13


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

22/02/10 Programmer en langage C 14


Structure d’un programme en Langage C
 Les directives à destination du préprocesseur

Eléments de base du langage C


#include <math.h>
Programme exécuté automatiquement avant la
#include <stdio.h> compilation, il transforme le fichier source à
#define NFOIS 5 partir d’un certain nombre de directive
 Il s’agit de directive qui seront prises en compte avant la
traduction (compilation) du programme. Ces directives
doivent être écrites une par ligne, et il est préférable de les
placer au début. Les deux premières directives demandent
d’introduire(avant compilation) des instructions(en
langage C) situées dans les fichier stdio.h et math.h. On
les appelles fichiers en-têtes.
 La troisième directive définie une constante. Elle
demande de remplacer systématiquement, dans toute la
suite du programme, le symbole NFOIS par 5

22/02/10 Programmer en langage C 15


Structure d’un programme en Langage C
 La fonction main()

Eléments de base du langage C


 est un bloc obligatoire d’un programme C. Sa forme la plus simple
consiste à saisir son nom, main, suivi de parenthèse () vide et d’une
paire d’accolades {}. L’exécution du programme débute à la première
instruction de main() et se termine avec la dernière instruction de
cette fonction.
 La définition des variables
 Une variable est un nom donné à une zone mémoire pour stocker les
données en cours d’exécution. En C une variable doit être définie
avant son utilisation. Sa définition indique son nom au compilateur
et le type de données que l’on pourra y stocker.
 Sa déclarations est de la forme
Type nom_variable [=<valeur>];
 Elle peut être déclarée à l’extérieur ou à l’intérieur de la fonction
main

22/02/10 Programmer en langage C 16


Structure d’un programme en Langage C

 Notion d’identificateur

Eléments de base du langage C


Un identificateur, comme son nom l’indique, permet de
donner un nom à une entité du programme (qu’il
s’agisse d’une variable ou d’une fonction). Ils sont sujets
aux règles suivantes :
1. Ils sont formés d’une suite de lettres (’a’ `a ’z’ et ’A’ `a ’Z’), de
chiffres (0 à 9) et du signe ’_’. En particulier, les lettres
accentuées sont interdites ;
2. le premier caractère de cette suite ne peut pas être un chiffre ;
3. les identificateurs sont case-sensitive.
Ainsi, les noms var1, S_i, et InitDB sont des
identificateurs valides, tandis que i:j ou 1i ne le sont pas.

22/02/10 Programmer en langage C 17


Structure d’un programme en Langage C
 Pour écrire des informations: la fonction printf

Eléments de base du langage C


L’instruction printf("Bonjour\n"); appelle une fonction
prédifinie(printf) qui reçoit un argument "Bonjour\n"
délimiter par des guillemets pour dire que c’est une
chaîne de caractères. La notation \n est conventionnelle
: elle représente un caractère de fin de ligne, lorsqu’il
est envoyé à l’écran, elle provoque le passage à la ligne
suivante.
L’instruction
printf("je vais vous calculer %d racines carrées\n",NFOIS);
Ressemble à la précédente avec la différence qu’il reçoit un
argument que l’on nomme un format, c’est comme un guide
qui précise comment afficher les informations, dans notre
cas le code format %d précise qu’il s’agit d’un entier.
22/02/10 Programmer en langage C 18
Structure d’un programme en Langage C
 Pour faire une répétition: l’instruction for

Eléments de base du langage C


 En langage C, il existe plusieurs façon de réaliser une
répétition, comme par exemple : for(i=0;i<NFOIS;i++), son
rôle est de répéter le bloc délimiter par les accolades, en
respectant les consignes suivantes :
○ Avant de commencer cette répétition réaliser : i=0
○ Avant chaque nouvelle exécution du bloc, examiner la condition:
i<NFOIS, si elle est satisfaite, exécuter le bloc indiqué à sa fin
réaliser i++qui n’est que i=i+1
 Pour lire les informations: la fonction scanf
 scanf("%f",&x): cette instruction n’est qu’appel de la fonction
prédéfinie scanf dont le rôle est de lire une information au
clavier
○ %f: le format de la variable
○ &x: son adresse

22/02/10 Programmer en langage C 19


Structure d’un programme en Langage C

 Pour faire le choix: l’instruction if

Eléments de base du langage C


Les lignes
if(x<0.0)
1 printf("le nombre %f ne possède pas de racine carrée\n",x);
else
{ racx=sqrt(x);
2 printf("le nombre %f a pour racine carrée :%f\n",x,racx);
}
Constituent une instruction de choix basée sur la
condition x<0.0, si cette condition est vrai, on exécute
l’instruction 1, si elle est fausse on exécute l’instruction
2.

22/02/10 Programmer en langage C 20


Structure d’un programme en Langage C

 Les commentaires

Eléments de base du langage C


/* un commentaire d’une ligne*/
Int a, b, c; /* commentaire sur une partie d’une ligne*/
/* un commentaire
Qui s’étend sur plusieurs ligne*/
//cette ligne est en commentaire
 Conseils:
Ajouter de nombreux commentaires dans le code
source de votre programme, surtout s’il contient des
instructions ou fonctions qui pourraient être difficile à
comprendre. Vous gagner un temps précieux quand
vous aurez à le modifier.

22/02/10 Programmer en langage C 21


Les mots-clés
 Un certains nombres de mots sont réservés pour le langage C, a

Eléments de base du langage C


évité comme identificateurs, la liste exhaustive est la suivante:

22/02/10 Programmer en langage C 22


Les types de base : Les caractères

Eléments de base du langage C


On utilise le mot-clé char pour désigner une variable
de type char.
char Il s’agit en fait d’un entier codé sur 8
bits interprété comme un caractère utilisé sur la
machine (il s’agit en général du code ASCII de ce
caractère).
 Exemple :
char c1 = ’a’; // Déclaration d’une variable c1 de type char
// a laquelle on affecte la valeur ’a’
// A noter l’utilisation du simple quotte

22/02/10 Programmer en langage C 23


Les types de base : Les caractères
 Le tableau suivant donne la liste des principaux codes ASCII en décimal

Eléments de base du langage C


22/02/10 Programmer en langage C 24
Les types de base : Les caractères
 Caractères particuliers
 Il existe un certain nombre de caractères particuliers dont les principaux

Eléments de base du langage C


sont résumés dans le tableau suivant :

 Chaînes de caractères
Les chaînes de caractères sont vues comme un pointeur sur des
caractères et sont donc de type char *.
*
Exemple:
○ char * chaine = "Hello World !";// une chaine de caractère
// noter l’utilisation du double
// quotte

22/02/10 Programmer en langage C 25


Les types de base : Entiers

Eléments de base du langage C


 Le type int peut être précisé par des attributs :
De longeur :
○ short pour des entiers courts(généralement de 8 ou 16 bits)
○ long pour des entiers longs(généralement de 32 ou 64bits)
○ La longeur par défaut est généralement de 16 ou 32bits
De domaine
○ signed pour les entiers relatifs
○ unsigned pour les entiers naturels positifs ou nuls

22/02/10 Programmer en langage C 26


Les types de base : Entiers

 On utilise le mot-clé int.


int

Eléments de base du langage C


 Exemple :
 /* déclaration la plus courante d’une variable de type int */
○ int a = 14; // la variable a est initialisée à la valeur 14
 /* Utilisation des précisions (cas le plus général)*/
○ short int b; // b est codé sur 16 bits
○ int c; // c est codé sur 16 ou 32 bits
○ long int d; // d est codé sur 32 bits
// la possibilité de l’écriture suivante dépend du compilateur
○ long long int e; // e est codé sur 64 bits.
/* Précision du signe */
○ unsigned long int n; //n est un entier non signé sur 32 bits

22/02/10 Programmer en langage C 27


Les types de base : Entiers
 Le tableau suivant regroupe les types entiers standards avec quelques informations
supplémentaires :

Eléments de base du langage C


22/02/10 Programmer en langage C 28
Les types de base : Entiers
 Constante entière: donnée inchangée qui ne peut varier

Eléments de base du langage C


pendant l’exécution d’un programme
Déclaration : #define Max 100
 Elle se présente sous forme décimale, octale ou hexadécimal
décimale (écriture en base 10) : c’est l’écriture usuelle. Ex :
372 ;
octale (base 8) : on commence par un 0 suivi de chiffres octaux.
Ex : 0477 ;
héxadécimale (base 16) : on commence par 0x (ou 0X) suivis de
chiffres héxadécimaux (0-9, a-f). Ex : 0x5a2b, 0X5a2b, 0x5A2b.

22/02/10 Programmer en langage C 29


Les types de base : Les flottants
 On distingue trois types de flottants : float,
float double et long double.
double
Exemple : double Pi = 3,14159;

Eléments de base du langage C


 Le tableau suivant donne des informations pour chaque type flottant.

22/02/10 Programmer en langage C 30


Les types de base : Les flottants
 Une constante réelle représente un nombre à virgule
flottante(de type float ou double) sous forme décimale ou

Eléments de base du langage C


exponentielle.
 Exemple :

22/02/10 Programmer en langage C 31


Les types de base : Le type void

Eléments de base du langage C


 Toute variable C est typée, de même que toute
valeur de retour d’une fonction. Mais il peut arriver
qu’aucune valeur ne soit disponible pour exprimer
l’idée de ”aucune valeur”, pour cela on utilise le
mot-clé void.
void Ce type est utilisé pour la déclaration
de fonctions qui n’ont pas de valeur de retour.

22/02/10 Programmer en langage C 32


Déclarations des variables simples
 Les variables et les constantes sont les données

Eléments de base du langage C


principales manipulées par un programme.
 Les déclarations introduisent les variables, fixent leur
type et parfois aussi leur valeur de départ(initialisation);
 Syntaxe de déclaration:
 int x,y;
 short compteur;
 float prix,salaire;
 double m;
 char s;

22/02/10 Programmer en langage C 33


Déclarations des variables simples

 Initialisation des variables

Eléments de base du langage C


En C, il est possible d’initialiser les variables à la
déclaration
Exemples:
○ int max=123;
○ char tab=‘c’;
En utilisant l’attribut const, la valeur d’une variable
ne change pas au cours du programme: c’est une
constante.
Exemple:
○ Const int max=765;
○ Const char newline=‘\n’;

22/02/10 Programmer en langage C 34


Le mot-clé typedef

 Le mot-clé typdef permet de créer un synonyme

Eléments de base du langage C


pour un type de donnée existant. Par exemple
l’instruction :
typedef int entier;
Crée le synonyme entier pour int. Vous pouvez ainsi
utiliser entier pour définir des variables de type int,
comme dans l’exemple suivant:
entier compte;

22/02/10 Programmer en langage C 35


Exercices
 Quel type de variable convient le mieux pour stocker
les valeurs suivantes:
 L’âge d’une personne •unsigned int age;
 Le poids •unsigned int poids;
•float rayon=3;
 Le rayon d’un cercle
•long salaire_annuel;
 Salaire annuel •float cout=29,95;
 Le prix d’un article •const int
 La note la plus haute d’un test note_max=100; #define
 La température note_max 100;
•float temperature;
 Le gain d’une personne
•long gain=30000;
 La distance d’une étoile en kilomètre •double distance;

22/02/10 Programmer en langage C 36


Exercices
 Quels sont les noms de variables correctes :
a) 123variable
b) X
c) Score_totale
d) Poids_en_#s
e) One.0
f) Grand-cout
g) RAYON
h) rayon
i) Cela_est_une_variable_pour_stocker_la_largeur

22/02/10 Programmer en langage C 37


Définition de variables
 définition de variables sont couverts par le langage C :
 définition du domaine de valeur de cette variable et les

Eléments de base du langage C


opérations légales sur cette variable ; =⇒ grâce au type.
 réservation de l’espace mémoire nécessaire au support de la
variable lors de l’exécution ; =⇒ grâce au type et à la classe
mémoire.
 initialisation de la variableà l’aide d’une constante dont le
type correspond à celui de la variable ; =⇒ en faisant suivre le
nom par un symbole d’affectation = et une valeur compatible avec
la variable.
 association d’une durée de vie à la variable qui permet
l’utilisation dans certaines parties du programme(règles de
visibilité). =⇒ grâce à la classe mémoire et au lieu de définition.

22/02/10 Programmer en langage C 38


Définition de variables : classes mémoires
 Une définition de variable est l’association d’un identifiant à un type et la
spécification d’une classe mémoire. La classe mémoire sert à expliciter la

Eléments de base du langage C


visibilité d’une variable et son implantation en machine. Les classes mémoire
sont :
 global cette classe est celle des variables définies en dehors d’une fonction. Ces
variables sont accessibles à toutes les fonctions. La durée de vie des variables de type
global est la même que celle du programme en cours d’exécution.
 Local ou auto : cette classe comprend l’ensemble des variables définies dans un bloc.
C’est le cas de toute variable définie à l’intérieur d’une fonction. L’espace mémoire
réservé pour ce type de variable est alloué dans la pile d’exécution. C’est pourquoi elles
sont appelées aussi auto c.à.d automatique car l’espace mémoire associé est créé lors
de l’entrée dans la fonction et il est détruit lors de la sortie de la fonction. La durée de
vie des variables de type local est celle de la fonction dans laquelle elles sont définies.

22/02/10 Programmer en langage C 39


Définition de variables : classes mémoires
 Static ce qualificatif modifie la visibilité de la variable, ou son
implantation :
– dans le cas d’une variable locale il modifie son implantation en attribuant
une partie de l’espace de mémoire globale pour cette variable. Une
variable locale de type statique a un nom local mais a une durée de vie
égale à celle du programme en cours d’exécution.
– dans le cas d’une variable globale, ce prédicat restreint la visibilité du nom
de la variable à l’unité de compilation. Une variable globale de type
statique ne peut pas être utilisée par un autre fichier source participant
au même programme par une référence avec le mot réservé extern.
 extern ce qualificatif permet de spécifier que la ligne correspondante
n’est pas une tentative de définition mais une déclaration. Il précise les
variables globales (noms et types) qui sont définies dans un autre fichier
source et qui sont utilisées dans ce fichier source.

22/02/10 Programmer en langage C 40


Définition de variables : classes mémoires

 Register ce qualificatif permet d’informer le compilateur que


les variables locales définies dans le reste de la ligne sont
utilisées souvent. Le prédicat demande de les mettre si possible
dans des registres disponibles du processeur de manière à
optimiser le temps d’exécution. Le nombre de registres
disponibles pour de telles demandes est variable selon les
machines. Il est de toute façon limité (4 pour les données, 4 pour
les pointeurs sur un 680X0). Seules les variables locales peuvent
être qualifiées register.

22/02/10 Programmer en langage C 41


Définition de variables : classes mémoires

Déclaration/définition Classe mémoire

Int a; Définition d’une variable global


main ()
{
Int b; Définition d’une variable local à main
Static char c;
}
extern int b ; déclaration d’une variable qui est définie dans un autre
fichier(rien à voir la variable b de main), variable globale
externe
Int coucou(const int c) paramètre constant, variable locale
{
register int a ; variable locale à coucou, à mettre en registre si possible
if (b == 1) référence à la variable b externe
}

22/02/10 Programmer en langage C 42


Instructions, Expressions et Opérateurs
Les structures de contrôle
La récursivité
Les conversions de types
Principales fonctions d’entrées-sorties standard

22/02/10 Programmer en langage C 43


Instructions, Expressions et Opérateurs
 Les instructions :
 Une instruction représente une tâche à accomplir par l’ordinateur. En
langage C, on écrit une instruction par ligne et elle se termine par un

La syntaxe du langage C
point virgule( à l’exception de #define et #include). Par exemple:
x=2+3;
est une instruction d’affectation. Elle demande à l’ordinateur
d’ajouter 2 et 3 et d’attribuer le résultat à la
variable x.
 Les blocs:
○ Un bloc (ou instructions composées) est un groupe d’instructions
entre accolades:

{
printf("Hello"); {printf("Hello");
printf("world!"); printf("world!");}
}

22/02/10 Programmer en langage C 44


Instructions, Expressions et Opérateurs
 Les expressions:
Une expression est une combinaison d’opérateurs et d’opérandes(variables,
constantes). Autrement tout ce qui représente une valeur numérique. Une
expression génère toujours un résultat d’un type bien défini qu’on appellera le type

La syntaxe du langage C
de l’expression.
 Les expressions Simples
○ L’expression simple est constituée d’une seule variable, d’une constante. Par exemple:
 PI //constante dont la valeur est définie par #define
 Taux //variable
 Les expressions complexes
○ Les expressions complexes sont constituées d’expressions plus simples avec des
opérateurs. Par exemple:
 2+8
 8+(5*taux)+(taux*taux)/cout

22/02/10 Programmer en langage C 45


Instructions, Expressions et Opérateurs

 Les opérateurs: opérateur d’affectation


 L’opérateur d’affectation est le signe(=). Dans le

La syntaxe du langage C
programme C : x=y;
ne signifie pas ‘x égal y’. Elle indique à l’ordinateur
‘d’affecter la valeur de y à x’. Cette instruction doit être
composée d’une expression à droite du signe égale, et d’un
nom de variable à gauche de ce signe:
variable=expression;
Exemple:
○ x=6+(y=4+5);
○ a=b=2;

22/02/10 Programmer en langage C 46


Instructions, Expressions et Opérateurs
 Les opérateurs: opérateur d’affectation
Opération et affectation combinées op=

La syntaxe du langage C
var += exp ; équivalent à var = var + (exp) ;
var -= exp ; var = var - (exp) ;
var *= exp ; var = var * (exp) ;
var /= exp ; var = var / (exp) ;
var %= exp ; var = var % (exp) ;
Attention :
pas d’espace entre l’opérateur op et le égal =,
x *= y+1 est équivalent à x = x*(y+1) et pas x = x*y+1.

22/02/10 Programmer en langage C 47


Instructions, Expressions et Opérateurs
 Opérateurs arithmétiques

La syntaxe du langage C
22/02/10 Programmer en langage C 48
Instructions, Expressions et Opérateurs

 Opérateurs arithmétiques

La syntaxe du langage C
 Remarques :
○ Les opérandes de ces opérateurs arithmétiques peuvent
appartenir à tout type arithmétique seul l’opérateur % requiert
des types entiers.
○ Le résultat d’une division d’entiers est aussi un entier, Exemple :
6 / 4 // Resultat: 1
6 % 4 // Resultat: 2
 6.0 / 4.0 // Resultat: 1.5

22/02/10 Programmer en langage C 49


Instructions, Expressions et Opérateurs
 Opérateurs arithmétiques
Remarques
○ Les opérateurs unaires opèrent sur une seule variable ou opérande.

La syntaxe du langage C
○ Concernant l’incrémentation pré/postfixe, voici un petit exemple: Supposons que
la valeur de N soit égale à 3 :
 Incrémentation postfixe : X = N++ ;

Résultat : N = 4 et X = 3
 Incrémentation préfixe : X = ++N ;

Résultat : N = 4 et X = 4
 Décrémentation postfixe : X = N-- ;

Résultat : N = 2 et X = 3
 Décrémentation préfixe : X = --N ;

Résultat : N = 2 et X = 2

22/02/10 Programmer en langage C 50


Instructions, Expressions et Opérateurs

 Opérateurs de comparaison

La syntaxe du langage C
Toute comparaison est une expression de type int qui
renvoie la valeur 0 (faux) ou 1 (vraie). Il faut que les
opérandes soient du même type arithmétique (ou des
pointeurs sur des objets de même type).
Attention : il ne faut pas confondre l’opérateur d’égalité
(==) avec celui d’affectation (=).
Les différents opérateurs de comparaison sont détaillés
dans le tableau ci-dessous.

22/02/10 Programmer en langage C 51


Instructions, Expressions et Opérateurs
 Opérateurs de comparaison

La syntaxe du langage C
22/02/10 Programmer en langage C 52
Instructions, Expressions et Opérateurs
 Opérateurs de comparaison

La syntaxe du langage C
#include <stdio.h>
void main ()
{
int x=14,y=1; // x est différent de y
if (x = y) //erreur!!! il faudrait écrire ’if (x == y)’
printf("x est égal à y (%i=%i)\n",x,y);
else
printf("x est différent de y (%i!=%i)\n",x,y);
}

22/02/10 Programmer en langage C 53


Instructions, Expressions et Opérateurs
 Opérateurs logiques
Les opérateurs logiques, permettent de combiner le résultat de
plusieurs expressions de comparaison en une seule expression

La syntaxe du langage C
logique. Les opérandes des opérateurs logiques peuvent être
n’importe quel scalaire. Toute valeur différente de 0 est interprétée
comme vraie (et 0 correspond à ’faux’). Comme pour les expressions
de comparaisons les expressions logiques renvoient une valeur
entière (0 =faux ; 1=vraie).
Remarque :
les opérateurs && et || évaluent les opérandes de gauche à droite et
le résultat est connu dès l’opérande de gauche. Ainsi, l’opérande de
droite n’est évaluée que si celle de gauche est vraie dans le cas de
l’opérateur && (respectivement fausse dans le cas de l’opérateur ||).
Exemple:
(i < max) && (f(14) == 1), la fonction f n’est appelée que si i < max.

22/02/10 Programmer en langage C 54


Instructions, Expressions et Opérateurs
 Opérateurs logiques

La syntaxe du langage C
 Exemples
 L’expression : 32 && 40 vaut 1
 L’expression : !65.34 vaut 0
 L’expression : !!0 vaut 0

22/02/10 Programmer en langage C 55


Instructions, Expressions et Opérateurs
 Opérateurs bit à bit
Les opérateurs bits à bits n’opèrent que sur des entiers.

La syntaxe du langage C
Les opérandes sont interprétées bits par bits (le bit 1
correspondant à une valeur vraie, 0 est considéré
comme une valeur fausse).

22/02/10 Programmer en langage C 56


Instructions, Expressions et Opérateurs
 Opérateurs bit à bit
Exemples: chaque opérande est fournie sous forme décimale et binaire) :

La syntaxe du langage C
22/02/10 Programmer en langage C 57
Instructions, Expressions et Opérateurs

 Opérateurs d’accès à la mémoire : &


L’opérande de l’opérateur d’adresse & doit être une expression

La syntaxe du langage C
qui désigne un objet ou une expression.
&x renvoie l’adresse mémoire de x et est donc
un pointeur vers x.

22/02/10 Programmer en langage C 58


Instructions, Expressions et Opérateurs
 Autres opérateurs
 Opérateur séquentiel ( , )
○ <expr1> , <expr2>,., <exprN>

La syntaxe du langage C
○ Exprime des calculs successifs dans une même expression. Le type
et la valeur de l’expression sont ceux du dernier opérande.
○ Exemple : x = 5 , x + 6. L’expression a pour valeur 11
 Opérateur conditionnel (? :)
○ <expression> ? <expr1>: <expr2>

○ <expression> est évaluée. Si sa valeur est non nulle, alors la valeur


de <expr1> est retournée. Sinon, c’est la valeur de <expr2> qui est
renvoyée.
○ Exemple : max = a > b ? a : b
○ si a est le plus grand, alors affectation à max du contenu de a sinon
affectation du contenu de b

22/02/10 Programmer en langage C 59


Instructions, Expressions et Opérateurs
 Autres opérateurs

La syntaxe du langage C
22/02/10 Programmer en langage C 60
Instructions, Expressions et Opérateurs
 Priorité et associativité des opérateurs
Lors de l’évaluation des différentes parties d’une

La syntaxe du langage C
expression, les opérateurs respectent certaines lois de
priorité et d’associativité.
Exemples
○ La multiplication a la priorité sur l’addition
○ La multiplication et l’addition ont la priorité sur l’affectation.
 Tableau des opérateurs et priorité
 La priorité est décroissante de haut en bas dans le tableau.
 La règle d’associativité s’applique pour tous les opérateurs d’un
même niveau de priorité. (pour une associativité de gauche à droite
et pour une associativité de droite à gauche).
 Dans une expression, les parenthèses forcent la priorité.

22/02/10 Programmer en langage C 61


Instructions, Expressions et
Opérateurs
Priorité Opérateurs Associativité
1 () 

La syntaxe du langage C
2 + - ++ -- ! 
3 * / % 
4 + - 
5 < <= > >= 
6 == != 
7 && 
8 || 
9 ?: 
10 = += -= *= /= %= 

22/02/10 Programmer en langage C 62


Exercices
1) Soit les déclarations suivantes :
Int n=10, p=4;
Long q=2;

La syntaxe du langage C
Float x=1.75;
Donner le type et la valeur de chacune des expressions suivantes
a) n+q
b) n+x a) long 12
c) n%p+q b) float 11,75
d) n<p c) long 4
e) q+3 *(n<p) d) int 0
f) x*(q==2) e) long 5
g) x*(q=2) f) float 1,75
h) (q-2)&&(n-10) g) int 0
i) q&&n h) int 1

22/02/10 Programmer en langage C 63


Exercices
2. n étant de type int, écrire une expression qui prend la
valeur :

La syntaxe du langage C
-1 si n est négatif
0 si n est nul
1 si n est positif

n ? (n>0 ? 1: -1) : 0

22/02/10 Programmer en langage C 64


Les structures de contrôle
 On appelle structure de contrôle toute instruction servant à contrôler le
déroulement de l’enchaînement des instructions à l’intérieur d’un programme,
ces instructions peuvent être des instructions conditionnelles ou itératives.

La syntaxe du langage C
 Parmi les structures de contrôle, on distingue :
 structures de choix
○ if….else (choix conditionnel)
○ switch (choix multiple)
 structures répétitives ou itérative ou boucle
○ for
○ while
○ do…while
Branchement inconditionnel
○ Break, goto, continue

22/02/10 Programmer en langage C 65


Les structures de contrôle : if-else

La construction if-else (si-sinon) est la construction


logique de base du langage C qui permet d'exécuter un

La syntaxe du langage C
bloc d'instructions selon qu'une condition est vraie ou
fausse.
Syntaxe
○ Forme 1
 if (expression) instruction-1;
la forme if est ici dans sa forme la plus simple. Si expression est
vraie, instruction-1 est exécutée. Si expression est fausse,
instruction-1 est ignorée.

22/02/10 Programmer en langage C 66


Les structures de contrôle : if-else
 Syntaxe
○ Forme 2
 if (expression) instruction-1;
else instruction-2;

La syntaxe du langage C
Si expression est vraie, instruction-1 est exécutée, sinon c’est instruction-2 qui est
exécutée.
○ Forme 3
 if (expression-1)
instruction-1;
else if (expression-2)
instruction-2;
else
instruction-3;
Les instructions if sont imbriquées. Si expression-1 est vraie, instruction-1
est exécutée. Dans le cas contraire expression-2 est évaluée si cette dernière est
vraie instruction-2 est exécutée. Si les deux expressions sont fausses, c’est
instruction-3 qui est exécuté

22/02/10 Programmer en langage C 67


Les structures de contrôle : if-else
 Exemples:
Exemple 1

La syntaxe du langage C
○ if (salaire >45.000)
tax=0.30;
else
tax=0.25;
Exemple 2
○ if (age <18)
printf(‘’mineur’’);
else if (age <65)
printf(‘’adulte’’);
else
printf(‘’personne agée’’);

22/02/10 Programmer en langage C 68


Les structures de contrôle : if-else
#include <stdio.h>
void main ()
{ int i;
printf("Tapez un nombre entier positif ou negatif: ");
scanf("%d", &i);
if (i<0) {
i=-i;
printf("J'ai remis i à une valeur positive.\n");
}
else {
printf("Vous avez tapé un nombre positif.\n");
}
}
22/02/10 Programmer en langage C 69
Les structures de contrôle : Switch

 L’instruction switch est l’instruction de contrôle la plus


souple du langage C. Elle permet à votre programme

La syntaxe du langage C
d’exécuter différentes instructions en fonction d’une
expression qui pourra avoir plus de deux valeurs.
 On l’appelle aussi l’instruction d’aiguillage. Elle teste
si une expression prend une valeur parmi une suite
de constantes, et effectue le branchement
correspondant si c’est le cas.

22/02/10 Programmer en langage C 70


Les structures de contrôle : Switch
 Syntaxe

La syntaxe du langage C
switch (<condition>) {
case <valeur 1> : <action 1>; break;
case <valeur 2> : <action 2>; break;

default : <action n>;
}

22/02/10 Programmer en langage C 71


Les structures de contrôle : Switch
 Remarques :
 Le fonctionnement de cette instruction est le suivant :

La syntaxe du langage C
○ expression est évaluée ;
○ s’il existe un énoncé case avec une constante qui est égale à la
valeur de l’expression, le contrôle est transféré à l’instruction qui
suit cet énoncé;
○ si un tel case n’existe pas, et si énoncé default existe, alors le
contrôle est transféré à l’instruction qui suit l’énoncé default ;
○ si la valeur de l’expression ne correspond à aucun énoncé case et
s’il n’y a pas d’énoncé default, alors aucune instruction n’est
exécutée.
Attention.
○ Lorsqu’il y a branchement réussi à un case, toutes les instructions
qui le suivent sont exécutées, jusqu’à la fin du bloc ou jusqu’à une
instruction de rupture (break).

22/02/10 Programmer en langage C 72


Les structures de contrôle : Switch
#include<stdio.h>
void main() {
int a,b,d;

La syntaxe du langage C
char operateur;
Printf(‘’ Entrez un opérateur (+, -,* ou /):’’);
Scanf(‘’%c’’,&operateur);
Printf(‘’ Entrez deux entiers:’’);
Scanf(‘’%d’’,&a); Scanf(‘’ %d’’,&b);
switch(operateur){
case’-’ : y=a-b; printf(‘’%d’’,y);break;
case’+’ : y=a+b; printf(‘’%d’’,y); break;
case’*’ : y=a*b; printf(‘’%d’’,y); break;
case’/’ : y=a/b; printf(‘’%d’’,y); break;
default : printf(‘’opérateur inconnu\n’’);break;
}
}

22/02/10 Programmer en langage C 73


Les structures de contrôle : while
 L’instruction while permet de répéter des instructions,
tant qu'une condition est vérifiée.

La syntaxe du langage C
 Syntaxe
 Forme 1
while (condition)
une-instruction;
 Forme 2
while (condition) {
Des instructions;
}
}

22/02/10 Programmer en langage C 74


Les structures de contrôle :while
 La boucle while fonctionne de la façon suivante:
1. La condition est évaluée,
2. si cette condition est fausse, l’instruction while se termine,

La syntaxe du langage C
3. si la condition est vraie les instructions sont exécutées
4. l’exécution reprend à l’étape 1.
 Exemple
#include <stdio.h>
void main ()
{ int i=1, N;
printf("N=\n"); scanf("%d",&N);
while (i <= N) {
printf("%d ", i); i = i+1;}
printf("\n");
}

22/02/10 Programmer en langage C 75


Les structures de contrôle :while
 while imbriqué
#define MAX 4

La syntaxe du langage C
int i=0,j;
while (i < MAX ) {
j=0;
while (j < MAX ) {
printf(" position : %d \t %d\n",i,j);
j++;
}
i++;
}

22/02/10 Programmer en langage C 76


Les structures de contrôle : do-while
 L'instruction do-while, exécute le bloc d'instructions
tant qu’une condition reste vraie. Dans cette boucle le
test de la condition s’effectue à la fin de la boucle.

La syntaxe du langage C
 Syntaxe
 Forme 1
do
une-instruction;
while (condition)
 Forme 2
do {
Des instructions;
} while (condition)

22/02/10 Programmer en langage C 77


Les structures de contrôle : do-while
 Exemple :
#include <stdio.h>

La syntaxe du langage C
#define MAX 4
void main()
{
int i=MAX;
do {
printf("Valeur de i : %i\n",i);
i++;
} while (i < MAX);
}

22/02/10 Programmer en langage C 78


Les structures de contrôle : for
 A l’instar des instructions while et do-while l’instruction for
permet d’exécuter un certain nombre de fois un bloc d’une ou
plusieurs instructions.

La syntaxe du langage C
 Syntaxe:
 for( [expression1] ; [expression2] ; [expression3 ])
{
liste d’instructions
}
 Les crochets [ et ] signifient que leur contenu est facultatif
 Dans la construction de for :
○ expression1 : effectue les initialisations nécessaires avant
l’entrée dans la boucle;
○ expression2 : est le test de continuation de la boucle ; le test
est évalué avant l’exécution du corps de la boucle;
○ expression3 : est évaluée à la fin du corps de la boucle.

22/02/10 Programmer en langage C 79


Les structures de contrôle : for
 Remarques
En pratique, expression1 et expression3 contiennent

La syntaxe du langage C
souvent plusieurs initialisations séparées par des
virgules.
○ For(i=0,j=1,k=5;….;…)
Les expressions expression1 et expression3 peuvent
être absente(les points-virgules doivent apparaître.
○ i=1; for(;i<=5;) {printf(‘’%d fois\n’’,i);i++;}
Lorsque expression2 est absente, l’expression
correspondante est considérée comme vraie. Par
conséquent, for(;;) est une boucle infinie

22/02/10 Programmer en langage C 80


Les structures de contrôle : for
 Remarques :par définition l’instruction de for
for ( expression1 ; expression2 ; expression3 )

La syntaxe du langage C
{
liste d’instructions
}
est équivalente à
expression1;
while(expression2)
{
instructions;
expression3;
}

22/02/10 Programmer en langage C 81


Les structures de contrôle :for
 Exemples
 Programme pour calculer la somme de 1 à 100

La syntaxe du langage C
Int n,total;
For(total=0,n=1;n<=100;n++)
total+=n;
Printf(’’la sommes des nombres de 1 à 100 est %d\n’’,total);

 Programme pour calculer la factorielle d’un entier n:


Int n, i,fact;
For(fact=1,i=1;i<=n;i++)
fact*=i;
Printf(’’%d!= %d\n’’,n,fact);

22/02/10 Programmer en langage C 82


Les structures de contrôle : break, goto et
continue
 Instruction break

La syntaxe du langage C
 On a vu le rôle de l’instruction break; au sein d’une
instruction de branchement multiple switch.
 L’instruction break peut, plus généralement, être
employée à l’intérieur de n’importe quelle boucle (for ;
while ; do-while). Elle permet l’abandon de la structure
et le passage à la première instruction qui suit la
structure.
 En cas de boucles imbriquées, break fait sortir de la
boucle la plus interne.

22/02/10 Programmer en langage C 83


Les structures de contrôle : break, goto et
continue
 Instruction break : exemple

La syntaxe du langage C
#include <stdio.h>
void main( )
{ int i;
for (i = 1 ; i<=10 ; i++){ Evaluation:
printf(’’début tour %d\n’’ ,i) ; Début tour 1
Bonjour
printf(’’ bonjour\n’’); Début tour 2
if (i ==3) break ; bonjour
fin tour 2
printf(" fin tour%d\n", i) ; Début tour 3
Bonjour
} Après la boucle
printf(" après la boucle\n") ;
}
22/02/10 Programmer en langage C 84
Les structures de contrôle : break, goto et
continue
 Instruction continue

La syntaxe du langage C
 L’instruction continue peut être employée à l’intérieur
d’une structure de type boucle (for ; while ; do-while ).
 Elle produit l’abandon de l’itération courante et fait
passer directement à l’itération suivante d’une boucle.
 L’instruction continue concerne la boucle la plus
proche.

22/02/10 Programmer en langage C 85


Les structures de contrôle : break, goto et
continue
 Instruction continue

La syntaxe du langage C
 Exemple :
Void main()
Evaluation:
{ int i; Début tour 1
for(i=1;i<=10;i++) Début tour 2
Début tour 3
{ printf(’’début tour %d\n’’ ,i) ; Début tour 4
Bonjour
if (i <4) continue ; Début tour 5
printf(’’ bonjour\n’’); Bonjour

}
}

22/02/10 Programmer en langage C 86


Les structures de contrôle : break,
continue et goto
 Instruction goto
Elle permet le branchement en un emplacement quelconque

La syntaxe du langage C
du programme.
Void main()
{ int i;
for(i=1;i<=10;i++) Evaluation:
{ printf(’’début tour %d\n’’ ,i) ; Début tour 1
Bonjour
printf(’’ bonjour\n’’);
fin tour 1
if (i ==3) goto sortie ; Début tour 2
printf(’’ fin tour%d\n", i); bonjour
fin tour 2
}
Début tour 3
Sortie:printf (" après la boucle\n") ; Bonjour
} Après la boucle

22/02/10 Programmer en langage C 87


La récursivité

 Le langage C autorise des appels de fonctions. Celle-


ci peut prendre deux aspects:

La syntaxe du langage C
Récursivité directe: une fonction comporte, dans sa
définition, au moins un appel à elle-même.
Récursivité croisée: l’appel d’une fonction entraîne
celui d’une autre fonction qui, à son tour, appelle la
fonction initiale(le cycle pouvant d’ailleurs faire
intervenir plus de deux fonctions)

22/02/10 Programmer en langage C 88


La récursivité
 Exemple
#include <stdio.h>

La syntaxe du langage C
int fact (int x)
{ printf (“Computing fact %d\n”, x) ;
if (x == 1)
return 1 ;
else
return x * fact (x-1) ;
}
Void main (){
printf (“5! = %d\n”, fact (5)) ;
}
22/02/10 Programmer en langage C 89
Les conversions de types
 La conversion de type est un outil très puissant, elle
doit donc être utilisée avec prudence. Le compilateur

La syntaxe du langage C
fait de lui-même des conversions lors de l’évaluation
des expressions. Pour cela il applique des règles de
conversion implicite. Ces règles ont pour but la perte
du minimum d’information dans l’évaluation de
l’expression. Ces règles sont les suivantes:
Règle de Conversion Implicite
○ Convertir les éléments de la partie droite d’une expression
d’affectation dans le type de la variable ou de la constante le
plus riche.
○ Faire les opérations de calcul dans ce type.
○ Puis convertir le résultat dans le type de la variable affectée.

22/02/10 Programmer en langage C 90


Les conversions de types
 La notion de richesse d’un type est précisée dans la norme
[ISO89]. Le type dans lequel le calcul d’une
expression à deux opérandes doit se faire est donné par les

La syntaxe du langage C
règles suivantes :
1. si l’un des deux opérandes est du type long double alors le
calcul doit être fait dans le type long double ;
2. sinon, si l’un des deux opérandes est du type double alors le
calcul doit être fait dans le type double ;
3. sinon, si l’un des deux opérandes est du type float alors le
calcul doit être fait dans le type float ;
4. si l’un des deux opérandes est du type unsigned long int
alors le calcul doit être fait dans ce type ;
5. si l’un des deux opérandes est du type long int alors le
calcul doit être fait dans le type long int ;

22/02/10 Programmer en langage C 91


Les conversions de types
 Hiérarchie des conversions arithmétiques habituelles
est la suivante:

La syntaxe du langage C
La syntaxe du langage C
long double
double
Float
unsigned long long
long long
unsigned long
long
unsigned int
int

22/02/10 Programmer en langage C 92


Les conversions de types

 Conversion implicite
Il est possible de forcer la conversion d’une variable (ou

La syntaxe du langage C
d’une expression) dans un autre type avant de l’utiliser
par une conversion implicite. Cette opération est
appelée “cast”.
cast Elle se réalise de la manière suivante :
(type) expression
Prenons pour exemple l’expression : i = (int) f + (int) d ;
f et d sont convertis en int, puis additionnés. Le résultat
entier est rangé dans i.

22/02/10 Programmer en langage C 93


Les conversions de types
 Exemple

La syntaxe du langage C
float f ; double d ; int i ; long li ;
li = f + i ; i est transformé en float puis additionné à f,
le résultat est transformé en long et rangé dans li.

d = li + i ; i est transformé en long puis additionné à li,


le résultat est transformé en double et rangé dans d.

i=f+d; f est transformé en double, additionné à d,


le résultat est transformé en int et rangé dans i.

22/02/10 Programmer en langage C 94


Principales fonctions d’entrées-sorties
standard
 Il s’agit des fonctions de la librairie standard stdio.h

La syntaxe du langage C
utilisées avec les unités classiques d’entrées-sorties,
qui sont respectivement le clavier et l’écran.
 Ces fonctions sont:
Getchar
Putchar
Puts
Printf
scanf

22/02/10 Programmer en langage C 95


Principales fonctions d’entrées-sorties
standard
 La fonction getchar

La syntaxe du langage C
La fonction getchar permet la récupération d’un seul
caractère à partir du clavier. La syntaxe d’utilisation de
getchar est la suivante : var=getchar();
Notez que var doit être de type char. Exemple :
#include <stdio.h>
void main() {
char c;
printf("Entrer un caractère:");
c = getchar();
printf("Le caractère entré est %c\n",c);
}

22/02/10 Programmer en langage C 96


Principales fonctions d’entrées-sorties
standard
 La fonction putchar

La syntaxe du langage C
permet l’affichage d’un seul caractère sur l’écran de
l’ordinateur. putchar constitue alors la fonction
complémentaire de getchar. La syntaxe d’utilisation est
la suivante : putchar(var);
où var est de type char. Exemple :
#include <stdio.h>
Void main() {
char c;
printf("Entrer un caractère:");
c = getchar();
putchar(c);
}

22/02/10 Programmer en langage C 97


Principales fonctions d’entrées-sorties
standard
 La fonction puts

La syntaxe du langage C
Syntaxe : puts(ch);
Cette fonction affiche, sur stdout, la chaîne de
caractères ch puis positionne le curseur en début de
ligne suivante. puts retourne EOF en cas d’erreur.
Exemple :
#include <stdio.h>
void main() {
char * toto = "on est super content!";
puts(toto);
}

22/02/10 Programmer en langage C 98


Principales fonctions d’entrées-sorties
standard
 La fonction d’écriture à l’écran formattée printf

La syntaxe du langage C
 La fonction printf est une fonction d’impression formatée, ce
qui signifie que les données sont converties selon le format
particulier choisi. Sa syntaxe est la suivante :
printf("chaîne de contrôle", expression1, . . . , expressionn);
 La chaîne de contrôle contient le texte à afficher et les
spécifications de format correspondant à chaque expression
de la liste. Les spécifications de format ont pour but
d’annoncer le format des données à visualiser. Elles sont
introduites par le caractère %. Le i-ème format de la chaîne
de contrôle sera remplacé par la valeur effective de
expressioni.

22/02/10 Programmer en langage C 99


Principales fonctions d’entrées-sorties
standard
 La fonction d’écriture à l’écran formattée printf

La syntaxe du langage C
Les différents formats de la fonction printf
format Conversion en écriture
%d int décimale signée
%ld long int décimale signée
%u unsigned int décimale non signée
%lu unsigned long décimale non signée
%o unsigned int Octale non signée
%lo unsigned long Octale non signée
%x unsigned int Héxadécimal non signée
%lx unsigned long Héxadécimal non signée

22/02/10 Programmer en langage C 100


Principales fonctions d’entrées-sorties
standard
 La fonction d’écriture à l’écran formattée printf
Les différents formats de la fonction printf

La syntaxe du langage C
format Conversion en écriture
%f float décimale virgule fixe
%lf Long float décimale virgule fixe
%e Double décimale notation exponentielle
%le Long double décimale notation exponentielle
%g Double décimale, représentation la plus courte parmi
%f et %e
%lg Long double décimale, représentation la plus courte parmi
%lf et %le
%c unsigned char caractère
%s char* Chaîne de caractères

22/02/10 Programmer en langage C 101


Principales fonctions d’entrées-sorties
standard
 La fonction d’écriture à l’écran formattée printf

La syntaxe du langage C
Les différents formats de la fonction printf
Exemple
printf("|% d|\n",14); | 14|
printf("|% d|\n",-14); |-14|
printf("|%x|\n",0x56ab); |56ab|
printf("|%X|\n",0x56ab); |56AB|
printf("|%o|\n",14); |16|
printf("|%#o|\n",14); |016|
printf("|%10d|\n",14); | 14|
printf("|%f|\n",1.234567890123456789e5); |123456.789012|
printf("|%.4f|\n",1.234567890123456789e5); |123456.7890|

22/02/10 Programmer en langage C 102


Principales fonctions d’entrées-sorties
standard
 La fonction d’écriture à l’écran formattée printf
Les différents formats de la fonction printf

La syntaxe du langage C
Exemple
printf("|%e|\n",1.234567890123456789e5); |1.234568e+05|
printf("|%.4e|\n",1.234567890123456789e5); |1.2346e+05||
printf("|%.4g|\n",1.234567890123456789e-5); |1.235e-05|
printf("|%.4g|\n",1.234567890123456789e-3); |0.001235|
printf("|%.8g|\n",1.234567890123456789e5); |123456.79|

22/02/10 Programmer en langage C 103


Principales fonctions d’entrées-sorties
standard
 La fonction de saisie scanf
La fonction scanf permet de récupérer les données

La syntaxe du langage C
saisies au clavier, dans le format spécifié. Ces données
sont stockées aux adresses spécifiées par les arguments
de la fonction scanf (on utilise donc l’opérateur
d’adressage & pour les variables scalaires). scanf
retourne le nombre de valeurs effectivement lues et
mémorisées .La syntaxe est la suivante :
scanf("chaîne de contrôle", arg1, . . . , argn);
La chaîne de contrôle indique le format dans lequel les
données lues sont converties. Comme pour printf, les
conversions de format sont spécifiées par un caractère
précédé du signe %.

22/02/10 Programmer en langage C 104


Principales fonctions d’entrées-sorties
standard
 La fonction de saisie scanf

La syntaxe du langage C
Exemple
#include <stdio.h>
void main()
{
int i ;
printf("entrez un entier sous forme hexadecimale i = ");
scanf("%x",&i);
printf("i = %d\n",i);
}

22/02/10 Programmer en langage C 105


•Les Enumération
•Les Tableaux
•Les Structures
•Les Unions

22/02/10 Programmer en langage C 106


Les énumérations

 Les énumérations permettent de définir un type pour des


variables qui ne sont affectées qu’a un nombre fini de
valeurs. Un objet de type énumération est défini par le

Les types dérivés


mot-clef enum et un identificateur de modèle, suivi de la
liste des valeurs que peut prendre cet objet :
enum modele {constante1, constante2,. . . ,constanten} ;
 En réalité, les objets de type enum sont représentés
comme des int. Les valeurs possibles constante1,
constante2,. . . ,constanten sont codées par des entiers de 0
à n-1.

22/02/10 Programmer en langage C 107


Les énumérations
 Le type enum boolean, Dans l’exemple suivant,
associe l’entier 0 à la valeur FALSE et l’entier 1 à la
valeur TRUE.

Les types dérivés


#include <stdio.h>
enum boolean {FALSE, TRUE};
void main ()
{
enum boolean b1 = TRUE;
printf("b = %d\n",b1);
}

22/02/10 Programmer en langage C 108


Les tableaux
 Il est souvent nécessaire de mémoriser un grand nombre
d’éléments identiques. Il serait par exemple fastidieux de
déclarer 1000 variables réelles représentant 1000 valeurs.
Pour cela on utilise des tableaux.

Les types dérivés


 Définition
 Un tableau représente un ensemble d’emplacements mémoire qui
portent le même nom et contiennent le même type de données.
Chacun de ces emplacements est un éléments du tableau.
 On appelle tableau une variable composée de données de même
type, stockée de manière contiguë en mémoire(les uns à la suite des
autres).
 Un tableau est une suite des éléments de même taille. Par
conséquent, la taille(en octet) du tableau est :
type de donnée*le nombre d’éléments.

22/02/10 Programmer en langage C 109


Les tableaux
 Les tableaux à une dimensions
Un tableau à une dimension ne possède qu’un index. Un
index est le nombre entre crochets qui suit le nom du tableau.
Il indique le nombre d’éléments du tableau.

Les types dérivés


Déclarations
<type simple> Nom_du_tableau[nombre_elements];
○ Type simple : définit le type d’élément que contient le tableau
○ Nom du tableau : est le nom qu’on donne au tableau, ce nom suit les
mêmes règles qu’un nom de variable.
○ Nombre_elements : est une expression constante entière positive, qui
exprime la taille du tableau.
Exemple:
○ char caractere[12];
○ int entier[10];
○ float reel[8];

22/02/10 Programmer en langage C 110


Les tableaux

 Les tableaux à une dimensions


Initialisation à la déclaration
Il est possible d’initialiser le tableau à la définition :

Les types dérivés


<type > Nom_du_tableau[nombre_elements]={c1,c2,…cn};
Ou c1, c2,…cn sont des constantes dont le nombre ne doit pas
dépasser le nombre _elements.
Exemple
#define Mois 12
int tableau[12];
int tab[4] ={100,200,300,400;}\\ initialisation
char voyelles[6]={‘a’,’e,’i’,’o’,’u’,’y’};

22/02/10 Programmer en langage C 111


Les tableaux
 Les tableaux à une dimensions
Accès aux composantes d’un tableau
○ Pour accéder à un élément du tableau, il suffit de donner le nom
du tableau, suivi de l’indice de l’élément entre crochets :

Les types dérivés


Nom_du_Tableau [indice]
○ Où indice est une expression entière positive ou nulle.
○ Un indice est toujours positif ou nul ;
○ L’indice du premier élément du tableau est 0 ;
○ L’indice du dernier élément du tableau est égal au nombre
d’éléments – 1.
 Exemples :
○ short A[5] = {12 , 23 , 34 , 45 , 56}; // A[0] = 12 ; A[1] = 23 ; A[2] = 34 ;
// A[3] = 45 ; A[4] = 56 ;
○ for( i = 0 ; i< 5 ; i++ ) //Affichage des éléments

printf(‘’A[%d] = %d \t‘’,i,A[i)); // du tableau A

22/02/10 Programmer en langage C 112


Les tableaux
 Les tableaux à une dimensions
Remarque
○ Chaque élément ( TAB[i] ) d’un tableau ( int TAB[20] ) est manipulé comme une simple
variable, on peut :

Les types dérivés


 la lire : scanf("%d", &TAB[i] ); // TAB[i] sera initialisé par un
// entier saisi depuis la clavier
 l’écrire : printf("TAB[%d] = %d", i , TAB[i] ); //Le contenu de TAB[i]
//sera affiché sur écran
 la passer en argument à une fonction : TAB[i] = pow(TAB[i],2);
// = TAB[i] 2
○ Pour initialiser un tableau (TAB1) par les éléments d’un autre tableau (TAB2) : évitez
d’écrire TAB1 = TAB2 (incorrect)
○ On peut par exemple écrire :
for( i = 0 ; i < taille_tableau ; i++ )
TAB1[i] = TAB2[i];

22/02/10 Programmer en langage C 113


Les tableaux
 Les tableaux à deux dimensions
En C, un tableau multidimensionnel est considéré
comme un tableau dont les éléments sont eux même

Les types dérivés


des tableaux.
Un tableau à deux dimensions se déclare donc de la
manière suivante :
int mat[10][20];
En faisant le rapprochement avec les mathématiques,
on peut dire que mat est une matrice de 10 lignes et
de 20 colonnes.

22/02/10 Programmer en langage C 114


Les tableaux
 Les tableaux à deux dimensions
 On accède à un élément du tableau par l’expression mat[i][j].
 Pour initialiser un tableau à plusieurs dimensions à la compilation, on
utilise une liste dont chaque élément est une liste de constantes :

Les types dérivés


#include <stdio.h>
#define L 3 //nombre de lignes
#define C 2 //nombre de colonnes
short tab[L][C] = {{1, 2}, {14, 15}, {100, 200}};
void main() {
int i, j;
for (i = 0 ; i < L; i++) {
for (j = 0; j < C; j++)
printf("tab[%d][%d]=%d\n",i,j,tab[i][j]);}}

22/02/10 Programmer en langage C 115


Les tableaux
 Modification des éléments d’un tableau passé en
paramètre
#include <stdio.h>
void print_tab(int tab[], int nb_elem) {...}

Les types dérivés


/* incrémente chaque composantes du tableau */
void incr_tab(int tab[], int nb_elem) {
int i;
for (i=0; i < nb_elem; i++) tab[i]++;}
#define TAILLE 4
void main() {
int t[TAILLE] = {1, 2, 3, 4};
incr_tab(t, TAILLE);
print_tab(t, TAILLE);}

22/02/10 Programmer en langage C 116


Les structures
 Une structure est une suite finie d’objets de types
différents. Qui sont regroupé au sein d’une même entité.
 Contrairement aux tableaux, les différents éléments
d’une structure n’occupent pas nécessairement des

Les types dérivés


zones contiguës en mémoire.
 Chaque élément de la structure, appelé membre ou
champ, est désigné par un identificateur.
struct enreg {
int numero;
int qte;
float prix;
};

22/02/10 Programmer en langage C 117


Les structures
 L’utilisation pratique d’une structure se déroule de la
façon suivante :
1. On commence par déclarer la structure elle-même. Le

Les types dérivés


modèle général de cette déclaration est le suivant :
struct nom_structure {
type_1 membre_1 ;
type_2 membre_2 ;
...
type_n membre_n ;
};

22/02/10 Programmer en langage C 118


Les structures
2. Pour déclarer un objet de type structure correspondant au modèle
précédent, on utilise la syntaxe :
struct nom_structure identificateur_objet ;
Ou bien, si le modèle n’a pas encore été déclaré au préalable :

Les types dérivés


struct nom_structure {
type_1 membre_1 ;
type_2 membre_2 ;
...
type_n membre_n ;
} identificateur_objet ;
3. On accède aux différents membres d’une structure grâce à
l’opérateur membre de structure, noté ”.”. Le i-ème membre de objet
est désigné par l’expression :
identificateur_objet.membre_i

22/02/10 Programmer en langage C 119


Les structures
 Chaque champ d’une structure peut être manipulé
comme n’importe quelle variable de type correspondant.
Voici quelques exemples utilisant la structure enreg:

Les types dérivés


Struct enreg art1,art2; /* déclaration*/
Art1.numero=15; /*affectation*/
Printf(‘’%f’’,art1.prix); /* affiche la valeur du champ prix*/
Scanf(‘’%f’’,&art2.prix); /*lit une valeur qui sera affecté
au champ prix de la structure art2 */
Art1.numero++; /* incrémente de 1 la valeur du champ
numero de la structure art1*/

22/02/10 Programmer en langage C 120


Les structures
 Il possible d’affecter à une structure le contenu d’une
structure définie à partir du même modèle. Par
exemple nous pouvons écrire:

Les types dérivés


art1=art2;
 Une telle affectation remplace :
art1.numero = art2.numero;
art1.qte = art2.qte;
art1.prix = art2.prix;
 Initialisation d’une structure au moment de sa
déclaration :
Struct enreg art1={100,290,3000};

22/02/10 Programmer en langage C 121


Les structures
 Structure comportant des tableaux:
Struct personne{ char nom[30];
char prenom[20];

Les types dérivés


float heures[31];
} employe, courant;
/*heures: nbre d’heures du travail dans chaque jours du
mois*/
○ employe.heures[4];/*5ème éléments du tableau heures*/
○ employe.nom[0];/* premier caractère du champ nom*/
Initialisation:
○ Struct personne ={‘’Dupont’’, ‘’julea’’, {8, 7, 8, 6, 8, 0,0, 8}}

22/02/10 Programmer en langage C 122


Les structures
 Tableaux de structures
struct point { char nom;
int x;

Les types dérivés


int y;
};
struct point courbe[50];
Cette structure sert à représenter un point d’un plan qui
serait défini par son nom(caractère) et ses deux
coordonnées.
courbe[i].nom; courbe[i].x; courbe[i].y; /*représente le nom
du point de rang i, la valeur du champ x et la valeur du champ y*/
Initialisation :
○ Struct point courbe[50]={{‘A’,10,25},{‘M’,13,34},{‘R’,2,6}};

22/02/10 Programmer en langage C 123


Les structures
 Structures comportant d’autres structures:
 Supposant que l’intérieur de la structure employe et courant
nous ayant besoin d’introduire deux dates: la date d’embauche
et la date d’entrée. Si ces dates sont elles-mêmes des structures

Les types dérivés


comportant trois champs correspondant au jour et à l’année,
nous pouvons alors procéder aux déclarations suivantes :
○ struct date { int jour;
int mois;
int annee;};
○ Struct personne{ char nom[30];
char prenom[20];
float heures[31];
struct date date_embauche;
struct date date_poste;
} employe, courant;

22/02/10 Programmer en langage C 124


Les structures
 La notation :
Employe.date_embauche.annee
Représente l’année d’embauche correspondant à la

Les types dérivés


structure employe. Il s’agit d’une valeur de type int.
Courant.date_embauche
Représente la date d’embauche de la structure courant,
et nous pouvons faire l’affectation:
Courant.date_embauche=employe.date_poste;

22/02/10 Programmer en langage C 125


Les structures
 Exercice:
Ecrire un programme qui :
lit au clavier des informations dans un tableau de

Les types dérivés


structure du type point défini comme suit:
Struct point{
int num;
frloat x;
float y;
}
Le nombre d’éléments du tableau sera fixé par une instruction
#define.
Affiche à l’écran l’ensemble des informations
précédentes.

22/02/10 Programmer en langage C 126


Les unions
 Il est parfois nécessaire de manipuler des variables
auxquelles on désire affecter des valeurs de type
différents. Supposons que l'on désire écrire un package
mathématique qui manipulera des nombres qui seront

Les types dérivés


implémentés par des int, tant que la précision des
entiers de la machine sera suffisante et qui passera
automatiquement à une représentation sous forme de
flottants dès que ce ne sera plus le cas. Il sera
nécessaire de disposer de variables pouvant prendre
soit des valeurs entières, soit des valeurs flottantes.
Ceci peut se réaliser en C, grâce au mécanisme des
unions.

22/02/10 Programmer en langage C 127


Les unions
 Une définition d'union à la même syntaxe qu'une
définition de structure, le mot clé struct étant
simplement remplacé par le mot clé union.

Les types dérivés


 Exemple:
Union partage{
char c;
int i;
}
union nombre{
int i;
float f;
}

22/02/10 Programmer en langage C 128


Les unions
 on déclarera une variable p de type union partage par :
union partage p;
 cette variable pourra posséder soit une valeur entière,

Les types dérivés


soit un caractère, mais pas les deux à la fois.
 on déclarera une variable n de type union nombre par
union nombre n;
 cette variable pourra posséder soit une valeur entière,
soit une valeur flottante, mais pas les deux à la fois.

22/02/10 Programmer en langage C 129


•La mémoire de votre ordinateur
•Création d’un pointeur
•Définition
•Déclaration
•Initialisation
•Opérations élémentaires sur les pointeurs
•Pointeurs et tableaux
•Pointeurs et tableaux à deux dimensions
•Arithmétiques des pointeurs
•Allocation dynamique
•Allocation dynamique: Fonctions malloc et free

22/02/10 Programmer en langage C 130


La mémoire de votre ordinateur
 La compréhension des pointeurs, repose sur le
fonctionnement du mémoires de votre ordinateur.
 Tout d’abord un bref rappel sur le fonctionnement des
ordinateurs. Un ordinateur comporte un processeur et de

Les pointeurs
la mémoire. Les deux sont connectés par un bus, c'est-à-
dire un ensemble de lignes électriques
Mémoire(RAM) Adresses
rate
1000
Processeur 100 1004
Bus 1008
1009
1010
1014
Un octet = 8 bits 1018

22/02/10 Programmer en langage C 131


La mémoire de votre ordinateur
 La mémoire vive de votre ordinateur est constituée de milliers
d’emplacements mémoire rangés de façon séquentielle. Chaque
emplacement a une adresse unique, comprise entre 0 et une
valeur maximale qui dépend de la quantité de mémoire

Les pointeurs
installée sur votre ordinateurs.
 Lorsqu’une variable est déclarée, le compilateur réserve un
emplacement mémoire (une série de bits qu’on ne lit/écrit pas
un par un mais par paquets de huit, ce que l'on appelle un octet
(byte).) avec une adresse unique pour stocker cette
variable(qu’on peut relire plus tard) .
 Le compilateur associe l’adresse au nom de la variable. Quand
le programme utilise le nom de la variable, il accède
automatiquement à l’emplacement mémoire correspondant

22/02/10 Programmer en langage C 132


La création d’un pointeur
 Dans la figure précédente nous avons déclaré une variable rate et
nous l’avons initialisé à 100. Le compilateur à réservé un
emplacement mémoire à l’adresse 1004, qu’il associe au nom de la
variable.

Les pointeurs
 L’adresse de cette variable rate est un nombre, ce qui nous permet
de l’utiliser comme n’importe quel autre nombre en langage C.
 Si vous connaissez l’adresse d’une variable, vous pouvez créer une
autre variable pour y stocker l’adresse de la première.
 La première étape consiste à déclarer la variable dans laquelle on
stockera l’adresse de rate.

22/02/10 Programmer en langage C 133


La création d’un pointeur
 Soit p_rate la variable dans laquelle on stockera
l’adresse de rate, d’après le schéma ci-dessous un
emplacement mémoire a été réservé pour p_rate
1001 1002 1003 1004 1005

Les pointeurs
? 100

p_rate rate
 L’étape suivante consiste à stocker l’adresse de rate
dans la variable p_rate, celle-ci représente
maintenant l’emplacement mémoire de la variable
rate 1001 1002 1003 1004 1005
1004 100

p_rate rate

22/02/10 Programmer en langage C 134


Définition
 Un pointeur est une variable qui contient l'adresse d'une autre variable.

Déclaration
 On déclare un pointeur par l’instruction :

Les pointeurs
type *nom_du_pointeur ;

•Où: type est le type de la variable pointée,


•l’identificateur nom_du_pointeur est le nom de la variable
pointeur et * est l’opérateur qui indiquera au compilateur
que c’est un pointeur.
Exemple : int *p; float *p_float; char *p_char;
On dira que :p est un pointeur sur une variable du type int ,
ou bien p peut contenir l'adresse d'une variable du type int
*p est de type int, c’est l’emplacement mémoire pointé par p.
22/02/10 Programmer en langage C 135
Initialisation

 Déclarer un pointeur n’est pas suffisant, si vous ne


le faites pas pointer sur une variable, il est inutile.
 Un pointeur doit contenir l’adresse d’une variable

Les pointeurs
en utilisant l’opérateur &, quand il est placé avant
le nom de la variable, l’opérateur d’adresse renvoie
l’adresse de cette variable. Son initialisation est une
instruction de la forme : pointeur=&variable;

22/02/10 Programmer en langage C 136


Initialisation

 Exemple 1 :
int A, B, *P; /*supposons que ces variables occupent
la mémoire à partir de l’adresse 1000 */

Les pointeurs
A = 10;
B = 50;
P = &A ; // se lit : mettre dans P l’adresse de A
B = *P ; /* se lit : mettre dans B le contenu de
la variable pointée par P */
*P = 20; /*mettre la valeur 20 dans la variable
pointé par P*/
P = &B; // P pointe sur B

22/02/10 Programmer en langage C 137


Exemple 1:

void main()
{ int v=12;
int u=10;

Les pointeurs
int *vP; /*pointeur sur int*/
vP = &v; /*affectation du pointeur */
u = *vP;
printf(“u=%d v=%d\n”,u,v);
*vP = 25;
printf(“u=%d v=%d\n”,u,v);
printf(“*vP=%d”,*vP);
}
22/02/10 Programmer en langage C 138
Exemple 2 :
#include <stdio.h>
#include <conio.h>
Void main( )
{ float a , *p; /*supposons que ces variables sont représentées en

Les pointeurs
mémoire à partir de l’adresse 1000*/
clrscr( ); // pour effacer l’écran<conio.h>
p = &a;
printf(‘’Entrer une valeur : ‘’);
scanf(‘’%f’’ ,p); // on saisie la valeur 12.4
printf(‘’\nAdresse de a = %d Contenu de a = %f’’ ,p,*p);
*p += 0.4;
printf(‘’a = %f *p = %f ‘’, a,*p);
getch( ); // pour lire un caractère <conio.h>}
22/02/10 Programmer en langage C 139
Opérations élémentaires sur les pointeurs
 L’opérateur & : ’adresse de’ : permet d’obtenir
l’adresse d’une variable.
 L’opérateur * : ’contenu de’ : permet d’accéder au

Les pointeurs
contenu d’une adresse.
 Si un pointeur P pointe sur une variable X, alors *P
peut être utilisé partout où on peut écrire X.
 Exemple :
 int X=1, Y, *P Après l’instruction, P = &X ; On a :
Y = X + 1 équivalente à Y = *P + 1
X += 2 équivalente à *P += 2
++X équivalente à ++ *P
X++ équivalente à (*P)++
22/02/10 Programmer en langage C 140
Opérations élémentaires sur les pointeurs
 Le seul entier qui puisse être affecté à un pointeur d’un type
quelconque P est la constante entière 0 désignée par le
symbole NULL défini dans <stddef.h>.
 On dit alors que le pointeur P ne pointe ’nulle part’.

Les pointeurs
 Exemple :
#include <stddef.h>
int *t, x , *r;
short y = 10 , *pt = &y;
t = NULL ; /* Correct */
t = 0 ; /* Correct */
x=0;
t = x ; /* Incorrect ! bien que x vaille 0 */
r = &x ;
t = r ; /* Correct : p et q pointe sur des variables de même type*/
t = pt ; /* Incorrect : p et pt pointe sur des variable de type différent */

22/02/10 Programmer en langage C 141


Exercices
 Trouvez les erreurs dans les suites d’instruction
suivantes :
a) *p = x est incorrect parce
que le pointeur p n’est pas
a) int *p , x = 34; *p = x initialisé

Les pointeurs
b) int x = 17 , *p = x; *p = 17 b) p = x est incorrect. Pour que
c) double *q; int x = 17 , *p; p pointe sur x :p = &x
p = &x; q =p; c) q = p incorrect. q et p deux
d) int x, *p; &x = p; pointeurs sur des types
différent

d)&x = p incorrect. &x n’est pas


une variable (lvalue) et par
conséquent ne peut pas
figurer à gauche d’une
affectation.

22/02/10 Programmer en langage C 142


Pointeurs et tableaux
 En C, il existe une relation très étroite entre tableaux et pointeurs.
Ainsi, chaque opération avec des indices de tableaux peut aussi
être exprimée à l’aide de pointeurs. En effet, le nom d’un tableau
représente l’adresse de son premier élément :
 Tableau à une dimension (int T[N]) :

Les pointeurs
○ le nom T du tableau est un pointeur constant sur le premier élément
(1er entier) du tableau
○ T et &T[0] contiennent l’adresse du premier élément (1er entier) du
tableau.
 Tableau à deux dimensions( int T[N][M]) :
○ le nom T est un pointeur constant sur le premier tableau d’entiers
○ T[i] est un pointeur constant sur le premier élément (1er entier) du
ième tableau.
○ T et T[0] contiennent la même adresse mais leur manipulation n’est
pas la même puisqu’ils ne représentent pas le même type de
pointeur.

22/02/10 Programmer en langage C 143


Pointeurs et tableaux
 Adressage et accès aux composantes d’un tableau
à une dimension
En déclarant un tableau A de type int (int A[N]) et un
pointeur P sur des variables entière (int *P), l’instruction P

Les pointeurs
= A crée une liaison entre le pointeur P et le tableau A en
mettent dans P l’adresse du premier élément de A (de même
P = &A[0]).
 A partir du moment où P = A, la manipulation du tableau A
peut se faire par le biais du pointeur P. En effet
p pointe sur A[0] *p désigne A[0]
p+1 pointe sur A[1] *(p+1) désigne A[1]
..
p+(N-1) pointe sur A[N-1] *(p+N-1) désigne A[N-1]

22/02/10 Programmer en langage C 144


Exemple ( Lecture et Affichage d’un tableau
matérialisé par un pointeur)
#include ’’stdio.h’’
#define N 10
void main()

Les pointeurs
{ float t[N] , *pt ;
int i ;
printf("Entrez %d entiers\n", N) ;
pt = &t[0] ; /* ou pt = t */
for (i = 0 ; i<N; i++)
scanf("%f", pt+i) ; /* pt+i pointe sur t[i] */
printf("\n Tableau lu : \n") ;
for (i = 0 ; i<N ; i++)
printf("%7.2f", *(pt+i)) ; /* *(pt+i) équivalente à pt[i]*/
}
22/02/10 Programmer en langage C 145
Exemple ( Lecture et Affichage d’un tableau
matérialisé par un pointeur)
/* Autre Solution sans déclarer la variable i */
#include <stdio.h>
#define N 10

Les pointeurs
void main()
{ float T[N] , *pt ;
printf("Entrez %d entiers\n", N) ;
for (pt = T ; pt<T+N; pt++)
scanf("%f", pt) ;
printf("\nTableau lu : \n") ;
for (pt = T ; pt<T+N; pt++)
printf("%7.2f", *pt) ;
}
22/02/10 Programmer en langage C 146
Pointeurs et tableaux à deux dimensions
 En déclarant une matrice A de type int (int A[M][N]) et un
pointeur P sur des variables entières (int *P),
 l’instruction P = A[0] crée une liaison entre le pointeur P et la
matrice A en mettent dans P l’adresse du premier élément de la

Les pointeurs
première ligne de la matrice A ( P = &A[0][0]). A partir du
moment où P = A[0], la manipulation de la matrice A peut se
faire par le biais du pointeur P. En effet :
p pointe sur A[0][0] et * p désigne A[0][0]
p+1 pointe sur A[0][1] et * ( p + 1 ) désigne A[0][1]
..
p+N pointe sur A[1][0] et * ( p + N ) désigne A[1][0]
p+N+1 pointe sur A[1][1] et * ( p + N + 1 ) désigne A[1][1]
..
p + M * N-1 pointe sur A[M-1][N-1] et * ( p + M * N -1 ) désigne
A[M-1][N-1]

22/02/10 Programmer en langage C 147


Exemple ( Lecture et Affichage d’une matrice
matérialisé par un pointeur)
#include <stdio.h>
#define M 4
#define N 10
void main()

Les pointeurs
{ short A[M][N] ;
short *pt ;
int i, j ;
/* lecture d’une matrice */
pt = &A[0][0] ; /* ou bien pt = A[0] ; */
for (i = 0 ; i<M ; i++)
{
printf("\t ligne n° %d\n", i+1) ;
for (j = 0 ; j<N ; j++)
scanf("%i", pt + i * N + j ) ;
} for (i = 0 ; i<M ; i++)
{ for (j = 0 ; j<N ; j++)
printf("%d", *( pt + i * N + j ) ) ;
printf("\n") ; }}

22/02/10 Programmer en langage C 148


Arithmétiques des pointeurs

 Affectation par un pointeur sur le même type :


 Soient P1 et P2 deux pointeurs sur le même type de
données.

Les pointeurs
 L’affectation : P1 = P2 ; fait pointer P1 sur le même
objet que P2.
 Addition et soustraction d’un nombre entier :
 Si P pointe sur l’élément A[i] d’un tableau, alors :
 P+n pointe sur A[i+n] et P-n pointe sur A[i-n]

22/02/10 Programmer en langage C 149


Arithmétiques des pointeurs
 Incrémentation et décrémentation d’un pointeur :
 Si P pointe sur l’élément A[i] d’un tableau, alors après
l’instruction :
 P++ ; P pointe sur A[i+1]

Les pointeurs
 P += n ; P pointe sur A[i+n]
 P-- ; P pointe sur A[i-1]
 P -= n ; P pointe sur A[i-n]
 Comparaison de deux pointeurs :
 On peut comparer deux pointeurs de même type par :
<, >, <=, >=, == ou !=
 La comparaison de deux pointeurs qui pointent dans le
même tableau est équivalente à la comparaison des
indices correspondants.
22/02/10 Programmer en langage C 150
Autres déclarations des pointeurs :
 En C, il existe d’autres déclarations des pointeurs. En effet :
 Tableau de pointeurs :
int *Tab[20] ;

Les pointeurs
déclare un tableau Tab de 20 pointeurs d’entiers.
 Pointeur de tableaux :
int (*pt)[30] ;
déclare un pointeur pt sur des tableaux de 30
composantes.
 Pointeur de pointeurs :
int **pt ;
déclare un pointeur pt qui pointe sur des pointeurs
d’entiers.

22/02/10 Programmer en langage C 151


Allocation dynamique

 La déclaration d’un tableau définit un tableau statique


(il possède un nombre figé d’emplacements). Il y a
donc un gaspillage d’espace mémoire en réservant

Les pointeurs
toujours l’espace maximal prévisible.
 Il serait souhaitable que l’allocation de la mémoire
dépend du nombre d’éléments à saisir. Ce nombre ne
sera connu qu’à l’exécution : c’est l’allocation
dynamique.

22/02/10 Programmer en langage C 152


Allocation dynamique
 Fonction d’allocation dynamique de la mémoire
Bibliothèque <stdlib.h>
○ char *malloc(taille) ; //allocation d’un bloc
○ char *calloc(taille, sizeof(type)) ;//allocation & initialisation d’un
//bloc

Les pointeurs
○ char *realloc(char *, taille); //modification de la taille d’un bloc
○ void free(char *) ; //libération d’un bloc
Chacune des fonctions malloc, calloc ou realloc, prend une zone
d’une taille donnée dans l’espace mémoire libre réservé pour le
programme (appelé tas ou heap) et affecte l’adresse du début
de la zone à une variable pointeur.
S’il n’y a pas assez de mémoire libre à allouer, la fonction
renvoie le pointeurNULL.

22/02/10 Programmer en langage C 153


Allocation dynamique: Fonctions malloc et free

 malloc
<pointeur> = <type> malloc(<taille>);
○ <type> est un type pointeur définissant la variable pointé par

Les pointeurs
<pointeur>
○ <taille> est la taille, en octets, de la zone mémoire à allouer
dynamiquement, <taille> est du type unsigned int, donc on
ne peut pas réserver plus de 65536 octets à la fois
 La fonction malloc retourne l’adresse du premier
octet de la zone mémoire allouée. En cas d’échec, elle
retourne NULL.

22/02/10 Programmer en langage C 154


Allocation dynamique: Fonctions malloc et free

 free
Si on n’a plus besoin d’un bloc de mémoire réservé
dynamiquement par malloc, alors on peut le libérer à

Les pointeurs
l’aide de la fonction free.
free(<pointeur>);
Libère le bloc de mémoire désigné par le pointeur
<pointeur>

22/02/10 Programmer en langage C 155


Exemple (Allocation dynamique, Saisie et
Affichage d’un tableau )
#include <stdio.h>
#include <stdlib.h>
void main()

Les pointeurs
{short *pt;
int N , i;
printf("Entrez la taille N du tableau \n") ;
scanf("%d", &N) ;
pt = ( short * ) malloc( N * sizeof( short ) );
if (pt == NULL)
{printf("Mémoire non disponible") ;
system("pause");
}
22/02/10 Programmer en langage C 156
Exemple (Allocation dynamique, Saisie et
Affichage d’un tableau )

printf("Saisie du tableau : ");


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

Les pointeurs
scanf("%d", pt + i ) ;
printf("Affichage du tableau ") ;
for ( i= 0 ; i < N; i++)
printf("%d\t", *( pt + i ) ) ;
free( pt );
}

22/02/10 Programmer en langage C 157


Annexe A:

 Explication de l’exemple 1

Les pointeurs
22/02/10 Programmer en langage C 158
Annexe A:
 Gestion dynamique des tableaux
EXEMPLE :
/* Déclaration d'un pointeur sur des entiers p et de la taille du
tableau N */

Les pointeurs
int* p=NULL;
int N;
/* Saisie de la taille du tableau par l'utilisateur */
scanf ("%d",&N);
/* Allocation dynamique de la zone mémoire occupée par le
tableau */
p = (int*)malloc (N*sizeof(int));

22/02/10 Programmer en langage C 159


Pointeurs et structures
 Les pointeurs membres d’une structure
Un pointeur qui est membre d’une structure se déclare
de la même façon qu’un pointeur qui ne l’est pas, en
utilisant l’opérateur indirect(*), exemple:

Les pointeurs
Struct data {
int *valeur;
int *taux;
} premier;
Soit cout et interet de variable de type int tel que :
○ int cout, interet;
L’initialisation du pointeur valeur et taux suit la syntaxe
suivante :
○ premier.valeur=&cout;// (*premier.valeur=cout;)
○ premier.taux=&interet; // (*premier.taux=interet;)

22/02/10 Programmer en langage C 160


Pointeurs et structures
 Les pointeurs vers une structure
Soit la structure personne définie par:
Struct point{
int num;
float x;

Les pointeurs
float y;
}
On déclarera une variable de type pointeur vers cette structure
de la façon suivante :
○ struct point *p;
Pour initialiser ce pointeur, il faut déclarer une structure sur le
modèle struct point, sur laquelle il va pointer :
○ Struct point pnt;
○ p=&pnt;

22/02/10 Programmer en langage C 161


Pointeurs et structures
 Les pointeurs vers une structure
Pour accéder aux membres de la structure point, on utilise soit l’opérateur (.) :
○ (*p).num=1;
○ (*p).x=1.2;
○ (*p).y=2.5;

Les pointeurs
soit (->) comme suit:
○ p ->num=1;
○ p ->x=1.2;
○ p ->y=2.5;

22/02/10 Programmer en langage C 162


Pointeurs et structures
 Pointeurs et tableaux de structures
 Soit la structure définie par:
 struct part{
int nombre;
char nom[10];

Les pointeurs
};
Nous pouvons déclarer un tableau appartenant au type part
○ struct part data[50];
Nous pouvons ensuite déclarer un pointeur vers une structure de
type part, et l’initialiser pour pointer sur la première structure du
tableau data:
○ struct part *p_part;
○ p_part=&data[0];// ou bien écrire p_part=data;
Nous obtenons un tableau de structures de type part et un pointeur
vers le premier élément du tableau. On affiche le contenu du premier
élément avec l’instruction:
 printf(’’ %d %s ’’, p_part->nombre , p_part ->nom);

22/02/10 Programmer en langage C 163


Pointeurs et structures
 Pointeurs et tableaux de structures :exemple
#include<stdio.h>
#define max 4
Struct part{
int nombre;
char nom[10];

Les pointeurs
}data[Max]={1,’’smith’’,
2, ‘’jones’’,
3, ‘’Adams’’,
4,’’Wilson’’
};
Struct part *p_part;
int count;
void main(){
P_part=data;
For(count=0;count<Max;count++)
{ printf(‘’A l’adresse %d : %d %s\n’’,p_part,p_part->nombre,p_part->nom);
p_part++;}}

22/02/10 Programmer en langage C 164


•Définition
•Exemple de définition et d’utilisation d’une fonction en C
•Exemple de fonction sans résultat
•Le cas des fonctions sans paramètres
•Règles
•Une fonction peut en appeler une autre
•En langage C, les paramètres sont transmis par valeur
•Passage des paramètres par adresse
•Passage de tableau en paramètre
•Passage de structure en paramètre
•Fonctions récursives
•Fonctions prédéfinies : math.h

22/02/10 Programmer en langage C 165


Définition
 Une fonction est un bloc de code C indépendant, référencé par un
nom, qui réalise une tâche précise et qui peut renvoyer une valeur
au programme qui l’a appelée :
 Une fonction est référencée par un nom: ce nom est unique et en
l’introduisant dans la source de votre programme, vous pouvez exécuter le

Les fonctions
code de la fonction. une fonction peut être appelée par une autre fonction.
 Une fonction est indépendante : une fonction peut effectuer avec ou sans
échanges avec une autre partie du programme.
 Une fonction réalise une tâche particulière : cela peut être l’envoi d’une ligne
de texte vers l’imprimante, un tri, ou le calcul d’une racine carrée.
 Une fonction peut renvoyer une valeur au programme appelant: Quand ce
programme appelle la fonction, le code de cette fonction est exécuté. Ces
instructions peuvent renvoyer une information au programme.

22/02/10 Programmer en langage C 166


Définition : Syntaxe

type identificateur ( liste de-déclarations-de-paramètres )


{
liste-de-déclarationsoption(optionnel)

Les fonctions
liste-d'instructions
}

 type identificateur ( liste-de-déclarations-de-paramètres );


porte le nom de prototype de fonction.

22/02/10 Programmer en langage C 167


Définition : Sémantique
 Type :est le type de la valeur rendue par la fonction ;
 identificateur :est le nom de la fonction ;
 Liste de déclarations-de-paramètres : est la liste
(séparés par des virgules) des déclarations des

Les fonctions
paramètres formels.
 La liste-de-déclarationsoption : permet si besoin, de
déclarer des variables qui seront locales à la fonction,
elles seront donc inaccessibles de l'extérieur.
 La liste-d'instructions: est l'ensemble des instructions
qui seront exécutées sur appel de la fonction. Parmi
ces instructions, il doit y avoir au moins une
instruction du type : return expression ;

22/02/10 Programmer en langage C 168


Définition: Appel d’une fonction
 Syntaxe :
Expression :
 identificateur ( liste-d'expressions )

Les fonctions
 Sémantique :
Les expressions de liste-d'expressions sont évaluées,
puis passées en tant que paramètres effectifs à la
fonction de nom identificateur, qui est ensuite exécutée.
La valeur rendue par la fonction est la valeur de
l'expression appel de fonction.

22/02/10 Programmer en langage C 169


Exemple de définition et d’utilisation d’une fonction en C
#include <stdio.h>
/***** le programme principal (fonction main) *****/
void main()
{ /* déclaration de fonction fexple */
float fexple (float, int, int) ; /* prototype de la fonction cube */

Les fonctions
float x = 1.5 ;
float y, z ;
int n = 3, p = 5, q = 10 ;
/* appel de fexple avec les arguments x, n et p */
y = fexple (x, n, p) ;
printf ("valeur de y : %e\n", y) ;
/* appel de fexple avec les arguments x+0.5, q et n-1 */
z = fexple (x+0.5, q, n-1) ;
printf ("valeur de z : %e\n", z) ;
}

22/02/10 Programmer en langage C 170


Exemple de définition et d’utilisation d’une fonction en C

/*************** la fonction fexple ****************/


float fexple (float x, int b, int c)
{

Les fonctions
float val ; /* déclaration d’une variable "locale" à fexple
val = x * x + b * x + c ;
return val ;
}

22/02/10 Programmer en langage C 171


Exemple de définition et d’utilisation d’une fonction en C

#include<stdio.h>
/* déclaration de la fonction cube*/
long cube(long x); /* prototype de la fonction cube */
/****************************************************/

Les fonctions
long input, reponse;
void main()
{
printf("entrez une valeur entière : ");
scanf("%ld",&input);
reponse=cube(input);
printf("\n\n le cube de %ld est %ld\n", input, reponse);
}

22/02/10 Programmer en langage C 172


Exemple de définition et d’utilisation d’une fonction en C

/* définition de la fonction */

long cube(long x) /* en-tête de la fonction cube*/

Les fonctions
{ /*attention pas de ; */
long x_cube; /* variable “locale” à la fonction cube */
x_cube= x*x*x;
return x_cube;
}

22/02/10 Programmer en langage C 173


Exercice
Quels seront les résultats fournis par ce programme :
main()
{ int arrondi (float) ; /* prototype de la fonction arrondi */
float v1 = 1.6, v2 = 2.8 ;

Les fonctions
int p ;
p = arrondi (v1) ; printf (“%d\n”, p) ;
p = arrondi (v2) ; printf (“%d\n”, p) ;
printf (“%d %d\n”, arrondi(v1+v2), arrondi(v1) + arrondi(v2) ) ;
}
int arrondi (float r)
{ float y ;int n ;
y = r + 0.5 ;
n=y;
return n ;
}

22/02/10 Programmer en langage C 174


Autre exemple
/*définition d’une fonction, nommée max, qui fournit en
résultat la plus grande des trois valeurs entières reçues en
paramètres*/

Les fonctions
int max (int a, int b, int c)
{ int m ;
m=a;
if ( b>m ) m = b ;
if ( c>m ) m = c ;
return m ;
}

22/02/10 Programmer en langage C 175


Autre exemple

/*programme principal*/
void main()

Les fonctions
{ int max (int, int, int) ; /* prototype de notre fonction max */
int n, p, q, m ;
n=3;p=5;q=2;
m = max (n, p, q) ;
printf (“max de %d %d %d : %d\n”, n, p, q, m) ;
m = max (5*n, n+p, 12) ;
printf (“valeur : %d\n” , m) ;
}

22/02/10 Programmer en langage C 176


Exemple de fonction sans résultat
Soit la définition de fonction nommée optimist :
void optimist (int nfois)
{ int i ;
for (i=0 ; i<nfois ; i=i+1)

Les fonctions
printf (“il fait beau\n”) ;
}
 Son en-tête montre qu’elle comporte un paramètre entier
(nommé nfois) ; cette fois, il est précédé du mot void qui
indique que la fonction ne fournit pas de résultat.
 Si l’on examine les instructions du corps de la fonction, on
constate qu’elles affichent un certain nombre de fois le
même texte : il fait beau. Pour effectuer son travail, notre
fonction a eu besoin d’une variable locale (i).

22/02/10 Programmer en langage C 177


Exemple de fonction sans résultat

 Remarques:
Aucune instruction return ne figure dans la définition
de notre fonction.

Les fonctions
y = optimist (k) ; /* incorrect */
l’appel de cette fonction ce fait à l’aide d’une instruction
de la forme :
optimist (k) ; /* instruction simple provoquant
l’appel de optimist à laquelle on
transmet en paramètre, la valeur de k */

22/02/10 Programmer en langage C 178


Exemple de fonction sans résultat
void main()
{ void optimist (int) ; /* prototype de la fonction optimist */
int n = 2, p = 1 ;
optimist (n) ;

Les fonctions
optimist (p) ;
optimist (n+p) ;
}
void optimist (int nfois)
{ int i ;
for (i=0 ; i<nfois ; i=i+1)
printf (“il fait beau\n”) ;
}

22/02/10 Programmer en langage C 179


Le cas des fonctions sans paramètres
 Si une fonction ne possède aucun paramètre, son en-
tête et sa déclaration (prototype) doivent comporter le
mot void, à la place de la liste des paramètres.
 Exemple :

Les fonctions
int fexple1 (void)
Sa déclaration (prototype) serait:
int fexple1 (void) ;
 L’en-tête d’une fonction ne recevant aucun paramètre
et ne fournissant aucun résultat est:
void fexple2 (void)
 Son prototype est:
void fexple2 (void) ;

22/02/10 Programmer en langage C 180


Le cas des fonctions sans paramètres
 L’appel d’une fonction sans paramètres doit
comporter des parenthèses vides.
Exemple:
L’appel de fexple1 s’écrira : fexple1()

Les fonctions
et non simplement : fexple1
Exemple :
#include<stdio.h>
Void affiche(void);
Void main()
{ affiche();}
Void affiche(void)
{ printf(‘’bonjour’’);}

22/02/10 Programmer en langage C 181


Règles
 Arguments muets et arguments effectifs
Les noms des arguments figurant dans l’en-tête de la
fonction se nomment des « arguments muets », ou
encore « arguments formels » ou « paramètres formels »

Les fonctions
(de l’anglais : formal parameter). Leur rôle est de
permettre, au sein du corps de la fonction, de décrire ce
qu’elle doit faire.
Les arguments fournis lors de l’utilisation (l’appel) de la
fonction se nomment des « arguments effectifs » (ou
encore « paramètres effectifs »).

22/02/10 Programmer en langage C 182


Règles: L’instruction return
 L’instruction return peut mentionner n’importe
quelle expression. Ainsi, nous pourrons définir la
fonction fexple d’une manière plus simple :
○ float fexple (float x, int b, int c)

Les fonctions
{ return (x * x + b * x + c) ;}
 L’instruction return peut apparaître à plusieurs
reprises dans une fonction, comme dans cet autre
exemple :
○ double absom (double u, double v)
{ double s ;
s=a+b;
if (s>0) return (s) ;
else return (-s);
}

22/02/10 Programmer en langage C 183


Règles : Prototype
 L’instruction de déclaration du prototype sert à fournir au
compilateur les informations nécessaires à la traduction
des différents appels de la fonction (sans qu’il dispose des
instructions de définition de cette fonction).

Les fonctions
 En ce qui concerne son emplacement, le prototype peut
figurer :
 soit parmi les différentes déclarations situées au début d’une
fonction (y compris main) ; il n’est alors connu que dans la
dite fonction ; c’était le cas dans les exemples rencontrés
jusqu’ici ;
 soit avant toutes les définitions de fonctions, à un niveau
global (comme les variables globales dont nous parlerons un
peu plus loin) ; dans ce cas, il est utilisable par toutes les
fonctions du programme.

22/02/10 Programmer en langage C 184


Règles : Initialisation des variables locales
 Les variables locales peuvent être initialisées lors de
leur déclaration. Dans ce cas, il faut savoir que la
valeur indiquée est placée dans la variable, non pas au
moment de la compilation, mais à chaque appel de la

Les fonctions
fonction. Par exemple, avec cette définition :
void affiche (void)
{ int n = 10 ;
printf (“%d”, n) ;
n=n+1;
}
 on obtiendra l’affichage de la valeur 10, à chaque appel
de affiche.

22/02/10 Programmer en langage C 185


Une fonction peut en appeler une autre
 Rien n’empêche qu’une fonction appelle, à son tour, une
autre fonction, comme dans ce canevas :
void main()
{ int f1 (float) ; /* prototype de f1 */

Les fonctions
.....
f1 (...) ; /* appel de f1 */
.....
}
int f1 (float)
{ void f2 (int) ; /* prototype de f2 */
.....
f2 (...) ;
.....
}
22/02/10 Programmer en langage C 186
En langage C, les paramètres sont transmis
par valeur
void main(){
void echange (int a, int b) ;
int n=10, p=20 ;

Les fonctions
printf (“avant appel : %d %d\n”, n, p) ;
echange (n, p) ;
printf (“après appel : %d %d”, n, p) ; avant appel : 10 20
} début echange : 10 20
void echange (int a, int b) fin echange : 20 10
{ int c ; après appel : 10 20
printf (“début echange : %d %d\n”, a, b) ;
c=a;a=b;b=c;
printf (“fin echange : %d %d\n”, a, b) ;
}
22/02/10 Programmer en langage C 187
En langage C, les paramètres sont transmis
par valeur
 La fonction echange reçoit deux valeurs correspondant à ses
deux paramètres muets a et b. Elle effectue un échange de ces
deux valeurs. Mais, lorsque l’on est revenu dans le programme

Les fonctions
principal, aucune trace de cet échange ne subsiste sur les
paramètres effectifs n et p.
 En effet, lors de l’appel de echange, il y a eu transmission de la
valeur des expressions n et p. On peut dire que ces valeurs ont
été recopiées “localement” dans la fonction echange dans des
emplacements nommés a et b. C’est effectivement sur ces copies
qu’a travaillé la fonction echange, de sorte que les valeurs des
variables n et p n’ont, quant à elles, pas été modifiées. C’est ce
qui explique le résultat constaté.

22/02/10 Programmer en langage C 188


En langage C, les paramètres sont transmis
par valeur

 Solutions :
Transmettre en paramètre la “valeur” de l’“adresse”

Les fonctions
d’une variable. La fonction recevra, certes, toujours une
copie de cette adresse, mais elle pourra éventuellement
agir sur ce qui se trouve à cette adresse. Ceci est possible
grâce aux “pointeurs”.
 Utiliser des “variables globales”.

22/02/10 Programmer en langage C 189


Passage des paramètres par adresse
 Pour changer la valeur d’une variable de la fonction
appelante, on procède comme suit :
la fonction appelante doit fournir l’adresse de la variable;
la fonction appelée doit déclarer le paramètre comme

Les fonctions
pointeur.
Exemple:
void add(int a, int b, int *c) {
/* c repère l’entier où on veut mettre le résultat */
*c = a + b;}
void main() {
int i=10,j=14,k;
/* on passe les valeurs de i et j comme premiers paramètres */
/* on passe l’adresse de k comme troisième paramètre */
add(i,j,&k);}

22/02/10 Programmer en langage C 190


Passage des paramètres par adresse
/*passage d’arguments par valeur et par adresse */
#include<stdio.h>
void par_valeur(int a, int b, int c);
void par_adresse(int *a, int *b,int *c);

Les fonctions
void main(){
int x=2, y=4, z=6;
par_valeur(x,y,z);
par_adresse(&x,&y,&z); }
void par_valeur(int a, int b, int c)
{a=0;b=0;c=0;}
void par_valeur(int *a, int *b, int *c)
{*a=0;*b=0;*c=0;}

22/02/10 Programmer en langage C 191


Passage des paramètres par adresse
void main(){
void echange (int *a, int *b) ;
int n=10, p=20 ;
printf (“avant appel : %d %d\n”, n, p) ;

Les fonctions
echange (&n, &p) ;
printf (“après appel : %d %d”, n, p) ; avant appel : 10 20
} début echange : 10 20
void echange (int *a, int *b) fin echange : 20 10
{ int c ; après appel : 20 10
printf (“début echange : %d %d\n”, *a, *b) ;
c = *a ; *a = *b ; *b = c ;
printf (“fin echange : %d %d\n”, *a, *b) ;
}
22/02/10 Programmer en langage C 192
Passage de tableau en paramètre
 Tableau à une dimension de taille fixe
void main()
{ int i ;
int t[5] = { 1, 1, 1, 1, 1 } ; /* initialisation du tableau */
void affiche (int [5]) ; /* prototype de la fonction affiche */

Les fonctions
printf (“tableau t avant appel de affiche : ”) ;
for (i=0 ; i<5 ; i=i+1) printf (“%d ”, t[i]) ;
printf (“\n”) ;
affiche (t) ; /* appel de affiche, à laquelle on transmet en paramètre le tableau t
*/
printf (“tableau t après appel de affiche : ”) ;
for (i=0 ; i<5 ; i=i+1) printf (“%d ”, t[i]) ;
}
void affiche (int v[5])
{ int i ;
for (i=0 ; i<5 ; i=i+1)
v[i] = i+1 ;}

22/02/10 Programmer en langage C 193


Passage de tableau en paramètre
 Tableau à une dimension de taille fixe
Le mécanisme
○ Pour le compilateur, un nom de tableau (par exemple t) est
identique à son adresse, c’est-à-dire à l’adresse de son
premier élément (ici, &t[0]) ;

Les fonctions
○ l’appel affiche (t) provoque la transmission à la fonction
affiche, de la valeur du paramètre t c’est-à-dire en fait de
l’adresse du tableau t (il y a bien toujours mécanisme de
transmission par valeur, mais cette valeur se trouve être celle
d’une adresse) ;
○ dans la fonction affiche, à chaque appel, le symbole t est
remplacé par sa “valeur”, c’est-à-dire en l’occurrence l’adresse
reçue en paramètre ; ainsi, une affectation telle que : v[i] = 0 ;
est traduite en : affecter au i-ème entier, à partir de l’adresse
v, la valeur 0.

22/02/10 Programmer en langage C 194


Passage de tableau en paramètre
 Tableau à une dimension de taille variable
/* Initialise les éléments d’un tableau */
void init (int tab[], int n)
{ int i;
for (i = 0; i < n; i++)

Les fonctions
tab[i] = i;
}
void main()
{ int i, n = 5;
int *tab;
tab = (int*)malloc(n * sizeof(int));
init(tab,n);
for(i=0;i<n;i++) printf(‘’ %d\n’’,*tab++);
}

22/02/10 Programmer en langage C 195


Passage de tableau en paramètre
 Tableau à deux dimensions de taille fixe
void mat (int t[5][4])
{ int i, j ;
for (i=0 ; i<5 ; i++)

Les fonctions
for (j=0 ; j<4 ; j++)
t[i][j] = 1 ;
}
Voici quelques exemples d’utilisation de cette fonction :
void main ()
{ int tab [5] [4] ;
mat (tab) ;
}

22/02/10 Programmer en langage C 196


Passage de tableau en paramètre

 Tableau à deux dimensions de taille variable

 l’en-tête de mat pourra éventuellement ne pas

Les fonctions
préciser le nombre de lignes :
void mat (int t[][3])
 En revanche, il n’est pas possible de l’écrire :
void mat (int t[][])/* en-tête incorrect */

22/02/10 Programmer en langage C 197


Passage de structure en paramètre
#include<stdio.h>
#include<conio.h>
struct data{
float montant;
char fnom[20];
char lnom[20];

Les fonctions
}rec;
void affiche_rec(struct data x);
void main(){
printf("Entrez le montant du don\n");
scanf("%f",&rec.montant);
printf("Entrez le nom et le prénom du donateur\n");
scanf("%s %s", rec.lnom,rec.fnom);
printf("**********************\n");
affiche_rec(rec);
}
void affiche_rec(struct data x)
{ printf("\n le donateur %s %s a donné %.2f dh\n", x.lnom, x.fnom, x.montant);
}

22/02/10 Programmer en langage C 198


Passage de structure en paramètre
#include<stdio.h>
#define MAX 4
struct personne{
int numero;
char nom[10];

Les fonctions
} data[MAX]={{1,"Smith"},{2,"Jones"},{3,"Adams"},{4,"Wilson"}};
void affiche_str(struct personne [MAX]);
void main(){

affiche_str(data);
}
void affiche_str(struct personne x[MAX])
{int i;
for(i=0; i<MAX;i++)
printf("%d \t %s \n", x[i].numero,x[i].nom);
}

22/02/10 Programmer en langage C 199


Fonctions récursives
 Le langage C autorise la récursivité des appels de
fonctions. Celle-ci peut prendre deux aspects :
 récursivité directe : une fonction comporte, dans sa
définition, au moins un appel à elle-même,

Les fonctions
 récursivité croisée : l’appel d’une fonction entraîne celui
d’une autre fonction qui, à son tour, appelle la fonction
initiale (le cycle pouvant d’ailleurs faire intervenir plus
de deux fonctions).
Exemple
long fac (int n)
{
if (n>1) return (fac(n-1)*n) ;
else return(1) ;
}

22/02/10 Programmer en langage C 200


Fonctions prédéfinies : math.h
 Pour utiliser les fonctions de cette librairie, il faut
inclure la librairie par la directive #include <math.h>

Les fonctions
22/02/10 Programmer en langage C 201
Fonctions prédéfinies : math.h

Les fonctions
22/02/10 Programmer en langage C 202
•Définition
•Déclarations
•Chaînes de caractères constantes(chaînes littérales)
•Tableaux de caractères
•Chaînes et pointeurs
•Ordre alphabétique et lexicographique
•Manipulation des chaînes de caractères

22/02/10 Programmer en langage C 203


Définition
 Les variables de types char ne peuvent recevoir qu’un seul
caractères.

Les chaînes de caractères


 Un nom ou une adresse sont des exemples de chaînes de
caractères.
 Une chaîne de caractères est une suite de caractères
alphanumériques (du texte) qui se termine par le caractère
nul \0.
 Elle est représenté sur une suite d’octets se terminant par
un octet supplémentaire lié au symbole ’\0’. Celui-ci
indique une fin de chaîne.
 Une chaîne de caractères est considérée comme un tableau
de caractères.
 Il n’existe pas de type de données pour les chaînes de
caractères.
22/02/10 Programmer en langage C 204
Déclarations

 Sous forme de tableau

Les chaînes de caractères


char <nomchaine> [<longueur>];
 Sous forme de pointeur
Char *<nomchaine>;
 Exemples
Char nom[20];
Char *prenom;

22/02/10 Programmer en langage C 205


Chaînes de caractères constantes(chaînes
littérales)

 Sont représentées entre guillemets.

Les chaînes de caractères


La chaîne vide est noté ’’’’.
 Dans une chaîne, les caractères de contrôle peuvent
être utilisés.
 Exemples:
’’ce \n texte \n sera réparti sur 3 lignes.’’
’’Affichage de \’’ guillemets \’’ \n’’
’’un’’ ’’deux’’ ’’trois’’ sera évaluée comme ’’un deux trois’’

22/02/10 Programmer en langage C 206


Tableaux de caractères
 Pour stocker une chaîne de six caractères, il faut déclarer
un tableau de type char avec sept éléments:

Les chaînes de caractères


char chaine[7];
La septième case est réservée pour le caractère nul \0, même
s’il est représenté par deux caractères, il est interprété
comme un seul caractère et sa valeur ASCII est 0.
 Initialiser le tableaux des caractères
Char chaine[10]={‘b’,’o’,’n’,’j’,’o’,’u’,’r’,’\0’};
Char chaine[10]=’’bonjour’’;
Char chaine[]=’’bonjour’’;
Char chaine[7]=’’bonjour’’; /*erreur pendant l’exécution*/
Char chaine[6]=’’bonjour’’; /*erreur pendant la compilation*/

22/02/10 Programmer en langage C 207


Chaînes et pointeurs
 Une chaîne de caractères est stockée dans un tableau de type
char, et la fin de cette chaîne est représentée par le caractère
nul. Pour définir une chaîne, il suffit donc de pointer au début

Les chaînes de caractères


de cette chaîne. On peut donc représenté le début de la chaîne
par un pointeur vers une variable char :
 char *message;
 Cette instruction déclare le pointeur message vers une variable
de type char, mais le pointeur ne pointe encore sur rien. Si on
écrit:
 char *message=’’bonjour tout le monde’’;
 La chaîne sera stocker quelque part dans la mémoire(avec un
caractère nul à la fin).
 Voici une instruction équivalente à la précédente:
 char message[]=’’bonjour tout le monde ’’;

22/02/10 Programmer en langage C 208


Chaînes et pointeurs
 La fonction malloc:
 La fonction malloc() est une fonction qui permet de réserver de l’espace
mémoire. On lui transmet en argument le nombre d’octets nécessaires, elle

Les chaînes de caractères


se charge de trouver et de réserver un bloc de mémoire libre.
 Exemple :
○ char *p; p=malloc(1); p=’a’;
○ char *pt; pt=malloc(100);
 Remarques:
 char *ch1=’’une chaîne’’; char *ch2=’’une autre chaîne’’;
 ch1=ch2;/* ch1 et ch2 pointent sur la même chaîne*/
 char ch1[20]=’’une chaîne’’;
 char ch2[20]=’’une autre chaîne’’;
 Char ch3[30];
 ch1=ch2; /* impossible affichage d’erreur*/
 ch3= ’’bonjour’’; /* impossible affichage d’erreur*/

22/02/10 Programmer en langage C 209


Ordre alphabétique et lexicographique
 Ordre alphabétique des caractères:
Pour le code ASCII, on a l’ordre suivant :
○ …,0,1,2,…,9,…,A,B,…Z, ,b,…,c

Les chaînes de caractères


Il s’agit d’une relation d’ordre ’est inférieur à’ sur l’ensemble des
caractères.
Exemple:
○ ’0’ est inférieur à ’Z’ et noté : ’0’< ’Z’[(ASCII(’0’=48), ASCII(’Z’=90)]
 Ordre lexicographique des chaînes de caractères:
 Il se base sur l’ordre alphabétique des caractères.
 La chaîne vide ’’’’ précède toutes les autres chaînes.
 Exemples:
○ ’’ABC’’ précède ’’BCD’’ car ’A’ <’B’
○ ’’Abc précède ’’abc’’
○ ’’ab’’ précède ’’abcd’’ car ’’’’ précède ’’cd’’
○ ’’ ab’’ précède ’’ab’’ car [(ASCII(’ ’=12), ASCII(’a’=97)]

22/02/10 Programmer en langage C 210


Manipulation des chaînes de caractères
 Fonction de <stdio.h>
Affichage de chaînes de caractères
○ char ch[]=’’bonjour tout le monde’’;

Les chaînes de caractères


○ printf(’’%s’’,ch);
○ char *ch1;
○ puts(ch1); équivalente à printf(’’%s’’,ch1);
Lecture de chaînes de caractères
○ char lieu[30];
○ printf(’’entrez le lieu de naissance’’);scanf(’’%s’’,lieu);
○ char chaine[80];
○ printf(’’entrez une chaine’’); gets(chaine);
○ Contrairement à scanf, la fonction gets permet de saisir des chaînes de
caractères contenant des espaces et des tabulations.

22/02/10 Programmer en langage C 211


Manipulation des chaînes de caractères

 Fonctions de <string.h>
size_t strlen(const char * chaine);

Les chaînes de caractères


int strcmp(const char * chaine1, const char * chaine2);
char * strcat (char *destination, const char *source);
char * strcpy (char *destination, const char *source);
char * strncpy (char *destination, const char *source,
size_t n);
char * strchr(const char * chaine, int caractère);
char * strrchr(const char * chaine, int caractère);

22/02/10 Programmer en langage C 212


Manipulation des chaînes de caractères
 Fonctions de <string.h>
Longueur d'une chaîne de caractères

Les chaînes de caractères


○ La fonction strlen calcule la longueur d'une chaîne de caractères en
octets, le caractère nul n'étant pas compté.
○ le nombre de caractères comptés est retourné au programme par la
fonction, cela sous forme de valeur entière.
○ Exemple :
 c=strlen("bonjour");
 c aura la valeur 7.
Concaténation de chaînes de caractères
○ On peut concaténer deux chaînes de caractères en accrochant l'une
d'elles à la fin de l'autre. Cette opération s'effectue via la fonction
strcat.
○ Exemple:
 Strcat(ch1,ch2);

22/02/10 Programmer en langage C 213


Manipulation des chaînes de caractères
 Fonctions de <string.h>
Comparaison de chaînes de caractères

Les chaînes de caractères


○ La fonction strcmp compare deux chaînes caractère par
caractère, jusqu'à ce que soit détectée une différence ou que soit
atteint le caractère nul. La comparaison s'effectue dans l'ordre
alphanumérique. En d'autres termes, on vérifie à chaque fois si
les deux caractères à comparer occupent ou non la même place
dans la table des caractères utilisés. Ici, un caractère est
considéré comme supérieur à un autre s'il occupe une place plus
élevée dans la table des caractères, et inférieur s'il occupe une
place moins élevée. Ainsi, dans la table ASCII le caractère 'Z' est
plus grand que 'A' mais plus petit que 'a'.

22/02/10 Programmer en langage C 214


Manipulation des chaînes de caractères
 Fonctions de <string.h>
Comparaison de chaînes de caractères
○ Cette fonction retourne une valeur entière avec les conventions suivantes :

Les chaînes de caractères


 si la valeur est inférieure à 0, alors la chaîne dont l'adresse est donnée par le premier
paramètre de la fonction est inférieure à l'autre chaîne
 si la valeur est égale à 0, alors les deux chaînes sont égales
 si la valeur est supérieure à 0, alors la chaîne dont l'adresse est donnée par le
premier paramètre de la fonction est supérieure à l'autre chaîne.
 La valeur transmise au programme peut être stockée dans une variable de type int.
○ Exemple:
 int result;
 result=strcmp(ch1,ch2);

22/02/10 Programmer en langage C 215


Manipulation des chaînes de caractères
 Fonctions de <string.h>
Copie de chaînes de caractères
○ La fonction strcpy() (prononcez string copy) est une fonction qui

Les chaînes de caractères


permet de copier une chaîne entière de caractères dans une autre.
Cette fonction admet comme paramètres les deux chaînes de
caractères. Elle retourne 1 si la copie s'est effectuée correctement,
sinon elle renvoie 0.
○ Exemple:
 strcopy(ch1,ch2);
○ strncpy, est similaire à strcopy, on notera que:
 si la chaîne source a moins de n caractères non nuls, strncpy
rajoutera n - strlen(source) caractères nuls à la suite, pour
compléter;
 si la chaîne source fait au moins n caractères, la fonction
n'insèrera pas de caractère nul en fin de chaine (i.e. destination ne
sera pas une chaîne de caractères valide).

22/02/10 Programmer en langage C 216


Manipulation des chaînes de caractères
 Fonctions de <string.h>
Recherche dans une chaîne

Les chaînes de caractères


○ Les fonctions strchr & strrchr recherche le caractère dans la
chaîne et renvoie la position de la première occurrence dans le cas
de strchr et la position de la dernière occurrence dans le cas de
strrchr.
○ Exemple :
#include <stdio.h>
#include <string.h>
void main() {
char *str="E.N.A.C.", c = '.', *ptr;
if ( (ptr = strrchr(str, c)) != NULL)
printf("Le caractere %c est en position %d\n", c, ptr-str);
else
printf("Pas trouve\n"); }
___________________________________________
/* résultat de l'exécution */
Le caractere . est en position 7

22/02/10 Programmer en langage C 217


Manipulation des chaînes de caractères
#include <stdio.h>
#include <string.h>

Les chaînes de caractères


void main() {
char *str = "E.N.A.C.", c = 'A', *ptr;
if ( (ptr = strchr(str, c)) != NULL )
if (ptr)
printf("Le caractere %c est a la position %d\n", c, ptr-str);
else
printf("Le caractere %c n'est pas trouve dans %s\n", c, str
}
/* résultat de l'exécution*/
Le caractere A est a la position 4

22/02/10 Programmer en langage C 218


Manipulation des chaînes de caractères
#include <stdio.h>
#include <string.h>

Les chaînes de caractères


void main() {
char str[10];
char *ptr = "ABCDEFGHIJ";
strcpy(str, ptr); printf("%s\n", str);
} /* résultat de l'exécution: ABCDEFGHIJ*/
#include <stdio.h>
#include <string.h>
void main() {
char str[10]; char *ptr = "ABCDEFGHI";
strncpy(str, ptr, 3);
str[3] = '\0';
printf("%s\n", str); } /* résultat de l'exécution: ABC */

22/02/10 Programmer en langage C 219


Manipulation des chaînes de caractères
#include <stdio.h>
#include <string.h>

Les chaînes de caractères


void main() {
char *str = "E.N.A.C.";
printf("%d\n", strlen(str));} /* résultat de l'exécution: 8 */

#include <string.h>
#include <stdio.h>
void main() {
char m1[60] = "Ecole Nationale";
char *m2 = " de l'Aviation Civile";
strcat(m1, m2); printf("%s\n", m1); }
/* résultat de l'exécution: Ecole Nationale de l'Aviation Civile*/

22/02/10 Programmer en langage C 220


•Introduction
•Définition et propriétés
•Mémoire tampon
•Types de Fichiers
•Déclaration d’un fichier
•Ouverture de fichiers
•Fermeture de fichiers
•La fonction d’écriture en fichier
•La fonction de saisie en fichier
•Lecture et écriture par caractère
•Positionnement dans un fichier

22/02/10 Programmer en langage C 221


Introduction
 Le langage C offre la possibilité de lire et d’écrire des
données dans un fichier. Pour des raisons d’efficacité, les
accès à un fichier se font par l’intermédiaire d’une
mémoire-tampon (on parle de buffer), ce qui permet de
réduire le nombre d’accès aux périphériques (disque...).

Fichiers
 Pour pouvoir manipuler un fichier, un programme a besoin
d’un certain nombre d’informations : l’adresse de l’endroit
de la mémoire-tampon où se trouve le fichier, la position
de la tête de lecture, le mode d’accès au fichier (lecture ou
écriture)
 Ces informations sont rassemblées dans une structure,
dont le type est FILE *. Ce type est défini dans <stdio.h>.
 Un objet de type FILE * est appelé flot de données (stream
en anglais).

22/02/10 Programmer en langage C 222


Définition et propriétés
 Un fichier est une suite de données conservées en permanence sur
un support externe(disquette, disque dur,…). Ces données
regroupent, le plus souvent, plusieurs composantes(champs) d’une
structure.
 En C, les fichiers sont considérés comme une suite d’octets(1
octet=caractère).

Fichiers
 Principe de manipulation d’un fichier:
 Ouverture du fichier
 Lecture, écriture et déplacement dans le fichier
 Fermeture du fichier
 Deux techniques pour manipuler un fichier
 L’accès séquentiel : pour atteindre l’information souhaité, il faut
passer par la première puis la deuxième et ainsi de suite.
 L’accès direct : consiste à se déplacer directement sur l’information
souhaité sans avoir à parcourir celles qui la précédent.

22/02/10 Programmer en langage C 223


Mémoire tampon

 L’accès au fichier se fait par l’intermédiaire d’une


zone mémoire de stockage appelé mémoire
tampon(buffer).

Fichiers
 Le buffer une zone de la mémoire centrale qui
stocke une quantité, assez importante, de données
du fichier.
 Son rôle est d’accélérer les entrées/sorties à un
fichier.

22/02/10 Programmer en langage C 224


Types de Fichiers
 Fichier de texte : est une suite de lignes, chaque ligne
est une suite de caractères terminée par le caractère
spécial ’\n’.
 Fichier binaire : est une suite d’octets pouvant
représenter toutes sortes de données.

Fichiers
 Fichiers standards : se sont des fichiers spéciaux
prédéfinis qui s’ouvrent automatiquement lorsqu’un
programme commence à s’exécuter :
 Stdin (standard input): entrée standard(par défaut, lié au
clavier)
 Stdout (standard output): sortie standard(par défaut, lié à
l’écran)
 Stderr stderr (standard error) : affichage des messages
d’erreur (par défaut, à l’écran).
22/02/10 Programmer en langage C 225
Déclaration d’un fichier
FILE *<pointeurfichier>;
 Le type file est défini dans <stdio.h> en tant que structure. A
l’ouverture d’un fichier, la structure FILE contient un
certain nombre d’informations sur ce fichier telles que :
 Adresse de la mémoire tampon,

Fichiers
 Position actuelle dans le tampon,
 Nombre de caractères déjà écrits dans le tampon,
 Type d’ouverture du fichier,…
 Pour travailler avec un fichier dans un programme, il faut
ranger l’adresse de la structure FILE dans le pointeur de
fichier et tout accès ultérieur au fichier se fait par
l’intermédiaire de ce pointeur.

22/02/10 Programmer en langage C 226


Ouverture de fichiers
 Lorsqu’on désire accéder à un fichier, il est nécessaire
avant tout accès d’ouvrir le fichier à l’aide de la
fonction fopen.
 Cette fonction, de type FILE * ouvre un fichier et lui
associe un flot de données. Sa syntaxe est :

Fichiers
fopen("nom-de-fichier","mode");
 Sémantique des paramètres
Le premier argument de fopen fournit donc le nom du
fichier.
Le second argument, mode, est une chaîne de caractères
qui spécifie le mode d’accès au fichier.

22/02/10 Programmer en langage C 227


Ouverture de fichiers

 Les spécificateurs de mode d’accès diffèrent suivant


le type de fichier considéré.
 On distingue
les fichiers textes, pour lesquels les caractères de

Fichiers
contrôle (retour à la ligne...) seront interprétés en tant
que tels lors de la lecture et de l’écriture ;

22/02/10 Programmer en langage C 228


Ouverture de fichiers

 Les différents modes d’accès sont


 "r" ouverture d’un fichier texte en lecture
 "w" ouverture d’un fichier texte en écriture

Fichiers
 "a" ouverture d’un fichier texte en écriture à la fin
 "r+" ouverture d’un fichier texte en lecture/écriture
 "w+" ouverture d’un fichier texte en lecture/écriture
 "a+" ouverture d’un fichier texte en lecture/écriture à la fin

22/02/10 Programmer en langage C 229


Ouverture de fichiers
 Conditions particulières et cas d’erreur
 Si le mode contient la lettre r, le fichier doit exister, sinon c’est
une erreur(la fonction fopen retourne NULL).
 Si le mode contient la lettre w, le fichier peut ne pas exister.
Dans ce cas, il sera créé, et si le fichier existait déjà, son ancien

Fichiers
contenu est perdu.
 Si le mode contient la lettre a, le fichier peut ne pas exister.
Comme pour le cas précédent, si le fichier n’existe pas, il est
créé ; si le fichier existe déjà, son ancien contenu est conservé.
 Si un fichier est ouvert en mode ”écriture à la fin” toutes les
écritures se font à l’endroit qui est était la fin du fichier lors de
l’exécution de l’ordre d’écriture. Cela signifie que si plusieurs
processus partagent le même FILE*, résultat de l’ouverture
d’un fichier en écriture à la fin, leurs écritures ne s’écraseront
pas mutuellement.

22/02/10 Programmer en langage C 230


Ouverture de fichiers

 Utilisation typique de fopen


#include <stdio.h>
FILE *fp;
…..

Fichiers
if ((fp = fopen("donnees.txt","r")) == NULL)
{
fprintf(stderr,"Impossible d’ouvrir le fichier données en

lecture\n");
exit(1);
}

22/02/10 Programmer en langage C 231


Fermeture de fichiers : la fonction fclose
 La fonction fclose permet de terminer la manipulation d’un
fichier ouvert par la fonction fopen.
 Sa syntaxe est :
fclose(nom_du_fichier)
nom_du_fichier
 où nom_du_fichier est de type FILE* retourné par la

Fichiers
fonction fopen correspondante.
 La fonction fclose retourne
0 si l’opération s’est déroulée normalement et
EOF si il y a eu une erreur.
 Exemple :
FILE *fp;
fp = fopen("donnees.txt","r")
fclose(fp);

22/02/10 Programmer en langage C 232


La fonction d’écriture en fichier: fprintf
 La fonction fprintf, analogue à printf, permet d’écrire des
données dans un flot.
 Sa syntaxe est :
fprintf(nom_du_fichier, "format", expression1, . . . ,
expressionn);

Fichiers
 où nom_du_fichier est le flot retourné par la fonction
fopen.
 Les spécifications de format utilisées pour la fonction
fprintf sont les mêmes que pour printf
 Puisque
printf(...) ⇐⇒ fprintf(stdout,...)
 Expressioni est une expression délivrant une valeur à
écrire.
22/02/10 Programmer en langage C 233
La fonction de saisie en fichier : fscanf
 La fonction fscanf, analogue à scanf, permet de lire des
données dans un fichier.
 Sa syntaxe est semblable à celle de scanf :
fscanf(nom_du_fichier, "format", adresse1, . . . ,
adressen);

Fichiers
 où nom_du_fichier est le flot de données retourné par
fopen.
 Les spécifications de format sont ici les mêmes que celles
de la fonction scanf.
 Adressei : adresse des variables à affecter à partir des
donner.
 Un format et une adresse doivent être fournis pour
chaque variable.
22/02/10 Programmer en langage C 234
Programme: Exemple
#include<stdio.h>
Void main(){
FILE *pf;
int i=100;

Fichiers
char=‘c’;
float t=1.234;
pf=fopen(’’essai.txt’’,w+); /*ouverture et mise à jour*/
fprintf(pf,’’%d %c %f ’’,i,c,t);
fscanf(pf,’’%d %c %f’’,&i,&c,&t);
fprintf(pf,’’%d %c %f,i,c,t);
fclose(pf);
}
22/02/10 Programmer en langage C 235
Lecture et écriture par caractère : fgetc et
fputc
 Similaires aux fonctions getchar et putchar les
fonctions fgetc et fputc permettent respectivement de
lire et d’écrire un caractère dans un fichier.
 La fonction fgetc retourne le caractère lu dans le

Fichiers
fichier et la constante EOF lorsqu’elle détecte la fin du
fichier. Sa syntaxe est :
int fgetc(pf); /*où pf est de type FILE* */
 La fonction fputc écrit un caractère dans le flot de
données . Sa syntaxe est :
fputc(int caractere, FILE *flot)
 Elle retourne l’entier correspondant au caractère lu
(ou la constante EOF en cas d’erreur).

22/02/10 Programmer en langage C 236


Exemple
#include <stdio.h>
#include <stdlib.h>
#define ENTREE "entree.txt"
#define SORTIE "sortie.txt"
Void main() {
FILE *f_in, *f_out;
int c;

Fichiers
// Ouverture du fichier ENTREE en lecture
if ((f_in = fopen(ENTREE,"r")) == NULL)
fprintf(stderr, "\nErreur: Impossible de lire %s\n",ENTREE);
// Ouverture du fichier SORTIE en ecriture
if ((f_out = fopen(SORTIE,"w")) == NULL)
fprintf(stderr, "\nErreur: Impossible d’ecrire dans %s\n",SORTIE);
// Recopie du contenu de ENTREE dans SORTIE
while ((c = fgetc(f_in)) != EOF)
fputc(c, f_out);
// Fermeture des flots de donnees
fclose(f_in);
fclose(f_out);
}

22/02/10 Programmer en langage C 237


Exemples
#include <stdio.h>
void main ()
{
FILE *TheFic;
FILE *TheFic1;
char BigBuf[256];

Fichiers
TheFic = fopen ("esai.txt", "r"); /*doit être créé avant compilation*/
TheFic1 = fopen ("esai1.txt", "w");
if (TheFic == NULL)
printf ("Impossible d ouvrir le fichier \n");
/*char *fgets(char *, int , FILE *) ;*/

while (fgets (BigBuf, sizeof BigBuf, TheFic) != NULL)


/* char *fputs(char *, FILE *) ; */
fputs (BigBuf, TheFic1);
fclose (TheFic);
fclose (TheFic1);
}

22/02/10 Programmer en langage C 238


Positionnement dans un fichier : fseek,
rewind et ftell
 fseek
Les différentes fonctions d’entrées-sorties permettent
d’accéder à un fichier en mode séquentiel : les données
du fichier sont lues ou écrites les unes à la suite des

Fichiers
autres.
Il est également possible d’accéder à un fichier en mode
direct, c’est-à-dire que l’on peut se positionner à
n’importe quel endroit du fichier.
La fonction fseek permet de se positionner à un endroit
précis.

22/02/10 Programmer en langage C 239


Positionnement dans un fichier : fseek,
rewind et ftell
 fseek
 a pour prototype :
int fseek(FILE *pf, long deplacement, int origine);

Fichiers
La variable deplacement détermine la nouvelle position
dans le fichier. Il s’agit d’un déplacement relatif par
rapport à origine, compté en nombre d’octets.
La variable origine peut prendre trois valeurs :
1. SEEK_SET (égale à 0) : début du fichier ;
2. SEEK_CUR (égale à 1) : position courante ;
3. SEEK_END (égale à 2) : fin du fichier.

22/02/10 Programmer en langage C 240


Positionnement dans un fichier : fseek,
rewind et ftell
 rewind
int rewind(FILE *flot);
permet de se positionner au début du fichier. Elle est
équivalente à fseek(flot,0, SEEK_SET) ;

Fichiers
 ftell
long ftell(FILE *flot);
retourne la position courante dans le fichier (en nombre
d’octets depuis l’origine).

22/02/10 Programmer en langage C 241