Exood4 Studio - Video Game Development, Toulouse (France)
Exood4 Studios Exood4 Tutorials

   
L a n g a g e   C

L a   g n r a t i o n   d e   t y p e s






 Les dclarateurs peuvent tre composs pour former des types plus compliqus :

int *tab[10]; /* tableau de 10 pointeurs d'entier */

 Ce type est compos des dclarateurs tableau [] et pointeur *.

 Les dclarateurs de tableaux et de fonctionx sont prioritaires par rapport aux dclarateurs de pointeur, d'o l'utilisation de parenthses :

int *fct(); /* fonction retournant un pointeur d'entier */
int * (fct());   /* idem, fonction retournant un pointeur d'entier */
int (*fct) ();   /* pointeur sur une fonction retournant un entier */


 int *(*x) [10]; signifie que :
*(*x) [i] est de type int (entier)
(*x) [i] est de type int * (pointeur d'entier)
*x est de type int * [10] (tableau de 10 pointeurs d'entier)
x est de type int () [10] (pointeur de tableau de 10 pointeurs d'entier)
 Le type compos obtenu doit tre valide. En particulier :
  • Si le type void est utilis, cela ne doit tre que pour un type void *, une fonction de type void, ou pour la liste de ses paramtres.

  • Les lments d'un tableau ne peuvent pas tre de type fonction : un tableau peut contenir des pointeurs de fonctions mais pas les fonctions elles mmes.

  • Un tableau ne peut pas tre un type de retour d'une fonction : une fonction peut renvoyer un pointeur de tableau ou un pointeur sur le premier lment d'un tableau, mais pas un tableau lui-mme.

  • Une fonction ne peut pas retourner de fonction, mais seulement un pointeur de fonction.
 Exemple de compositions valides :

/* p est un pointeur de fonction, retournant un pointeur d'entier */
int *(*p)();

/* T est un tableau de pointeurs de fonctions retournant un entier */
int (*T[])();

/* T est un tableau de pointeurs de fonctions retournant un pointeur d'entier */
int *(*T[])();

/* F est un pointeur de fonction retournant un entier, ce pointeur est */
/* initialis l'adresse de la fonction f */
int *(*F)() = f;

/* F est une fonction qui retourne un pointeur de pointeur vers un type long */
long **F();

/* F est une fonction retournant un pointeur de tableau d'lments de type short */
short (*F())[];

/* F est une fonction qui retourne un pointeur de fonction qui */
/* retourne un pointeur vers un type double */
double *(*F())();

/* F est une fonction qui retourne un pointeur de tableau de */
/* pointeurs de fonctions renvoyant un pointeur de tableaux d'lments de type char !! */
char (*(*(*F())[])())[];


Typedef


 Les dclarations typedef permettent de nommer des types composs. La syntaxe est la mme que pour dclarer un identificateur, le tout prcd du mot cl typedef. L'identificateur devient alors un nom de type, le type tant celui qui aurait t assign l'identificateur si la dclaration avait t une dclaration normale :

typedef unsigned char Bool; /* Bool est quivalent au type unsigned char */
typedef char String[255];    /* String est le type chane de 255 caractres */
typedef int *Ptr, (Fct)(); /* Ptr est le type pointeur d'entier */
   /* et Fct est le type fonction retournant un entier */
Bool fin, erreur;
Ptr ptr, f(int);
String s, tab[10];
int t = sizeof(String);
Fct fct, *ptrfct;


Les types anonymes


 Il peut parfois tre utile de rfrencer un type sans lui donner de nom. C'est le cas lors de l'criture d'expressions de conversion de type (oprateur de cast), de calcul de taille de type (oprateur sizeof) ou de l'criture de prototypes de fonctions. Un dclarateur de type anonyme est un dclarateur de type standard dans lequel a t supprim l'identificateur :

float * pointeur de rel
char (*)() pointeur d'une fonction retournant un caractre
unsigned *[10] tableau de 10 pointeurs d'entier non sign
int (*(*)())() pointeur d'une fonction retournant un pointeur d'une fonction retournant un entier


Exemple d'utilisation :

double zero (double, double, double (*)(double));

 Cette dclaration pourrait tre le prototype d'une fonction calculant le zro d'une fonction relle quelconque entre deux bornes relles. La fonction zero pourrait tre appele comme ceci :

z = zero (1.57, 4.71, sin);

/* calcule le zro de la fonction sinus dans l'intervalle [1.57;4.71] */


Les conversions explicites


 Un nom de type plac entre parenthses, suivi d'une expression provoque la conversion dans le type indiqu de la valeur de l'expression. Cette construction s'appelle "cast". Le type peut tre anonyme ou tre un nom de typedef. Il ne peut tre ni une instruction, ni un tableau, ni une fonction. Par exemple, si la taille du type short est 16 bits et celle du type long est 32 bits:

char c;
int i;

c = (char) 0xFFFF:
i = (int) 0xFF;
i = (char) 0xFFFF;

 Ces instructions affectent chaque fois la valeur 0xFF. Dans les deux premiers cas, les conversions implicites auraient conduit au mme rsultat. De mme :

 (unsigned long) (unsigned short) 0xFFFFFF vaut 0x0000FFFF.



  Retour en haut de page Page suivante