Leçon 4 : Pointeurs et chiers

Rodrigue DJEUMEN

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 1 / 21

 Sommaire

Sommaire
1 Sommaire
2 Les pointeurs
Variables dynamiques, pointeurs et prise d'adresse
Déclarateur de pointeur et adressage indirect
Opérateurs de pointeurs
Pointeurs et tableaux
Pointeurs et structures
Exercices
3 Les chiers
Dénition
Supports et organisation
Types de supports
Organisation et accès
Opérations sur un chier
Identication du chier
Primitives d'ouverture et de fermeture
Les traitements
Fichier texte
Dénition
Exemple
Fichier binaire
Exercices

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 2 / 21

 Les pointeurs Variables dynamiques, pointeurs et prise d'adresse

Variables dynamiques, pointeurs et adresse

Un objet P de type pointeur sert à désigner des objets : les valeurs q'il prend
sont des références (adresses en mémoire) à ces objets.
Une variable dynamique (ou objet pointé ) est un objet crée pendant
l'exécution d'un programme. Elle a un type et une valeur variable mais n'a
pas de nom.

L'opérateur de prise d'adresse &, est un opérateur unaire qui s'applique à

une identication de variable ; il ne s'applique pas à des constantes.
Exemple :
int x;
int t[N];
/* &x a pour valeur, l'adresse de x
&t[3] a pour valeur l'adresse du 4e élément de t
&t est interdit (t est une constante)
*/
Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 3 / 21
 Les pointeurs Déclarateur de pointeur et adressage indirect

Déclarateur de pointeur et adressage indirect

Comme pour les tableaux, il n'existe pas de type pointeur. Une variable
pointeur est dénie par un déclarateur de pointeur.

Exemple :

int *p; //déclare une variable p qui pointe sur les objets
int *p[N]; //déclare un tableau de N pointeurs;
int (*p)[N]; //déclare un pointeur sur un tableau;
Le pointeur va servir à faire des indirections, et à obtenir des valeurs par

indirection ; considérons :

int x = 4, y = 5;
int *p = &x;
p est le pointeur d'adresse initialisé à l'adresse
de x
∗p est la variable pointée de p , qui correspond à x
*p = y; //affecte à x la valeur y

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 4 / 21

 Les pointeurs Opérateurs de pointeurs

Les opérateurs
Un pointeur qui ne pointe sur rien a pour valeur NULL (constante dénie
dans stdio.h) ;

Les aectations entre les pointeurs ayant des objets pointés de même types
sont possibles.

Les opérations arithmétiques suivantes sont dénies sur les pointeurs :

addition : Correspond à un déplacement dans le type pointé

soustraction d'un entier : -//-
soustraction de deux pointeurs : fournit le nombre d'éléments situés entre deux pointeurs
comparaisons :
void ∗ pu est appelé pointeur universel.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 5 / 21

 Les pointeurs Pointeurs et tableaux

Pointeurs et tableaux

Les déclarations suivantes char t[] et char ∗ p sont équivalentes, en ce

sens que t et p sont des variables de type chaîne.
si t = ”une” et p = ”deux , alors t[1] vaut 0 n0 , ∗t vaut 0 u 0 ; p[2] vaut
0 u 0 tandis que ∗p vaut 0 d 0 .

L'opérateur d'indexation sur les tableaux est une forme particulière

d'indirection pour les pointeurs :
id[expr ] équivaut à ∗(id + (expr ))
Le parcours d'un tableau peut s'écrire :
for(i = 0; i <= N-1; i++)
scanf(%c,*(t+i));

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 6 / 21

 Les pointeurs Pointeurs et structures

Pointeurs et structures
Soit le type date ci-après :
typedef struct{
short j,m;
int a;
} Date;
et la déclaration d'un pointeur sur cette structure :
Date *d;
L'accès à un champ du pointeur d ce fait par :
(*d).j = 2;
(*d).m = 12;
(*d).a = 2015;
On peut également se servir de l'opérateur − > pour simplier l'écriture et
obtenir le même résultat :
d->j = 2;
d->m = 12;
d->a = 2015;
Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 7 / 21
 Les pointeurs Exercices

Exercice 1
Soit le programme suivant :
main() {
int A = 1;
int B = 2;
int C = 3;
int *P1, *P2;
P1=&A;
P2=&C;
*P1=(*P2)++;
P1=P2;
P2=&B;
*P1-=*P2;
++*P2;
*P1*=*P2;
A=++*P2**P1;
P1=&A;
*P2=*P1/=*P2;
return 0;
}

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 8 / 21

 Les pointeurs Exercices

