Le nom du tableau est dans ce cas une constante pointeur sur un tableau:

int (*P)[8]; P = T; *P est un pointeur et pointe sur le sous-tableau T[0][]. **P est un entier, le premier élément T[0][0].

Remarque:

La définition "int **P" serait incorrecte. Elle signifierait pointeur sur un pointeur d’entier et serait donc équivalente à la déclaration "int *P[S]". I1 faut donc définir un pointeur sur un élément du type "T[i]". Cet élément est un tableau de 8 entiers. Les parenthèses de la définition sont donc obligatoires car les crochets sont prioritaires par rapport à l’étoile.

Les variations de l’indice dans l’ordre de rangement des éléments du tableau s’effectuent toujours de droite à gauche.

Un tableau peut étre initialisé. On définit l’ensemble des valeurs entre deux accolades:

int T[10] = { 0,1,2,3,4,5,6,7,8,9 };

int S[5][2] = { 0,1 , 2,3 , 4,5 , 6,7 , 8,9 }; variation des indices de droite à gauche.

ou

int S[5][2] = { {0,1},{2,3},{4,5},{6,7},{8,9}};

exemple:

\verbatiminputtesttab.c

Un cas particulier de tableau est celui des chaînes de caractères. Une chaine de caractéres est un tableau de caractères à une dimension. I1 existe une forme abrégée pour définir les éléments du tableau d’une chaine de caractères: on place la chaîne entre deux guillemets. Le compilateur construit alors un tableau de caractpres contenant les caractères de la chaine et ajoute le caractère ’\0" en fin de tableau. Les deux déclarations suivantes ont le même effet:

char CH[3] = { ’u’,’n’,’\0’ };

char CH[3) = "un";

Remarque: Le termanateur de chaîne (’\0’) est utilisé pour reconnaître la fin d’une chaîne, son absence est grâve des fonctions tel que printf ne saurait plus fonctionner.

Bien sûr un tableau est une constante pointeur. On pourra définir plus simplement la chaine comme:

char *CH=”un”;

ou

char CH[] = "un";

La définition d’une table de messages pourra prendre la forme d’une table de pointeurs sur des chaines de caractpres :

char *MES[3] = { "messagel","message2","message3" };

cette définition correspond 8 la définition:

char MES1[]="message1"; //premier tableau contenant "messagel" char MES2[] = "message2"; char MES3[] = "message3"; char *MES[3] = { MESl, MES2, MES3 }; /** Les éléments de ce tableau sont des * pointeurs sur des caractères. Ils * peuvent étre initialisés avec les * constantes pointeurs MESl, MES2 et * MES3. */

Les structures

La structure est un ensemble hétérogène d’éléments regroupés pour des raisons fonctionnelles. Une structure porte un nom qui identifie sa nature. Ce nom pourra servir à la définition de plusieurs variables de ce type. Une structure est introduite par le mot clé "struct" suivi du nom d’identification et enfin, entre accolades, de la description des éléments composant cette structure:

struct exp { int I; int *P; int TAB[10]; }; La structure "exp" est composée d’un entier, d’un pointeur sur un entier et d’un tableau de dix entiers.

La déclaration d’une structure ne définit aucune variable. Elle définit seulement la forme d’une structure et identifie cette forme par un nom. Dans l’exemple précédent la forme de cette structure porte le nom "exp". On peut alors définir des variables ayant cette forme:

struct exp A, *B, C[10]; A est une structure de type "exp". B est un pointeur sur une structure de type "exp". C est un tableau de dix structures de type "exp".

L’initialisation d’une structure est similaire à l’initialisation d’un tableau. Les éléments sont rangés de gauche à droite ou de haut en bas:

struct dex { int I; char A; short C[4]; }; struct dex E = { 2,’a’,3,4,5,6 };

La déclaration d’une variable structure peut suivre directement la définition de type:

struct trx { int T[10]; char L[S]; } F; /* définit une structure F de type trx. */

Les structures peuvent étre imbriquées.

On réfère à un élément d’une structure par le nom pointé:

E.I représente l’élément I de la structure E de type dex. F.L[0] ou F.(L[0]) représente le premier élément du tableau L de la structure F de type trx.

Dans le cas ou il s’agit d’un pointeur sur une structure il faut utiliser le nom fléché "->" ( symbole "-" suivi du symbole ">" ):

B->I représente l’élément I de la structure pointée par B.

Ces expressions peuvent étre d’une complexité quelconque ( limites imposées par le compilateur ).

