Logo GNT
Actualités Tests & Guides Bons Plans
Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11
Entraide Développement Développement Langage C De la pertinence d'une phrase

De la pertinence d'une phrase

67 réponses
Avatar
Yoxoman
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)

On entend souvent des formulations plus ou moins diverses et compliquées
sur cette conversion tableau-pointeur, ce qui fait qu'on a du mal à s'y
retrouver.
On parle par exemple du nom du tableau (alors que si p pointe vers un
tableau, il me semble que *p est également concerné par cette
conversion), ou d'exception sur certains opérateur (& et sizeof, ce qui
n'est pas faux, mais dont la cause semble être le fait que derrière ces
opérateurs, une lvalue n'est pas convertie en rvalue).

Ma question est simple : cette phrase est-elle vraie ?

--
"Yo!"
Martin Heidegger (trad. Terrence Malick)
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2 3 4 5
Avatar
bruno at modulix
Yoxoman wrote:
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)

On entend souvent des formulations plus ou moins diverses et compliquées
sur cette conversion tableau-pointeur, ce qui fait qu'on a du mal à s'y
retrouver.


<disclaimer val="pas fait de C depuis lulure, corriger si besoin" />

Bon, reprenons...

Un tableau V de N éléments de type T est, techniquement, un block de
mémoire contigu d'une taille suffisante pour stocker N élément de type T
(problèmes d'alignement etc compris...). Le fait de connaitre T permet
de connaitre la taille de T, donc de pouvoir, à partir de l'adresse de
V[0], calculer l'adresse de V[x].

Accessoirement, l'adresse de V[0] étant celle du premier élément du
tableau, elle est aussi celle du block mémoire lui-même puisque c'est à
cette adresse qu'il commence (M. de la Palisse vous salue bien). Et la
*valeur* de V (pas son *adresse*) est bien *l'adresse* de V[0] - sans
quoi on ne pourrrait pas accéder à ce block mémoire.

On est en fait dans la même situation qu'avec un pointeur sur block de
mémoire de taille T*N dynamiquement alloué - à un détail près: le type
tableau connait sa 'taille' (ie le nombre d'éléments) alors que le type
pointeur ne connait pas la taille du bloc mémoire sur lequel il pointe.

Et on peut effectivement, *dans les deux cas*, utiliser de façon
interchangeable la syntaxe tableau et la syntaxe pointeur - puisqu'en
fait la syntaxe tableau n'est guère plus que du sucre syntaxique.

On parle par exemple du nom du tableau


Qui n'est rien d'autre qu'un symbole...

(alors que si p pointe vers un
tableau,


définition de p ???

il me semble que *p est également concerné par cette
conversion),


Quelle conversion ?-)

La seule conversion (implicite, j'entend) est celle qui a lieu quand tu
passe un tableau en paramètre à une fonction. Ce que la fonction reçoit
effectivement est un pointeur, et non le tableau lui-même - d'où le fait
que sizeof retourne la taille du pointeur et non le nombre d'éléments du
tableau.

ou d'exception sur certains opérateur (& et sizeof, ce qui
n'est pas faux, mais dont la cause semble être le fait que derrière ces
opérateurs, une lvalue n'est pas convertie en rvalue).

Ma question est simple : cette phrase est-elle vraie ?



Laquelle ?-)


--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in ''.split('@')])"

Avatar
Marc Boyer
Le 29-03-2006, Yoxoman a écrit :
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)

On entend souvent des formulations plus ou moins diverses et compliquées
sur cette conversion tableau-pointeur, ce qui fait qu'on a du mal à s'y
retrouver.


C'est que les formulation justes sont souvent compliquées, et
les simples sont pas complètement justes.
Bon, il existe aussi des compliquées fausses....

On parle par exemple du nom du tableau (alors que si p pointe vers un
tableau, il me semble que *p est également concerné par cette
conversion),


Quelle conversion ? Et quel type de p ?
int tab[64];
int* p= tab;
ou bien
typedef int Tab64[64];
Tab64 tab;
Tab64 *p= &tab;