Copiez le tableau suivant et complétez le pour chaque instruction du programme cidessus.

A B C P1 P2
Initialisation 1 2 3 / /
P1=&A 1 2 3 &A /
P2=&C ;
*P1=(*P2)++ ;
P1=P2 ;
P2=&B ;
*P1-=*P2 ;
++*P2 ;
*P1*=*P2 ;
++*P2 ;
*P1*=*P2 ;
A=++*P2**P1 ;
P1=&A ;
*P2=*P1/=*P2 ;

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 9 / 21

 Les pointeurs Exercices

Exercice 2
Soit P un pointeur, qui pointe sur un tableau A :
int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
int *P;
P = A;
Quelles valeurs ou adresses fournissent ces expressions :
1 *P+2

2 *(P+2)

3 &P+1

4 &A[4]-3

5 A+3

6 &A[7]-P

7 P+(*P-10)

8 *(P+*(P+8)-A[7])

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 10 / 21

 Les chiers Dénition

Notion de chier

Un chier est une collection d'informations, structurée en unités

d'accès appelées articles ( ou enregistrements) qui sont tous du même
type, en général composé.
Exemple : Le chier des résultats à un examen comprendra un article
par étudiant, chaque article étant composé de 4 champs :
char nom[40]
char Prenom[40]
char matricule[6]
char DateNaissance[8]
oat note
Un chier est toujours enregistré sur un support externe à la mémoire
centrale et tout programme de traitement échangera des informations
avec le chier article par article.
On distingue deux types de chiers : chiers textes et chiers binaires.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 11 / 21

 Les chiers Supports et organisation

Supports

On distingue deux catégories de supports :

Les supports séquentiels : les informations sont écrites ici les unes à la
suite des autres, et sont telles que l'accès à l'information i nécessite le
passage sur toutes les informations qui précèdent i sur le support. Exemple :
la bande magnétique, le streamer,...

Les supports adressables : ces supports sont structurées en surfaces

d'enregistrement individuellement adressables : les informations qui y sont
enregistrées peuvent être retrouvées directement, grâce à leur adresse, sans
que l'on ait à passer par des enregistrements intermédiaires. Exemple : les
disques( Disque Dur, Disquette, CD-ROM, DVD,...)

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 12 / 21

 Les chiers Supports et organisation

Organisation & accès

Selon les impératifs du traitement, on utilise deux techniques d'accès aux

articles d'un chier :
L'accès séquentiel : on accède au chier dans l'ordre

d'enregistrement des articles.

L'accès sélectif : on accède directement à un article particulier sans

passer par les articles intermédiaires ; cet accès n'est possible qu'avec
les supports adressables.
L'organisation d'un chier, dénit la manière dont les articles du chier
sont disposés sur le support. On distingue trois organisations principales :
Séquentielle qui ne permet que l'accès séquentielle.

Directe conçue pour l'accès sélectif

Séquentielle indexée qui permet l'accès séquentiel et l'accès sélectif.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 13 / 21

 Les chiers Opérations sur un chier

Identication du chier

Un chier F est identié, de manière unique, par un nom externe qui

lui est attaché.
Il peut exister plusieurs programmes de traitement de F et, dans
l'environnement de chacun d'eux, F est décrit avec son nom interne
qui n'a en général, aucun rapport avec le nom externe.
Au moment de traiter un chier, un programme doit s'assurer le
contrôle de ce chier à l'aide d'une primitive d'ouverture de chier. le
rôle d'une telle action est :
d'établir la correspondance entre le nom interne et le nom externe,
d'assurer au programme le contrôle du chier,
d'eectuer le positionnement initial du dispositif de lecture/écriture sur
le support de chier.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 14 / 21

 Les chiers Opérations sur un chier

Ouverture de chier

Si fich est le nom interne du chier, nous noterons fopen(fich, mode)

la primitive qui permet d'ouvrir le chier fich, suivant mode . le
pointeur NULL est retourné si le chier n'est pas trouvé.
Modes
r ouverture en lecture
w ouverture en écriture (si chier existe, le contenu est eacé)
a ouverture en allongement
r+ Ouverture en lecture pour mise à jour
w+ analogue à w, mais permet de lire
a+ ouverture en lecture et en allongement

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 15 / 21

 Les chiers Opérations sur un chier