struct cexp { struct exp K[10]; int A; struct exp *V; }; struct cexp L,*R;

On peut alors avoir par exemple les constructions suivantes:

L.K[0].TAB[1] deuxième élément du tableau "TAB" de la structure premier élément du tableau K de la structure L. R->K[1].I variable I de la structure deuxième élément du tableau K dans la structure pointée par R. *(L.V->P) valeur de la variable pointée par le pointeur P de la structure pointé par la variable V de la structure L R->V->P variable P de la structure pointée par la variable V de la structure pointée par la variable R.

Un cas particulier concerne les structures se référant à elles-mémes (type récursif):

struct cel { int R; struct cel *Suivant; };

Ce type de structure permet de définir des listes de façon simple. Une cellule d’une liste du type précédent est constituée d’un entier et d’un pointeur sur la cellule suivante.

La structure suivante permet la définition d’un arbre binaire:

struct bin { int val; struct bin *gauche; struct bin *droite; };

La construction de type structure sert également à définir des champs. Un champ est une suite continue de bits. Les champs doivent tous être définis à l’intérieur d’une variable élémentaire. Les bits de cette variable sont pris dans le même ordre mais le langage ne précise pas cet ordre (gauche-droite ou droite-gauche). Nous supposerons pour les exemples que l’on utilise l’ordre gauche-droite. Un champ est défini en précisant le nombre de bits qu’il contieni:

struct champ { unsigned prem : 4; /* les quatre premiers bits. */ unsigned deux : 2; /* les deux bits suivants. */ unsigned fin : 16; /* et les 16 derniers */ };

Une structure de ce type fait référence à 32 bits (regroupement minimum existant pour contenir les trois champs ). Cette structure sera donc rangée dans un mot de 32 bits sur une machine classique. Dans le cas ou un int sur cette machine occupe 32 bits la structure sera rangée dans un "int". Dans le cas ou les "int" de cette machine serait aeulement de 16 bits cette structure serait rangée dans un tableau de deus "int": Le premier mot contiendrait les deux premiers champs et le deuxième mot le champ suivant. I1 ne doit pas y avoir de chevauchement entre les données élémentaires pour les champs ). Un champ peut ne pas Atre nommé; dans ce cas on utilise les deux poinis suivis de la largeur du champ anonyme. Ils sont utilisés pour le remplissage. Ainsi dans le cas précédent et en supposant qu’un int occupe 16 bits la structure champ est équivalente H la structure:

struct champ { unsigned prem: 4; unsigned deux: 2; : 10; unsigned fin: 16; };

Les champs sont des entiers. I1s peuvent étre utilisés comme tel.

L’Union

La mémoire est une suite de bits avec certains regroupements. Les regroupements peuvent étre interprétés de différentes façons. Ainsi un octet peut étre interprété comme un entier ou comme un caractère. Seul l’utilisation du regroupement détermine l’interprétation machine de ce regroupement. Les langages de programmations associent des noms à ces regroupements et définissent une interprétation par 1e type. Cette interprétation fixe associée à un regroupement peut étre quelquefois source de difficultés inexistantes dans la programmation assembleur. La définition d’union permet de définir une vision différente du méme espace mémoire. Les contraintes dues aux types sont donc ainsi levées. La définition d’une union suit le méme principe que celui d’une siructure mais chaque membre définit une interprétation du méme espace mémoire:

union exp { int I; char T[2]; }

Si un entier est sur 16 bits et un caractère sur 8 bits 1a définition précédente donnera deux interprétations de 16 bits mémoire: soit une suite de deux caractères, soit un entier signé. Les règles de traitement de l’union sont les mémes que celle de la structure. La zone mémoire occupée par une union est toujours la zone maximum correspondant à l’un de ces membres.

Exemple: Un registre sur le micoprocesseur 68000 possède 32 bits. I1 peut étre utilisé sur 16 bits et sur 8 bits. On peut définir toutes les interprétations d’un registre:

traitement des bits: struct bitrg { unsigned bit3l:l; unsigned bit30:1; unsigned bit29:1; unsigned bit28:1; unsigned bit27:1; unsigned bit26:1; unsigned bit25:1; unsigned bit24:1; unsigned bit23:1; unsigned bit22:1; unsigned bit2l:l; unsigned bit20:1; unsigned bitl9:l; unsigned bitl8:l; unsigned bitl7:l; unsigned bitl6:l; unsigned bitl5:l; unsigned bitl4:l; unsigned bitl3:l; unsigned bitl2:l; unsigned bitll:l; unsigned bitl0:l; unsigned bit09:1; unsigned bit08:1; unsigned bit07:1; unsigned bit06:1; unsigned bit05:1; unsigned bit04:1; unsigned bit03:1; unsigned bit02:1; unsigned bit0l:l; unsigned bit 00:1 }; Définition du registre: union reg { struct bitrg H; char CR[4]; short SR[2]; long LR; }; ainsi avec la déclaration "struct reg R"; R.B.bit31 représentera le bit de poids fort. R.CR[3] le caractère manipulé dans les instructions machines. R.SR[2] le mot traité par les instructions machines. R.LR le mot long ou le registre en entier.

La déclaration des fonctions

I1 ne faut pas confondre la définition d’une fonction et sa déclaration. La déclaration indique le nom de cette fonction et précise la nature du résultat de cette fonction.

Dans le langage C toutes les fonctions produisent un résultat. L’utilisation d’un résultat n’est pas obligatoire et une procédure peut étre vue comme une fonction dont on utilise pas le résultat. Dans le langage C la déclaration des fonctions ne donne aucune indication sur les paramètres ( nombre et nature ) qui doivent être passés à cette fonction. Les paramètres seront définis seulement au moment de la définition de la fonction. La cohérence entre la nature des paramètres à l’appel d’une fonction et celle attendue par la fonction est de la responsabilité du programmeur. I1 existe des programmes ( lint ) qui permettent de vérifier cette cohérence.

de même le compilateur gcc de GNU augmente C de la possibilité de signer les fonctions, il permet de préciser les paramètre et leurs type au moment de la déclaration. La norme initiale du langage C imposait qu’un paramètre soit de nature simple ( contenu dans un mot mémoire ). Les versions actuelles acceptent des extensions et permettent de passer une structure comme paramètre ( dans la norme initiale il était seulement possible de passer un pointeur sur une structure, ce qui reste meilleur car consomme mois de place dans la pile). La même contrainte existe sur la nature de l’objet retourné par une fonction. Ces restrictions initiales ne sont pas des limitations car comme il est possible de transmettre dans les deux sens des pointeurs sur des objets des objets ( le programme appelant ou appelé doit simplement comporter une recopie de l’objet pointé ). Ce paragraphe ne traite que de la déclaration des fonctions. Une fonction définit une valeur d’un objet quelconque. On définit une fonction en plaçant deux parenthèses derrière son nom. La fonction doit étre précédée du type d’objet qu’elle produit:

un exemple:

int f(); /* signature d'une fonction renvoyant un entier */ int *g(); /* signature d'une fonction renvoyant un pointeur sur entier */ int w(); int (*k)(); /* pointeur sue une fonction renvoyant un entier */ /** * definition de la fonction f */ int f(int x, int y) { return (x+y); } int w(int (*s)(), int x, int y) { return ((*s)(x,y)); /* dans gnu gcc on peur ecrite s(x,y) au lieu (*s)(x+y) * c'est peut-être plus clair! */ } main () { k=f; /* on dit que k pointe sur la fonction f */ printf("%d+%d=%d\n",3,5,k(3,5)); /* l'utilisation de k est alors equivalente à f*/ printf("%d+%d=%d\n",3,5,w(f,3,5)); } /** resultat de l'execution (test) compilation: [pfares@pportable MPS]$ gcc testdecfonc.c execution: [pfares@pportable MPS]$ ./a.out 3+5=8 3+5=8 */

int f(); //fonction renvoyant un entier. int *f(); //fonction renvoyant un pointeur sur un entier. int (*f)(); pointeur sur une fonction renvoyant un entier. La parenthèse est ici nécessaire. Elle précise que l’étoile se rapporte à "f" et non à "int". Donc au lieu d’avoir un pointeur sur "int" on a un pointeur sur "f". int *(*f)(); pointeur sur une fonction renvoyant un pointeur sur un entier. struct exp *f(); fonction renvoyant un pointeur sur une structure de type "exp".

Avec une fonction il est possible soit de l’appeler, soit de caluler son adresse.

Lorsqu’une fonction n’est pas déclarée elle retourne implicitement un entier. Lorsque l’on veut définir une procédure on définit une fonction et on n’utilise pas sa valeur. Certains compilateurs utilisent le type "void" pour indiquer que la valeur de la fonction ne doit pas étre utilisée.

Exemple de définition de fonctions:

Soit une fonction "somme" qui retourne la somme de deux éléments. Les écritures suivantes ont le méme effet:

x + y; évaluation de la somme somme(x,y); sans utilisation du résultat. z = x + y; évaluation de la somme z = somme(x,y); avec utilisation du résultat.

Lorsque l’on fait référence à une fonction comme paramètre d’une autre fonction on utilise implicitement son adresse:

int f(); g(f);

Dans g() on définit le paramètre comme un pointeur sur une fonction:

g(P) int (*p)(); { .... (*p)(); appel de la fonction paramètre. .... }

Bien sûr les pointeurs sur des fonctions peuvent apparaitre n’importe où comme membre d’une structure ou élément de tableau.

Exemple:

Sur le microprocesseur 68000 il existe un tableau de vecteurs d’interruptions. Ce tableau définit pour chaque entrée une procédure d’exception. Nous pouvons le déclarer de la façon suivante:

int (*exp)()[256]; ou void (*exp)()[256];

La déclaration de type : typedef

La pseudo-fonction "typedef" permet la définition de nouveau type. Elle est très utile pour les programmes importants. Cette fonction ne définit qu’une abzéviation et n’est pas associée à la définition du traitement du type cozrespondant comme dans le langage ADA ou C++ par exemple. Néanmoins elle est très employée dans les programmes volumineux et permet de classifier les différents objets utilisés ( un nom par type d’objet ). Le mot clé "typedef" précède la déclaration:

typedef int Now; Le mot "Now" devient un type nouveau synonyme de "int".

On pourra alors écrire:

Now x,y; x et y sont deux entiers.

Bien sûr cette pseudo-fonction est valable quelle que soit la déclaration:

typedef struct { char NOM[8]; int IX; } TAB;

Le mot "TAB" définit un type d’élément qui peut étre utilisé pour former de nouveaux objets:

TAB T[100],*P: tableau de structure et pointeur sur une structure. T[4].IX détinit l’entier IX de 1a structure en cinquième position dans le tableau T.

1.1 Les expressions

Une expression définit une valeur. La valeur d’une expression esi très souvent une valeur élémentaire ( dans la norme initiale une expression définit toujours une valeur élémentaire ). Pour définir une expression on utilise des variables, des constantes et des opérateurs. Une fonction est bien sdr considérée comme un opérateur. Ces opérateurs permettent de calculer une nouvelle valeur à partir d’un ensemble d’éléments.

Exemple: L’opérateur "&" détermine l’adresse de quelque chose. "&I" sera donc l’adresse de la variable I.

L’accès à une valeur élémentaire détermine une expression primaire. Une expression primaire utilise des opérateurs d’accés et est définie par:

• • une constante.

  • un identificateur.

  • une chaine.

  • une expression entre parenthèses.

  • une expression primaire suivie d’une expression enire crochets.

  • une expression primaire suivie d’une suite d’expressions entre parenthpses.

  • une valeur primaire suivie d’un identificateur précédé d’un point.

  • une expression primaire suivie d’un identificateur précédé d’une flèche.

Dans chaque cas la signification est différente. Elle correspond l’interprétation suivante:

• • [≜] constante : constante.

  • [≜] identificateur : valeur de la variable définie par cet identificateur.

  • [≜]chaine : une chaine est un tableau de caractères. La valeur associée à une chaine est donc un pointeur sur le premier caractère de la chaine.

  • [≜]( expression ) : valeur de l’expression.

  • [≜]expression_primaire [ expression ] : accès à un tableau. l’expression E1[E2] à la méme signification que *((E1) + (E2))

  • [≜]expression_primaire(liste d’expression) : appel de fonction.

  • [≜] valeur_primaire.identificateur : accès à un élément de structure.

  • [≜] expression_primaire->identificateur : accès à un élément d’une structure pointée.

L’évaluation d’une expression utilise toujours les mémes formes de données. I1 y a une conversion préalable (casting) avant toute évaluation. Cette conversion suit des règles simples:

• • [✓]Les opérandes de type caractère et entier court sont converties en entiers.

  • [✓] Les opérandes de type flottant sont converties en double.

  • [✓] Si une opérande est de type double, les autres opérandes du mème opérateur sont converties en double.

  • [✓] Sinon si une opérande est de type long, les sutres opérandes sont converties en long.

  • [✓] Sinon si une opérande est de type unsigned, les autres opérandes sont converties en unsigned.

  • [✓] Sinon les opérandes sont de type int.

Le résultat de l’expression est du type ainsi déterminé et peut étre converti pour une affectation par exemple. Les différents opérateurs accessibles dans le langage C sont les suivants: