Non-Lvalue Arrays May Have Subscripts

Bonjour,


Tout d'abord je tiens à m'excuser par avance si la question a déjà été posée. J'ai cherché sur le forum avec quelques mots clés qui me sont passés par la tête mais je n'ai pas trouvé de réponse. Désolé si j'ai mal cherché...

Dans le manuel de gcc 4.3.2, il est fait mention de "non-lvalue arrays". Je ne me suis pas mis au C99, mais il me semble que l'expression ne figure pas dans le standard. En tout cas, dans le K&R2, si j'ai bonne mémoire, il y a une ligne qui dit quelque chose du genre: "Arrays are not lvalues." Donc, je trouve l'expression utilisée dans le manuel de gcc vraiment bizarre...

Ce que je ne saisis pas trop bien non plus, c'est le paragraphe "5.19 Non-Lvalue Arrays May Have Subscripts". Je ne vois pas pourquoi le code présenté - dans le manuel de gcc - n'est pas valide en C89.

Code:

---

1 2 3 4 5 6 7

struct foo {int a[4];}; struct foo f();   bar (int index) { return f().a[index]; }

---

J'ai testé sous Borland 5.5 et ça compile correctement. Je suis conscient que cela ne signifie pas que c'est conforme à la norme, ce pourrait être une extension du compilateur ou bien juste une non conformité à la norme.

Vos explications sont les bienvenues. Merci d'avance,
Stephane

Hello,

je ne comprend pas trop ce que tu veux faire en faisant :

Code:

---

struct foo f();

---

En C il n'y a pas de notion de classe et donc de constructeur comme dans les langages plus haut niveau.

à mon avis ce que tu as voulut ecrire est plutot :

Code:

---

1 2 3 4 5 6 7

struct foo {int a[4];}; struct foo f;   int bar (int index) { return f.a[index]; }

---

De plus tu devrais compiler avec les flags -Wall -Werror aussi car tu n'avais pas de type de retour sur ta fonction, ce qui n'est pas dramatique mais n'est pas tres propre ni tres secure au niveau du type checking.

J'espere avoir bien compris ce que tu voulais faire.

A bientot,

Oniric.

Merci pour tes réponses. Le code est extrait du manuel de gcc. Pour le test que j'ai effectué, voici le code que j'ai utilisé:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <stdio.h>     struct foo {int a[4];};     struct foo f(void) { struct foo st = {8 ,9 ,10 ,11}; return st; }     int bar(int index) { return f().a[index]; }     int main(void) { printf("%d\n", bar(1)); return 0; }

---

Je sais bien qu'il n'y a pas de classe en C, et je ne cherche pas à en émuler. Je veux juste comprendre ce paragraphe du manuel de gcc.

J'ai compris ce dont tu parlais, je ne comprenais pas tout à l'heure.

Je ne peux actuellement pas lire le man de gcc (je suis sous windows deja ... et j'ai un acces limité au net). Mais j'ai compris ce que tu voulais faire et je pense "deviner" pourquoi ce code ne fonctionne pas en C89.

Le probleme se situe surement au niveau du type checking, c'est à dire le moment ou le compilateur verifie les types des variables et leurs compatibilités mutuelles.
En C89 le type checking devait etre moins poussé et lorsque tu fais

Code:

---

return f().a[index];

---

il voudrai que f() soit un type "struct" (à cause de l'operateur '.') hors, c'est une fonction. Il ne va pas chercher à regarder le retour de la fonction, ce que fait surement le C99.
Cette ecriture necessite que le compilateur désucre la ligne en faisant :

Code:

---

1 2 3 4 5 6

int bar(int index) { struct foo tmp = f();   return tmp.a[index]; }

---

Le C89 ne doit pas savoir desucré la ligne du coup il ne peut pas faire le bind entre l'adresse de retour de f() et a[index].

Si tu cherches à comprendre comment fonctionne les compilateurs, je te conseil de regarder ce genre de livre : http://www.cs.princeton.edu/~appel/modern/c/

J'ai bcp appris et compris à l'epoque grace à ca (il y a un moment, donc mes explications ne sont peut etre pas tres clair, ni à prendre pour parole d'evangile ! :P )

nb : sucrage syntaxique : fait de donner au programmeur des possibilités d'écriture plus succinctes ou plus proches d'une notation usuelle.
exemple en C89 : tableau[i] est en faite un sucre syntaxique traduit à la pré compilation par : *(tableau + i)

Citation:

---

Envoyé par oniric

Mais j'ai compris ce que tu voulais faire [...]

---

Juste pour être sûr: je ne veux rien faire du tout, sinon comprendre pourquoi le manuel de gcc cite ce code comme invalide en C89.

Citation:

---

Envoyé par oniric

En C89 le type checking devait etre moins poussé [...]

---

Pourquoi pas, mais cela me semble bizarre.

Citation:

---

Envoyé par oniric

Code:

---

return f().a[index];

---

il voudrai que f() soit un type "struct" (à cause de l'operateur '.') hors, c'est une fonction. Il ne va pas chercher à regarder le retour de la fonction, ce que fait surement le C99.

---

Je ne suis pas sûr que ce soit l'explication car d'après le manuel de gcc, il semble que le problème ne soit pas lié au fait que l'on accède à un membre de la structure mais au fait que l'on indexe ce membre qui est un tableau.

En tout cas, merci pour tes réponses et ton lien vers le livre.

la norme C89 dit:

Citation:

---

3.2.2.1 Lvalues and function designators

An lvalue is an expression (with an object type or an incomplete type other than void) that designates an object.24 When an object is said to have a particular type, the type is specified by the lvalue used to designate the object. A modifiable lvalue is an lvalue that does not have array type, does not have an incomplete type, does not have a const-qualified type, and if it is a structure or union, does not have any member (including, recursively, any member of all contained structures or unions) with a const-qualified type.

Except when it is the operand of the sizeof operator, the unary & operator, the ++ operator, the -- operator, or the left operand of the . operator or an assignment operator, an lvalue that does not have array type is converted to the value stored in the designated object (and is no longer an lvalue). If the lvalue has qualified type, the value has the unqualified version of the type of the lvalue; otherwise the value has the type of the lvalue. If the lvalue has an incomplete type and does not have array type, the behavior is undefined.

Except when it is the operand of the sizeof operator or the unary & operator, or is a character string literal used to initialize an array of character type, or is a wide string literal used to initialize an array with element type compatible with wchar_t, an lvalue that has type ``array of type '' is converted to an expression that has type ``pointer to type '' that points to the initial member of the array object and is not an lvalue.

---

la norme C99 dit:

Code:

---

1 2 3 4 5

5 This second edition cancels and replaces the first edition, ISO/IEC 9899:1990, as amended and corrected by ISO/IEC 9899/COR1:1994, ISO/IEC 9899/AMD1:1995, and ISO/IEC 9899/COR2:1996. Major changes from the previous edition include: ... — conversion of array to pointer not limited to lvalues

---

et

Citation:

---

6.3.2.1 Lvalues, arrays, and function designators
An lvalue is an expression with an object type or an incomplete type other than void;53)
1
if an lvalue does not designate an object when it is evaluated, the behavior is undefined.
When an object is said to have a particular type, the type is specified by the lvalue used to
designate the object. A modifiable lvalue is an lvalue that does not have array type, does
not have an incomplete type, does not have a const-qualified type, and if it is a structure
or union, does not have any member (including, recursively, any member or element of
all contained aggregates or unions) with a const-qualified type.
2 Except when it is the operand of the sizeof operator, the unary & operator, the ++
operator, the -- operator, or the left operand of the . operator or an assignment operator,
an lvalue that does not have array type is converted to the value stored in the designated
object (and is no longer an lvalue). If the lvalue has qualified type, the value has the
unqualified version of the type of the lvalue; otherwise, the value has the type of the
lvalue. If the lvalue has an incomplete type and does not have array type, the behavior is
undefined.
3 Except when it is the operand of the sizeof operator or the unary & operator, or is a
string literal used to initialize an array, an expression that has type ‘‘array of type’’ is
converted to an expression with type ‘‘pointer to type’’ that points to the initial element of
the array object and is not an lvalue. If the array object has register storage class, the
behavior is undefined.

---

étant donné qu'une fonction retourne une rvalue, l'instruction

Code:

---

1 2 3 4 5 6 7

struct foo {int a[4];}; struct foo f();   bar (int index) { return f().a[index]; }

---

est incorrect en C89 mais pas en C99.

Je te remercie pour ta réponse Nicolas. Je viens de lire les 2 extraits de norme plusieurs fois et j'ai encore un peu de mal à bien comprendre, mais quand j'en serai arrivé à ma 20ième relecture, j'espère que ça ira mieux :mrgreen:.

OK, je pense que mon problème de compréhension venait aussi du fait que j'avais mal saisi le concept de lvalue. Je n'ai jamais lu la norme (à part quelques paragraphes ici et là), juste K&R 1 et 2. Dans mon esprit, une lvalue était une expression qui pouvait figurer à la gauche du signe =, et donc je pensais qu'un tableau ne pouvait être une lvalue.

Merci encore pour ces extraits de la norme en tout cas.

Citation:

---

Envoyé par stephl

Ce que je ne saisis pas trop bien non plus, c'est le paragraphe "5.19 Non-Lvalue Arrays May Have Subscripts". Je ne vois pas pourquoi le code présenté - dans le manuel de gcc - n'est pas valide en C89.

Code:

---

1 2 3 4 5 6 7

struct foo {int a[4];}; struct foo f();   bar (int index) { return f().a[index]; }

---

J'ai testé sous Borland 5.5 et ça compile correctement. Je suis conscient que cela ne signifie pas que c'est conforme à la norme, ce pourrait être une extension du compilateur ou bien juste une non conformité à la norme.

---

ceci fonctionne avec MinGW en mode C90 :

Code:

---

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 26 27

#include <stdio.h>   struct foo { int a[4]; };   struct foo f () { struct foo foo = { {10, 11, 12, 13} }; return foo; }   int bar (int index) { int x = f ().a[index]; return x; }   int main (void) { int y = bar (2);   printf ("y = %d\n", y); return 0; }

---

Code:

---

1 2 3 4 5

y = 12   Process returned 0 (0x0) execution time : 0.069 s Press any key to continue.

---

Certes, il y a un warning, mais je ne suis pas certain qu'il soit justifié...

En fait, si. Voir l'explication de Nicolas.

J'avoue que ces subtilités me donnent mal à la tête, surtout que comme toi, j'avais déjà utilisé de genre de codage un peu ... extrême, sous Borland C++, sans warning... (mais je n'étais peut être pas en mode ANSI strict : ligne de commande : -A ).

Citation:

---

Envoyé par Emmanuel Delahaye

[...] Certes, il y a un warning, mais je ne suis pas certain qu'il soit justifié...
En fait, si. Voir l'explication de Nicolas.

---

Oui, le warning apparaît quand on ajoute pedantic.

Citation:

---

Envoyé par Emmanuel Delahaye

J'avoue que ces subtilités me donnent mal à la tête [...]

---

Ah, bon je ne suis pas le seul alors :mrgreen:.

Bizarre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

struct foo { int a[4]; int b; };   struct foo f(void) { struct foo st = {{8 ,9 ,10 ,11},-1}; return st; } int main(void) { // Ce qui m'inquiète est plutôt que ceci soit toléré (même si ça ne fait rien) : f().a[1] = 5;   // Alors que bien sûr, ceci ne l'est pas (ce qui est compréhensible) : invalid lvalue // f().b = 5; return 0; }

---

Remarque :

n1256 :

Citation:

---

6.5.2.1 Array subscripting
...
2 A postfix expression followed by an expression in square brackets [] is a subscripted
designation of an element of an array object. The definition of the subscript operator []
is that E1[E2] is identical to (*((E1)+(E2)))...

---

Si, X[i] est considéré équivalent à *(X+i), on aboutit à :

f().a[1] <-> *(f().a +1)

La première écriture est admise et pas la seconde
Conclusion : un interprétation particulière est faite pour l'opérateur [] si il s'agit d'un tableau qui n'est pas une lvalue !

Citation:

---

Envoyé par diogene

Bizarre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

struct foo { int a[4]; int b; };   struct foo f(void) { struct foo st = {{8 ,9 ,10 ,11},-1}; return st; } int main(void) { // Ce qui m'inquiète est plutôt que ceci soit toléré (même si ça ne fait rien) : f().a[1] = 5;   // Alors que bien sûr, ceci ne l'est pas (ce qui est compréhensible) : invalid lvalue // f().b = 5; return 0; }

---

Remarque :

n1256 :


Si, X[i] est considéré équivalent à *(X+i), on aboutit à :

f().a[1] <-> *(f().a +1)

La première écriture est admise et pas la seconde
Conclusion : un interprétation particulière est faite pour l'opérateur [] si il s'agit d'un tableau qui n'est pas une lvalue !

---

Aucune des 2 n'est permises!

Citation:

---

"main.c", line 15: warning: left operand of "." must be lvalue in this context, program behavior is undefined
"main.c", line 18: warning: left operand of "." must be lvalue in this context, program behavior is undefined

---

Je préfère ça qui est logique. Mais aucun avertissement n'était émis par mingw pour la forme f().a[1] = 5; et une erreur était signalée pour la seconde f().b = 5;

Accessoirement, un warning me semble insuffisant.

Citation:

---

Envoyé par diogene

Je préfère ça qui est logique. Mais aucun avertissement n'était émis par mingw pour la forme f().a[1] = 5; et une erreur était signalée pour la seconde f().b = 5;

---

Le compilateur utilisé est Sun Studio 12.

Citation:

---

Envoyé par diogene

Accessoirement, un warning me semble insuffisant.

---

+1.

Bonjour,

Sur ce type d'exemple je reste assez perplexe. A vrai dire en C la fonction devrait renvoyer un pointeur sur structure, non pas la structure elle-même.

Mais bon, on peut dire autrement.

Citation:

---

Envoyé par dj.motte

Sur ce type d'exemple je reste assez perplexe. A vrai dire en C la fonction devrait renvoyer un pointeur sur structure, non pas la structure elle-même.

---

Je ne comprends pas ce que tu veux dire. Une fonction C est capable de retourner soit une structure complète, soit son adresse.

Bonjour,

Je veux dire par là que j'ai rarement vu du code en C où les fonctions renvoyaient une structure. Si vous avez un exemple dans les fonctions standards du C ? Mais c'est possible, comme il est possible de faire des choses compliquées mais peu avantageuses.

C'est bizarre je voyais plutôt un truc du genre :

void theFonction( Type * theStructure ) ;

appelé par :

Type aStructure ;
theFonction( &aStructure ) ;

Mais bon ce n'est pas le cas.

Les fonctions du C qui gèrent des structures comme la date ou le temps, à ma connaissance ne font pas des retours sur structures.

Citation:

---

Envoyé par dj.motte

Je veux dire par là que j'ai rarement vu du code en C où les fonctions renvoyaient une structure. Si vous avez un exemple dans les fonctions standards du C ?

---

div()
ldiv()

Citation:

---

Mais c'est possible, comme il est possible de faire des choses compliquées mais peu avantageuses.

---

Il ne faut évidemment pas en abuser mais pour des petites structures, c'est acceptable et ça simplifie pas mal le code. Sinon, l'usage courant est

- soit de retourner l'adresse d'une structure allouée dynamiquement,
- soit de passer l'adresse de la structure à la fonction.

Citation:

---

C'est bizarre je voyais plutôt un truc du genre :

void theFonction( Type * theStructure ) ;

appelé par :

Type aStructure ;
theFonction( &aStructure ) ;

---

Tout à fait.

Citation:

---

Les fonctions du C qui gèrent des structures comme la date ou le temps, à ma connaissance ne font pas des retours sur structures.

---

Les fonctions du C traitant du temps sont une calamité...