Fermeture de chier

la primitive fclose(fich) permet de marquer la n de traitement du

chier.
L'exécution de la primitive de fermeture a deux but :
Compléter le chier par une marque de n de chier (notée EOF ), dans
le cas où le traitement était une création de chier.
Signaler l'abandon du chier.

La primitive int feof (FILE ∗ f ) permet de tester si la n de chier est

atteinte.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 16 / 21

 Les chiers Opérations sur un chier

Traitement sur un chier

Il existe trois mode de traitement associé aux chiers :

Traitement en lecture : Ici, le chier est ouvert, et parcouru à la
recherche de l'information voulue. Pendant ce temps, il reste
accessible en lecture à d'autres programmes.
Traitement en écriture : Le chier est ouvert de manière exclusive,
an d'éviter que les données écrites ne soient incohérentes ; et l'ajout
du nouvel élément se fait à la n du chier.
Traitement en lecture/écriture ou mise à jour : le chier est
ouvert de manière exclusive et une recherche est préalablement faite
sur l'article à modier ; une fois les modications faites, l'article est
écrite dans le chier.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 17 / 21

 Les chiers Fichier texte

Fichier textes
Un chier de texte est formé d'éléments bien connus : les caractères.
Les caractères contenus dans un chier de texte sont organisés en
lignes, chacune terminée par une marque de n de ligne. Après la
dernière ligne, le chier se termine par une marque de n de chier.
La déclaration d'un chier texte se fait par l'instruction FILE ∗ fich;
Les primitives de lecture sont :
int fgetc(FILE ∗ fich); pour lire un caractère dans le chier,
int fgets(char ∗ ch, int n, FILE ∗ fich); pour lire n caractères sur fich et
les ranger dans ch.
int fscanf (FILE ∗ fich, char ∗ format, ...); pour lire une donnée formatée
dans le chier.

Les primitives d'écriture sont :

int fputc(char c, FILE ∗ fich); pour écrire le caractère c , dans le chier,
int fputs(char ∗ ch, FILE ∗ fich); pour écrire la chaîne ch sur fich.
int fprintf (FILE ∗ fich, char ∗ format, ...); pour écrire une donnée
formatée dans le chier.
Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 18 / 21
 Les chiers Fichier texte

Exemple

#include<stdio.h>
void main(){
int i ;
double tab[2] ;
FILE *chier ;
chier = fopen(essais.txt,r) ;
if (chier != NULL){
for(i=0 ;i<2 ;i++)
fscanf(chier, %lf\n, tab+i) ;
fclose(chier) ;
}
for(i=0 ;i<2 ;i++)
printf(%lf\n, tab[i]) ;
}

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 19 / 21

 Les chiers Fichier binaire

Fichier binaire

Les types chier binaire sont structurés, le type de leurs éléments peut
être n'importe lequel (sauf un type chier !).
La déclaration d'un chier binaire se fait par l'instruction FILE ∗ fich;
La primitive de lecture est :
int fread(void ∗ destination, int taille, int nombre, FILE ∗ fich); pour lire
un bloc de données en binaire, pus retourner le nombre d'éléments
eectivement lus.

La primitive d'écriture est :

int fwrite(void ∗ source, int taille, int nombre, FILE ∗ fich); pour écrire
un bloc donnée en binaire dans le chier.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 20 / 21

 Les chiers Exercices

Exercices

Dans un établissement, un étudiant est caractérisé par son matricule, ses noms et
prénoms, son âge et sa lière. Un ensemble d'étudiants d'un parcours-type
constitue, une classe d'étudiants ; Cette classe d'étudiants peut être implémentée
par un chier.Il vous est demandé de mettre sur pied un programme permettant
de prendre en charge la gestion de la scolarité.
1 Comment représenter les structures de données Etudiant et une classe
d'étudiant ?
2 Écrire une fonction void lireDonnee(...) permettant de lire les données d'un
étudiant ;
3 Écrire une fonction void creerClasse(...); se servant de la fonction
lireDonnee() pour créer à volonté, une classe d'étudiants ;
4 Écrire une fonction void afficherClasse(...) permettant d'acher la liste des
étudiants ;
5 Écrire une fonction int rechercher (...) permettant de rechercher l'existence
d'un étudiant de matricule mat dans la classe.

Rodrigue DJEUMEN Leçon 4 : Pointeurs et chiers 21 / 21