ou d'exception sur certains opérateur (& et sizeof,


et +, []...

ce qui
n'est pas faux, mais dont la cause semble être le fait que derrière ces
opérateurs, une lvalue n'est pas convertie en rvalue).


Là, je suis perdu.

Ma question est simple : cette phrase est-elle vraie ?


Pas dans un contexte de logique booléenne. Après,
si on acepte d'avoir une valeur de véracité continue
entre 0 et 1, je lui mets environ 0,8...

Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. Paul Éluard)

Avatar
Yoxoman

Yoxoman wrote:
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)


Bon, reprenons...

Un tableau V de N éléments de type T est, techniquement, un block de
mémoire contigu d'une taille suffisante pour stocker N élément de type T
(problèmes d'alignement etc compris...). Le fait de connaitre T permet
de connaitre la taille de T, donc de pouvoir, à partir de l'adresse de
V[0], calculer l'adresse de V[x].


Oui.

Accessoirement, l'adresse de V[0] étant celle du premier élément du
tableau, elle est aussi celle du block mémoire lui-même puisque c'est à
cette adresse qu'il commence (M. de la Palisse vous salue bien). Et la
*valeur* de V (pas son *adresse*) est bien *l'adresse* de V[0] - sans
quoi on ne pourrrait pas accéder à ce block mémoire.


Oui.

On est en fait dans la même situation qu'avec un pointeur sur block de
mémoire de taille T*N dynamiquement alloué - à un détail près: le type
tableau connait sa 'taille' (ie le nombre d'éléments) alors que le type
pointeur ne connait pas la taille du bloc mémoire sur lequel il pointe.


Oui.

Et on peut effectivement, *dans les deux cas*, utiliser de façon
interchangeable la syntaxe tableau et la syntaxe pointeur - puisqu'en
fait la syntaxe tableau n'est guère plus que du sucre syntaxique.


Je pense aussi. Mais il me semble que c'est en contradiction avec la fin
de

http://www.eskimo.com/~scs/c-faq.com/aryptr/aryptr2.html

On parle par exemple du nom du tableau


Qui n'est rien d'autre qu'un symbole...


Et quelle est la définition de symbole ? Si *p (ci-dessous) en est un,
ce n'est pas le nom d'un tableau. Ne faut-il pas dire "identifiant" ?

(alors que si p pointe vers un
tableau,


définition de p ???


du type :

int a[3] = {0, 1, 2};
int (*p)[3] = &a;

il me semble que *p est également concerné par cette
conversion),


Quelle conversion ?-)


En effet, pas de conversion, sinon celle de lvalue à rvalue.

La seule conversion (implicite, j'entend) est celle qui a lieu quand tu
passe un tableau en paramètre à une fonction. Ce que la fonction reçoit
effectivement est un pointeur, et non le tableau lui-même - d'où le fait
que sizeof retourne la taille du pointeur et non le nombre d'éléments du
tableau.


Oui.

ou d'exception sur certains opérateur (& et sizeof, ce qui
n'est pas faux, mais dont la cause semble être le fait que derrière ces
opérateurs, une lvalue n'est pas convertie en rvalue).

Ma question est simple : cette phrase est-elle vraie ?



Laquelle ?-)


Celle du début... :)

--
"Yo!"
Martin Heidegger (trad. Terrence Malick)


Avatar
Yoxoman

Le 29-03-2006, Yoxoman a écrit :
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)

On parle par exemple du nom du tableau (alors que si p pointe vers un
tableau, il me semble que *p est également concerné par cette
conversion),


Quelle conversion ? Et quel type de p ?
int tab[64];
int* p= tab;
ou bien
typedef int Tab64[64];
Tab64 tab;
Tab64 *p= &tab;


Bah, p pointe vers un tableau. C'est la deuxième solution, il me semble.
Mais comme me l'a fait remarquer Bruno, il n'y a pas de conversion.
C'est juste que *p a une valeur de type pointeur vers int.

ou d'exception sur certains opérateur (& et sizeof,


et +, []...


