Discussion :

[souviron34]

Pour en revenir au problème initial :

1) Nous sommes sur le forum C et non C++ .

2)

Le & devant un nom de tableau n'est pas utilisé normalement, cependant ce n'est pas une erreur et &a signifie a si a est un tableau.

• sprintf attend un char *.
• Or le P.O a donné
  

  Code :

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

  1
  2
   
  extern char chaine_debug[70];

  donc chaine_debug est un char *
  
• &chaine_debug est un char **

CQFD..

[Médinoc]

PERDU!

chaine_debug est un tableau de 70 char, implicitement convertible en char*, mais reste un tableau.

Donc, &chaine_debug n'est pas un char**, mais un char (*)[70]

Edit, voir ci-dessous: !! je suis surpris qu'Emmanuel se soit laissé aller à écrire cela...

[Jean-Marc.Bourguet]

• a désigne un tableau de N éléments de type T. Il a pour valeur l'adresse du premier élément du tableau. Il a pour type T*.

Le type de a est T[N]. Meme s'il est converti implicitement dans la plupart des contextes en un T* qui est un pointeur vers le premier element.

• &a est l'adresse du tableau. Il a certes la même valeur que a mais le type est différent : T(*)[N]. (EDIT)

La, nous sommes d'accord.

[Jean-Marc.Bourguet]

PERDU!

chaine_debug est un tableau de 70 char, implicitement convertible en char*, mais reste un tableau.

Donc, &chaine_debug n'est pas un char**, mais un char (*)[70]

Edit, voir ci-dessous: !!

Chouette, il y en a un qui a compris!

La difference entre le tableau implicitement convertible dans quasiment tous les contextes (exception sizeof et &) en un char* et un char* est faible et un char* qui se comporte de maniere bizarre pour sizeof et & est faible tant qu'on ne considere que les variables tableaux unidimentionnels, mais bloque la comprehension quand on fait intervenir les pointeurs et les tableaux multidimentionnels.

je suis surpris qu'Emmanuel se soit laissé aller à écrire cela...

Je ne suis pas etonne. Ca fait combien de fois qu'on a cette discussion et qu'a chaque fois il refait l'erreur?

[souviron34]

j'aimerais bien alors que vous m'expliquiez la différence entre :

Code :

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

1
2
 
char chaine_debug[70] ;

et

Code :

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

1
2
3
4
 
char *chaine_debug = NULL ;
 
chaine_debug = calloc ( 71, 1 );

[stephl]

j'aimerais bien alors que vous m'expliquiez la différence entre :

Code :

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

1
2
 
char chaine_debug[70] ;

et

Code :

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

1
2
3
char *chaine_debug = NULL ;
chaine_debug = calloc ( 70, 1 );

Dans le premier cas, chaine_debug n'est pas une lvalue et sizeof chaine_debug donne 70; dans le second cas, chaine_debug est une lvalue et sizeof chaine_debug donne sizeof (char *).

[Jean-Marc.Bourguet]

j'aimerais bien alors que vous m'expliquiez la différence entre :

Code :

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

1
2
 
char chaine_debug1[70] ;

et

Code :

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

1
2
3
4
 
char *chaine_debug2 = NULL ;
 
chaine_debug2 = calloc ( 71, 1 );

chaine_debug1 est un tableau de 70 caracteres.

chaine_debug2 est un pointeur vers char initialise avec un pointeur vers le premier caractere d'un tableau de 71 caracteres alloue dynamiquement.

Oui, on peut dire que le C cherche a induire de la confusion (avec l'arithmetique sur les pointeurs, avec l'equivalence entre p[x] et *(p+x), avec le fait que p[] declare un pointeur dans les arguments des fonctions, ...)

[Médinoc]

char chaine_debug[70];

• chaine_debug est un tableau de taille statique connue à la compilation (l'appellation "tableau statique" est trompeuse, voir la suite.
• Une variable locale de ce type sera en mémoire automatique (sur la pile)). Une variable globale de ce type sera dans le segment de données.
• sizeof(chaine_debug) retournera 70.
• chaine_debug est de type char[70], implicitement convertible en char* et en char const*
• &chaine_debug est de type char (*)[70]

char *chaine_debug = calloc ( 71, 1 );

