Next: Qualificatifs de type
Up: Les déclarations
Previous: Définition de types
Sous-sections
La principale utilité des
typedef est, si l'on en fait une utilisation
judicieuse, de faciliter l'écriture des programmes, et d'en augmenter la
lisibilité.
Il est parfois nécessaire de manipuler des variables qui ne peuvent prendre
comme valeurs qu'un sous-ensemble des valeurs d'un type de base.
Supposons que nous voulions manipuler des booléens. Comme le type booléen
n'existe pas dans le langage, il faudra utiliser des
int, en se
restreignant à deux valeurs, par exemple 0 et 1.
Il est alors intéressant de redéfinir à l'aide d'un
typedef,
le type
int.
On écrira par exemple :
#define VRAI 1
#define FAUX 0
typedef int BOOLEAN;
On pourra par la suite déclarer des << booléens >> de la manière suivante :
BOOLEAN b1,b2;
et les utiliser :
b1 = VRAI;
if (b2 == FAUX) ...
mais bien entendu, ce sera à la charge du programmeur d'assurer que les
variables
b1 et
b2 ne prennent comme valeurs que
VRAI ou
FAUX.
Le compilateur ne protestera pas si on écrit :
b1 = 10;
On voit que la lisibilité du programme aura été augmentée, dans la
mesure où le programmeur aura pu expliciter une restriction sémantique
apportée au type
int.
Lorsqu'on donne un nom à un type structure par typedef, l'utilisation est
beaucoup plus aisée.
En effet, si on déclare :
struct personne
{
...
}
les déclarations de variables se feront par :
struct personne p1,p2;
alors que si on déclare :
typedef struct
{
...
} PERSONNE;
les déclarations de variables se feront par :
PERSONNE p1,p2;
on voit que la seconde méthode permet d'éviter d'avoir à répéter
struct.
De la même manière, en ce qui concerne les pointeurs, il est plus difficile
d'écrire et de comprendre :
struct personne
{
...
};
struct personne *p1,*p2; /* p1 et p2 pointeurs vers des struct */
que la version suivante qui donne un nom parlant au type pointeur vers struct :
typedef struct
{
...
} PERSONNE;
typedef PERSONNE *P_PERSONNE; /* P_PERSONNE type pointeur vers struct */
P_PERSONNE p1,p2; /* p1 et p2 pointeurs vers des struct */
Dans le cadre de l'écriture de programme en plusieurs unités de compilation,
il est souvent
utile de définir un type de manière opaque, c'est à dire d'en laisser libre
l'utilisation sans que l'utilisateur n'ait à connaître sa définition.
C'est exactement ce que réalise la bibliothèque standard pour le type
FILE : le programmeur sait que
fopen() rend une valeur de type
FILE
* et que cette valeur doit être passée en paramètre des fonctions
d'entrées-sorties
fprintf(),
fputc(),
fputs() etc.
Il y a beaucoup d'autres exemples de ce type dans la bibliothèque standard.
Next: Qualificatifs de type
Up: Les déclarations
Previous: Définition de types
Bernard Cassagne
1998-12-09