Non, ces opérateurs attendent des valeurs. Et la somme d'un tableau et
d'un entier sera bien un pointeur, non ? En fait, je parle des énoncés
tel que ceux de la faq :

http://www.eskimo.com/~scs/c-faq.com/aryptr/aryptrequiv.html

ce qui
n'est pas faux, mais dont la cause semble être le fait que derrière ces
opérateurs, une lvalue n'est pas convertie en rvalue).


Là, je suis perdu.


Il me semble que & et sizeof s'appliquent à des lvalue (semantiquement
un objet - avec une adresse), alors que (tous ?) les autres opérateurs
s'appliquent à des rvalue (sémantiquement une valeur).

Ma question est simple : cette phrase est-elle vraie ?


Pas dans un contexte de logique booléenne. Après,
si on acepte d'avoir une valeur de véracité continue
entre 0 et 1, je lui mets environ 0,8...


Ha bon ? Mais pourquoi ? Je parle de la phrase du début (je ne sais pas
si je suis clair).

--
"Yo!"
Martin Heidegger (trad. Terrence Malick)


Avatar
Marc Boyer
Le 29-03-2006, Yoxoman a écrit :

Le 29-03-2006, Yoxoman a écrit :
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)

On parle par exemple du nom du tableau (alors que si p pointe vers un
tableau, il me semble que *p est également concerné par cette
conversion),


Quelle conversion ? Et quel type de p ?
int tab[64];
int* p= tab;
ou bien
typedef int Tab64[64];
Tab64 tab;
Tab64 *p= &tab;


Bah, p pointe vers un tableau. C'est la deuxième solution, il me semble.
Mais comme me l'a fait remarquer Bruno, il n'y a pas de conversion.
C'est juste que *p a une valeur de type pointeur vers int.


Heuh, je ne comprends rien à ta réponse. Dans les deux versions,
p pointe 'vers un tableau'. Dans le premier cas, *p est de type
int, dans l'autre, il est de type int[4].

ou d'exception sur certains opérateur (& et sizeof,


et +, []...


Non, ces opérateurs attendent des valeurs. Et la somme d'un tableau et
d'un entier sera bien un pointeur, non ?


Oui, mais le calcul effectué par + dépend de type de pointeur.
Si tu veux, p+1 sera différent dans les deux versions que j'ai donné.

En fait, je parle des énoncés
tel que ceux de la faq :

http://www.eskimo.com/~scs/c-faq.com/aryptr/aryptrequiv.html


Ben, il a l'air plutôt juste comme énoncé. Mais il parle
bien de 'array-to-T' et 'pointer-to-T', et pas (comme ma deuxième
version) 'pointer-to-array-to-T'?

ce qui
n'est pas faux, mais dont la cause semble être le fait que derrière ces
opérateurs, une lvalue n'est pas convertie en rvalue).


Là, je suis perdu.


Il me semble que & et sizeof s'appliquent à des lvalue (semantiquement
un objet - avec une adresse), alors que (tous ?) les autres opérateurs
s'appliquent à des rvalue (sémantiquement une valeur).


Et sizeof(int) ?

Ma question est simple : cette phrase est-elle vraie ?


Pas dans un contexte de logique booléenne. Après,
si on acepte d'avoir une valeur de véracité continue
entre 0 et 1, je lui mets environ 0,8...


Ha bon ? Mais pourquoi ? Je parle de la phrase du début (je ne sais pas
si je suis clair).


Ben
"La valeur d'un tableau est un pointeur vers son premier élément".
n'a pas de sens car 'valeur' en a peu, et 'pointeur' est un objet,
pas une valeur.

On pourrait avancer vers:
"La valeur d'un tableau sur T est égale à celle d'un pointeur
du T contenant l'adresse de son premier élement".

Mais je ne suis toujours pas d'accord, car la valeur d'un
tableau, c'est pour moi la valeur de ces cases.

Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. Paul Éluard)



Avatar
bruno at modulix
Yoxoman wrote:


Yoxoman wrote:

"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)




Bon, reprenons...
(snip)



Et on peut effectivement, *dans les deux cas*, utiliser de façon
interchangeable la syntaxe tableau et la syntaxe pointeur - puisqu'en
fait la syntaxe tableau n'est guère plus que du sucre syntaxique.


Je pense aussi. Mais il me semble que c'est en contradiction avec la fin
de

http://www.eskimo.com/~scs/c-faq.com/aryptr/aryptr2.html


voir ici :
http://www.eskimo.com/~scs/c-faq.com/aryptr/aryptrequiv.html

"""
Une référence à un objet de type tableau-de-T apparaissant dans une
expression se dégrade (à 3 exceptions près) en un pointeur sur le
premier élément du tableau. Le type de ce pointeur est pointeur-sur-T.
"""

Les trois exceptions sont
- quand le tableau est l'opérande de & ou de sizeof
- quand le tableau est une chaine littérale servant d'initialisateur
pour un tableau de char.


il me semble que *p est également concerné par cette
conversion),


Quelle conversion ?-)


(snip)


La seule conversion (implicite, j'entend) est celle qui a lieu quand tu
passe un tableau en paramètre à une fonction.
(snip)



Oui.


Bin non :(

Ma mémoire m'a trahi. Il y a bien conversion, cf trad ci-dessus.

Ma question est simple : cette phrase est-elle vraie ?



Laquelle ?-)



Celle du début... :)



A ton avis ?-))



--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in ''.split('@')])"



Avatar
Emmanuel Delahaye
"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)


Je préfère

"La valeur d'un tableau est l'adresse et a le type de son premier élément".

--
A+

Emmanuel Delahaye

Avatar
Harpo
Yoxoman wrote:

"La valeur d'un tableau est un pointeur vers son premier élément".
(valeur dans le sens rvalue. D'ailleurs ce mot peut-il avoir un autre
sens ?)

On entend souvent des formulations plus ou moins diverses et
compliquées sur cette conversion tableau-pointeur, ce qui fait qu'on a
du mal à s'y retrouver.
On parle par exemple du nom du tableau (alors que si p pointe vers un
tableau, il me semble que *p est également concerné par cette
conversion), ou d'exception sur certains opérateur (& et sizeof, ce
qui n'est pas faux, mais dont la cause semble être le fait que
derrière ces opérateurs, une lvalue n'est pas convertie en rvalue).

Ma question est simple : cette phrase est-elle vraie ?


Cette phrase est confusante. On ne peut dire qu'elle soit vraie ni
qu'elle soit fausse mais j'ai peur qu'elle soit seulement
compréhensible que lorsqu'on la comprend...
Les mots sont trompeurs mais très généralement on associe un tableau à
une adresse, mais on peut aussi parler de valeurs dans ce tableau. Par
exemple en disant "j'ai 4096 éléments de 1024 octets dans le tableau p"
alors que p est une variable qui fait 32 ou 64 bits en général.
Le sens est rétabli dans le contexte.
Voilà un petit programme dont l'ecécution peut peut-être permettre d'y
voir plus clair :

#include <stdlib.h>
#include <stdio.h>
int main( ) {
char a[16] = "blurb";
char * p = "blah" ;
printf( "1 : a=%p (%u) &a=%p (%u)n",
a, sizeof(a), &a, sizeof(&a) );
printf( "2 : p=%p (%u) &p=%p (%u)n",
p, sizeof(p), &p, sizeof(&p) );
printf( "3 : a=%s p=%sn", a, p );
return EXIT_SUCCESS ;
}


--
http://patrick.davalan.free.fr/

Avatar
bruno at modulix
Harpo wrote:
(snip)
Cette phrase est confusante.


En effet !-)

--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in ''.split('@')])"

Avatar
Antoine Leca
En news:,
Yoxoman va escriure:
On parle par exemple du nom du tableau


Un tableau est un objet. Parler de son "nom" est clairement un abus de
style. Un objet n'a pas vraiment de nom ; on peut concevoir de désigner de
cette façon l'identificateur qui _désigne_ l'objet, lorsqu'il est unique ;
mais parfois cet identificateur n'existe pas, ou il peut ne pas être unique.


Antoine

1 2 3 4 5