• chaine_debug est un pointeur, pointant vers une zone mémoire allouée de 71 octets minimum (en supposant que calloc() n'échoue pas).
• Une variable locale de ce type sera en mémoire automatique, mais les données allouées, elles, (les 71 char) seront sur le tas
• sizeof(chaine_debug) retournera sizeof(char*), soit 4 sur une machine 32 bits.
• chaine_debug est de type char*, implicitement convertible en char const*
• &chaine_debug est de type char **

Edit: Tiens, cette fois c'est moi qui me suis fait doublement griller (et pas qu'un peu)...

[souviron34]

1) bien sûr pour la pile etc..
2) bien sûr pour le sizeof (bien que je ne l'utlise jamais comme ça)
3) cependant, d'après K&R :

The correspondence between indexing and pointer arithmetic is very close. By definition, the value of a variable or expression of type array is the address of element zero of the array. Thus after the assignment
pa =
*
pa and a have identical values. Since the name of an array is a synonym for the location of the initial element, the assignment pa=&a[0] can also be written as
pa = a;

There is one difference between an array name and a pointer that must be kept in mind. A pointer is a variable, so pa=a and pa++ are legal. But an array name is not a variable;

5.3 Pointers and Arrays

are equivalent; we prefer the latter because it says more explicitly that the variable is a pointer.

Donc quand stephl dit :

Le & devant un nom de tableau n'est pas utilisé normalement, cependant ce n'est pas une erreur et &a signifie a si a est un tableau.

ça ne correspond pas à ce que dit K&R ....

D'après la première citation :

pa = a = &a[0]

donc

&a = &(&a[0]) = &pa = char **

[stephl]

Donc quand stephl dit ...
ça ne correspond pas à ce que dit K&R ....

Ce que je veux dire, c'est que si a est un tableau, alors a et &a ont la même valeur. K&R est aussi ma référence, et si j'ai bonne mémoire, ils ne s'amusent pas à coller un & devant un tableau pour savoir quel type est obtenu; ils précisent juste que ce n'est pas une erreur, mais que c'est inutile et illogique.

[Thierry Chappuis]

Toujours K&R2, Annexe A7.1 du manuel de référence:

Si une expression ou une sous-expression est de type "tableau de T", où T est un type donné, alors la valeur de cette expression est un pointeur sur le premier élément du tableau, et le type de l'expression se transforme en "pointeur sur T". Cette convertion n'a pas lieu si l'expression est l'opérande d'un des opérateurs unaires &, ++, --, ou sizeof, ou l'opérande de gauche d'un opérateur d'affectation ou de l'opérateur ".".

K&R2 est aussi aussi ma référence. Soit donc

Code :

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

T tableau[70];

L'idée de convertion implicite d'une expression de type tableau-sur-T y appraît de manière explicite, de même que la différence entre tableau et &tableau.

EDIT: Voir également §6.3.2.1 de la norme du langage qui donne les mêmes informations.

Thierry

[Jean-Marc.Bourguet]

1) bien sûr pour la pile etc..
2) bien sûr pour le sizeof (bien que je ne l'utlise jamais comme ça)
3) cependant, d'après K&R :

J'ai pas le temps de repondre en detail pour le moment. Je te suggere en attendant la lecture de A.7.1 en tenant compte de l'errata: http://www.cs.bell-labs.com/cm/cs/cbook/2ediffs.html. Tres rapidement il faut faire la difference entre le tableau a et le resultat de l'evaluation de l'expression a et tenir compte du fait qu'il s'agit d'une explication informelle. (EDIT: Thierry cite A.7.1 mais ne tient pas compte de l'errata).

Donc quand stephl dit :

Le & devant un nom de tableau n'est pas utilisé normalement, cependant ce n'est pas une erreur et &a signifie a si a est un tableau.

Je ne suis pas d'accord avec stephl ici. Les expressions a et &a n'ont pas le meme type meme si elles designent la meme adresse.

pa = a = &a[0]

donc

&a = &(&a[0]) = &pa = char **

Le type de &a est char (*)[N]. Essaie

Code :

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

1
2
3
4
5
void f() {
   char a[10];
   char** p1 = &a;
   char (*p2)[10] = &a;
}

dans un compilateur. Moi j'ai

"ComeauTest.c", line 3: error: a value of type "char (*)[10]" cannot be used to
initialize an entity of type "char **"
char **p1 = &a;

[Thierry Chappuis]

&a = &(&a[0]) = &pa = char **

