Discussion :

[ram-0000]

Bonjour,

J'ai un petit problème de compréhension d'un comportement avec le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void ma_fct1(char Param[6])
{
	printf("ma_fct1(), size = %d\n", sizeof(Param));
}
 
void ma_fct2(char * Param)
{
	printf("ma_fct2(), size = %d\n", sizeof(Param));
}
 
void ma_fct3(char Param[8])
{
	printf("ma_fct3(), size = %d\n", sizeof(Param));
}
 
int main(int /*argc*/, char * /*argv*/ [])
{
	char buff[6];
	printf("main(), size = %d\n", sizeof(buff));
	ma_fct1(buff);
	ma_fct2(buff);
	ma_fct3(buff);
 
	return 0;
}

Le résultat généré est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
main(), size = 6
ma_fct1(), size = 4
ma_fct2(), size = 4
ma_fct3(), size = 4

La taille du buffer est correctement calculée par sizeof() dans le main() mais n'est plus le résultat attendu dans les différentes fonctions (ma_fct1, ma_fct2 et ma_fct3). C'est comme ci, malgré la définition de la fonction, le compilateur disait que ce n'est pas un buffer de 6 ou 8 caractères mais un pointeur sur caractères (ce qui est vrai aussi).

D'autant plus que le compilateur ne hurle pas lorsque l'on passe un buffer de 6 à une fonction qui s'attend à recevoir un buffer de 8.

Quelqu'un aura t'il une explication ?

[Obsidian]

La taille du buffer est correctement calculée par sizeof() dans le main() mais n'est plus le résultat attendu dans les différentes fonctions (ma_fct1, ma_fct2 et ma_fct3). C'est comme ci, malgré la définition de la fonction, le compilateur disait que ce n'est pas un buffer de 6 ou 8 caractères mais un pointeur sur caractères (ce qui est vrai aussi).

C'est le cas.

Autant que je sache, le C ne sait pas passer directement les tableaux en tant qu'argument de fonction. Donc, tant que le tableau est directement visible, ça va. Par contre, si tu passes un tableau à une fonction, ce sera obligatoirement à travers un pointeur. Et comme, de fait, ce pointeur existe et est déclaré en mémoire en tant que tel, c'est bien à lui que sizeof va se référer.

La seule astuce que je connaisse pour « tricher » est de déclarer un tableau (de taille fixe) en tant que membre d'une structure. Passer cette structure permet donc de transmettre le contenu du tableau qu'elle contient.

Maintenant, j'ai toujours péché sur les conversions pointeurs↔tableau. Il y a probablement plus érudit que moi pour te répondre…

[orfix]

Tout devient clair à partir du moment où l'on sait que le nom d'un tableau est implicitement converti en pointeur vers son premier élément (sauf devant sizeof et &), autrement dit on aurait pu écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
	ma_fct1(&buff[0]);
	ma_fct2(&buff[0]);
	ma_fct3(&buff[0]);

Vous voyez donc bien qu'écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void ma_fct1(char Param[6])
void ma_fct3(char Param[8])
/* Voir même */
void ma_fct4(char Param[99999])

Ne change absolument rien, le compilateur voit cela toujours comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void ma_fct1(char *Param)
/* Ou */
void ma_fct1(char Param[])

[Melem]

ram-0000 : En effet dans la spécification du type d'un argument d'une fonction, les déclarations char *, char [] et char [N] (N entier quelconque) sont strictement équivalentes, et vallent char *. Il en est ainsi car de toute façon, lorsque tu passes un tableau en argument d'une fonction, le tableau est systématiquement remplacé par l'adresse de son premier élément. D'ailleurs, les seuls cas où une expression de type tableau n'est pas remplacé par l'adresse de son premier élément s'est lorsqu'il est en unique argument de sizeof (sizeof(t)), en unique argument de l'opérateur "adresse de" (&t) ou en unique argument à droite de l'opérateur d'initialisation (const char * = "...").

[diogene]

On peut signaler un cas supplémentaire où le tableau reste un tableau, c'est en tant qu'expression parenthèsée : si t est un tableau, (t) est un tableau. C'est d'ailleurs ce qui t'a permis d'écrire sizeof(t) aussi bien que sizeof t.
Naturellement, il ne s'agit pas ici des délimiteurs ( et ) qui encadrent la liste des arguments d'une fonction.

[D[r]eadLock]

En résumé, voici la regle que j'utilise: n'utiliser [] que:

1. dans les déclarations de variable et le plus souvent sans taille:
   

   • Code :

     Sélectionner tout - Visualiser dans une fenêtre à part

     char foo[] = "....";

   • voire

     Code :

     Sélectionner tout - Visualiser dans une fenêtre à part

      strcut bar array[] =  { ... };

     en utilisant ensuite la macro

     Code :

     Sélectionner tout - Visualiser dans une fenêtre à part

     #define ARRAY_NB_ELEM(a) (sizeof(a)/sizeof(a[0])

     pour avoir le nombre d’éléments
2. dans les déclaration de struct:

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   struct foo { int array[SIZE]; char name[MAX_NAME_SIZE]...};

Et donc jamais dans des paramètres de fonctions, uniquement des pointeurs, et je n'ai jamais eu de soucis

[ram-0000]

Donc si je résume,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void ma_fct1(char Param[6])

est automatiquement transformé en interne par le compilateur en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void ma_fct1(char * Param)

et donc ce type de déclaration ou de définition ne présente d'intérêt que pour le développeur/relecteur. Il indique explicitement ce qu'il s'attend à trouver sachant que le compilateur le traite légèrement différemment.

[souviron34]

je +1 avec D[r]eadLock

[diogene]

Donc si je résume,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void ma_fct1(char Param[6])

est automatiquement transformé en interne par le compilateur en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void ma_fct1(char * Param)

et donc ce type de déclaration ou de définition ne présente d'intérêt que pour le développeur/relecteur. Il indique explicitement ce qu'il s'attend à trouver sachant que le compilateur le traite légèrement différemment.

Oui.
Ceci est traité exactement de la même façon par le compilateur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void ma_fct1(char Param[6])
void ma_fct1(char Param[])
void ma_fct1(char *Param)

et dans les trois cas, Param est du type char*.

Personnellement, je n'aime pas la première forme qui introduit une grandeur (6) qui n'a pas de signification. La troisième forme est la plus conforme au type de Param. Mais, on peut préférer selon le cas une des deux premières formes à la troisième mais alors dans un but purement documentaire.