La 1ère égalité ne joue pas, car, selon la citation de K&R2 que j'ai donné plus haut, l'expression a n'est pas convertie en (char *) lorsqu'elle est précédée de l'opérateur unaire &. Ainsi, l'expression &(&a[0]) est effectivement de type char**, mais l'expression &a est de type char (*)[].

Thierry

[stephl]

Merci pour ces précisions. Je ne voulais pas parler de l'annexe A qui est très claire et précise, mais des autres chapitres du livre, et notamment celui sur les pointeurs et tableaux (chapitre 5 de mémoire).
Cependant, à la lumière de votre citation de l'annexe A, il apparaît donc que si "a" est un tableau, alors "&a" est (comme vous l'avez spécifié précédemment) du type pointeur sur tableau puisque la conversion en char * n'a pas lieu.
Bref, mon but n'était pas de déclencher une polémique. Je ne m'étais jamais vraiment préoccupé de savoir quel était le type de "&a", comprenant que cette expression était assez illogique et que "a" était l'information voulue. L'objectif de mon tout premier post était simplement de préciser que l'erreur ne venait pas du fait qu'il y ait un '&' devant un nom de tableau.
En tout cas, merci d'avoir comblé mes lacunes sur le type de "&a" .

[stephl]

Je ne suis pas d'accord avec stephl ici. Les expressions a et &a n'ont pas le meme type meme si elles designent la meme adresse.

Encore une fois, je voulais juste dire que a et &a ont la même valeur. Pardon si je me suis mal exprimé.
Quoi qu'il en soit, je préfère me dire qu'un tableau n'est pas une variable à part entière (en effet, ce n'est pas une lvalue) et donc que je n'ai pas à chercher à avoir son adresse. Pour moi, "&a" a la même valeur que "a" mais est illogique. De même, je n'apprécie guère les expressions du genre &(&a[0]). &a[0] est pour moi une valeur et une valeur n'a pas d'adresse.

[Médinoc]

Mais il me semble que a et &a[0] ne sont pas réellement équivalents: &a[0] doit être de type T*, contrairement à a qui est de type T[N] implicitement convertible en T*

Ce qui explique que a est un tableau et possède une adresse, alors que &a[0] n'est pas une lvalue...

[Jean-Marc.Bourguet]

Encore une fois, je voulais juste dire que a et &a ont la même valeur.

Je n'en suis pas sur. On risque d'entrer dans un debat tres technique sur la notion de valeur dans la norme. Si j'ai bonne memoire

Code :

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

assert((void*)a == (void*)&a);

peut echouer.

Pardon si je me suis mal exprimé.
Quoi qu'il en soit, je préfère me dire qu'un tableau n'est pas une variable à part entière (en effet, ce n'est pas une lvalue) et donc que je n'ai pas à chercher à avoir son adresse. Pour moi, "&a" a la même valeur que "a" mais est illogique.

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
void f(char (*ptr)[10], int cnt) {
   int i;
   for (i = 0; i < cnt; ++i) {
      int j;
      for (j = 0; j < 10; ++j) {
         (*ptr)[j] = 0;
      }
      ++ptr;
   }
}
 
void g() {
   char a[10];
   char b[5][10];
   f(&a, 1);
   f(b, sizeof b/sizeof *b);
}

De même, je n'apprécie guère les expressions du genre &(&a[1]). &a[1] est pour moi une valeur et une valeur n'a pas d'adresse.

Ca, ca ne devrait pas passer a la compilation.

[stephl]

Ce qui explique que a est un tableau et possède une adresse...

Si vous voulez, c'est sûrement dans la norme. Je préfère me dire que la valeur de "a" est l'adresse du premier élément (&a[0]) et ne jamais utiliser "&a".

[stephl]

Ca, ca ne devrait pas passer a la compilation.

Je sais; c'est pourtant ce qui a été écrit dans certains messages précédents.

[Jean-Marc.Bourguet]

Si vous voulez, c'est sûrement dans la norme. Je préfère me dire que la valeur de "a" est l'adresse du premier élément (&a[0]) et ne jamais utiliser "&a".

La valeur de la variable a est le tableau complet; seulement les tableaux ne sont pas des types bien traite en C ce qui fait que la valeur de l'expression a est bien la meme que celle que de l'expression &a[0] sauf si a est un argument de & ou de sizeof (comme le a de l'expression &a[0]).