De la pertinence d'une phrase

"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 ?)

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'.

Là, c'est moi qui ne comprend plus rien. Dans le premier cas, p pointe
vers un entier, non ? Tu as bien écrit "int* p", ou c'est mes yeux ? :)

Dans le premier cas, *p est de type
int, dans l'autre, il est de type int[4].

Oui, modulo 64. Ce que je dis, c'est que *p a une *valeur* (rvalue) 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 ?

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é.

Oui, mais je dois mal m'exprimer. L'exception d'opérateurs dont je
parle, c'est celle mentionnée dans la faq (via le lien que je t'ai
donné).

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'?

*p est de type array-to-T.
Ce dont je parlait ici, c'est des énoncés du type « Whenever we use the
name of an array as a value, that name represents a pointer to the
initial element of the array. » (Accelerated C++).
Ce qui me gène, c'est « name of an array », étant donné qu'il me semble
que cette règle s'applique également par exemple pour *p.

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) ?

En effet. J'aurais du dire qu'une lvalue appliquée à & et sizeof n'est
pas convertie en rvalue.

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.

Pour moi, pointeur est un type. Ou plutôt un ensemble de types (pointeur
vers T). Je considère « un pointeur » comme synonyme de « une
expression de type pointeur ». Et une rvalue est une expression...

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.

Ce singulier-pluriel (*la* valeur ; *ses* cases) peut-il avoir un sens ?
Ou alors la valeur de l'ensemble de ses cases ? Mais je ne sais pas ce
que c'est.


En cherchant dans la norme C, je trouve (§6.3.2.1/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). (...) », et (§6.3.2.1/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.
(...) ».

Le premier paragraphe parle de conversion vers une « valeur contenue »,
et le deuxième de conversion vers autre chose. On sent une similarité
entre ces deux paragraphes, notamment au niveau des operateurs qui sont
exclus (bien sûr, ++, --, et . ne peuvent s'appliquer à un tableau).

La norme C ne parle pas de rvalue. En note de bas de la page 46, on peut
lire : « What is sometimes called ??rvalue?? is in this International
Standard described as the ??value of an expression??. ».
On lit également (§3.17/1): « value : precise meaning of the contents of
an object when interpreted as having a specific type. ». Mais la norme
du C ne définit pas la « valeur » d'un tableau.


A ce sujet, la norme C++ est un peu plus parlante (ou on peut la faire
plus parler, au choix).

Dans une partie « lvalue-to-rvalue conversion », on lit (§4.1/1) : « An
lvalue (3.10) of a non-function, non-array type T can be converted to an
rvalue (...) », et (§4.1/2) : « The value contained in the object
indicated by the lvalue is the rvalue result (...) ».
Dans la partie suivante, « array-to-pointer conversion », on lit (§
4.2/1): « An lvalue or rvalue of type ?array of N T? or ?array of
unknown bound of T? can be converted to an rvalue of type ?pointer to
T.? The result is a pointer to the first element of the array. »

(D'ailleurs, si quelqu'un a un exemple de rvalue de type tableau de N T,
je suis preneur...)

Le « can be converted » un peu mysterieux au premier abord est relatif
au contexte : certains operateurs prennent des lvalue, d'autres des
rvalue. Il faut donc une conversion dans certains cas (§5/8) : «
Whenever an lvalue expression appears as an operand of an operator that
expects an rvalue for that operand, the lvalue-to-rvalue (4.1), array-
to-pointer (4.2), or function-to-pointer (4.3) standard conversions are
applied to convert the expression to an rvalue. »

On peut noter une certaine similitude entre la conversion « lvalue-to-
rvalue » et « array-to-pointer ». Chacune conduit à produire des rvalue.

Donc...

Pour la norme C :

- Pour les lvalue qui ne sont pas de type tableau, on a une « valeur
contenue », synonyme de « valeur ». Pour les lvalue de type tableau, on
a une autre conversion, et on s'abstient de parler de valeur.

Pour la norme C++ :

- On a dans les deux cas une conversion vers une rvalue. Pour les
lvalues non-tableau, cette rvalue est la valeur contenue dans la lvalue.
Pour les lvalue tableau, cette rvalue est un pointeur vers le premier
élément du tableau.
Finalement, si la « valeur » d'une lvalue doit logiquement correspondre
avec « valeur contenue » dans le cas des lvalue non-tableau, on peut
raisonnablement lui donner comme définition plus large celle de « rvalue
», parce qu'elle inclut également les lvalue de type tableau.
Et donc de pouvoir écrire :

int x = 2; // x a pour valeur (rvalue) 2
int a[2] = {0, 1}; // a a pour valeur (rvalue) pointeur vers a[0]


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

Encodage foireux du premier message, j'espère qu'il est annulé. Je
recommmence.

"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 ?)

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'.

Là, c'est moi qui ne comprend plus rien. Dans le premier cas, p pointe
vers un entier, non ? Tu as bien écrit "int* p", ou c'est mes yeux ? :)

Dans le premier cas, *p est de type
int, dans l'autre, il est de type int[4].

Oui, modulo 64. Ce que je dis, c'est que *p a une *valeur* (rvalue) 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 ?

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é.

Oui, mais je dois mal m'exprimer. L'exception d'opérateurs dont je
parle, c'est celle mentionnée dans la faq (via le lien que je t'ai
donné).

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'?

*p est de type array-to-T.
Ce dont je parlait ici, c'est des énoncés du type « Whenever we use the
name of an array as a value, that name represents a pointer to the
initial element of the array. » (Accelerated C++).
Ce qui me gène, c'est « name of an array », étant donné qu'il me semble
que cette règle s'applique également par exemple pour *p.

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) ?

En effet. J'aurais du dire qu'une lvalue appliquée à & et sizeof n'est
pas convertie en rvalue.

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.

Pour moi, pointeur est un type. Ou plutôt un ensemble de types (pointeur
vers T). Je considère « un pointeur » comme synonyme de « une
expression de type pointeur ». Et une rvalue est une expression...

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.

Ce singulier-pluriel (*la* valeur ; *ses* cases) peut-il avoir un sens ?
Ou alors la valeur de l'ensemble de ses cases ? Mais je ne sais pas ce
que c'est.


En cherchant dans la norme C, je trouve (§6.3.2.1/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). (...) », et (§6.3.2.1/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.
(...) ».

Le premier paragraphe parle de conversion vers une « valeur contenue »,
et le deuxième de conversion vers autre chose. On sent une similarité
entre ces deux paragraphes, notamment au niveau des operateurs qui sont
exclus (bien sûr, ++, --, et . ne peuvent s'appliquer à un tableau).

La norme C ne parle pas de rvalue. En note de bas de la page 46, on peut
lire : « What is sometimes called "rvalue" is in this International
Standard described as the "value of an expression". ».
On lit également (§3.17/1): « value : precise meaning of the contents of
an object when interpreted as having a specific type. ». Mais la norme
du C ne définit pas la « valeur » d'un tableau.


A ce sujet, la norme C++ est un peu plus parlante (ou on peut la faire
plus parler, au choix).

Dans une partie « lvalue-to-rvalue conversion », on lit (§4.1/1) : « An
lvalue (3.10) of a non-function, non-array type T can be converted to an
rvalue (...) », et (§4.1/2) : « The value contained in the object
indicated by the lvalue is the rvalue result (...) ».
Dans la partie suivante, « array-to-pointer conversion », on lit (§
4.2/1): « An lvalue or rvalue of type "array of N T" or "array of
unknown bound of T" can be converted to an rvalue of type "pointer to
T". The result is a pointer to the first element of the array. »

(D'ailleurs, si quelqu'un a un exemple de rvalue de type tableau de N T,
je suis preneur...)

Le « can be converted » un peu mysterieux au premier abord est relatif
au contexte : certains operateurs prennent des lvalue, d'autres des
rvalue. Il faut donc une conversion dans certains cas (§5/8) : «
Whenever an lvalue expression appears as an operand of an operator that
expects an rvalue for that operand, the lvalue-to-rvalue (4.1), array-
to-pointer (4.2), or function-to-pointer (4.3) standard conversions are
applied to convert the expression to an rvalue. »

On peut noter une certaine similitude entre la conversion « lvalue-to-
rvalue » et « array-to-pointer ». Chacune conduit à produire des rvalue.

Donc...

Pour la norme C :

- Pour les lvalue qui ne sont pas de type tableau, on a une « valeur
contenue », synonyme de « valeur ». Pour les lvalue de type tableau, on
a une autre conversion, et on s'abstient de parler de valeur.

Pour la norme C++ :

- On a dans les deux cas une conversion vers une rvalue. Pour les
lvalues non-tableau, cette rvalue est la valeur contenue dans la lvalue.
Pour les lvalue tableau, cette rvalue est un pointeur vers le premier
élément du tableau.
Finalement, si la « valeur » d'une lvalue doit logiquement correspondre
avec « valeur contenue » dans le cas des lvalue non-tableau, on peut
raisonnablement lui donner comme définition plus large celle de « rvalue
», parce qu'elle inclut également les lvalue de type tableau.
Et donc de pouvoir écrire :

int x = 2; // x a pour valeur (rvalue) 2
int a[2] = {0, 1}; // a a pour valeur (rvalue) pointeur vers a[0]


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

"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".

Pourquoi ? Un pointeur est un objet ?

En fait, je ne trouve pas de référence à ceci dans la norme. Pointeur
vers T est définit en tant que type, mais quand ils font référence à «
un pointeur », on ne sait pas vraiment précisément ce dont ils parlent.

Du coup, je considère « un pointeur » comme synonyme à « une expression
de type pointeur ».

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

En news:MPG.1e9489eee866b7c5989747@news.free.fr,
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.

Aurais-tu un exemple d'identificateurs différents d'un même objet ?

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

"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".

Pourquoi ? Un pointeur est un objet ?

Oui, donc modifiable.

int a;
int *p = NULL;

p = &a;

Un tableau n'est pas modifiable

int a[10];

a = 123; /* ne compile pas. */

(son contenu l'est, par contre, mais il faut une syntaxe spéciale à base
de []).

a[2] = 123;

En fait, je ne trouve pas de référence à ceci dans la norme. Pointeur
vers T est définit en tant que type, mais quand ils font référence à «
un pointeur », on ne sait pas vraiment précisément ce dont ils parlent.

Du coup, je considère « un pointeur » comme synonyme à « une expression
de type pointeur ».

En anglais c'est assez confus. En français, c'est clair. Pointeur, c'est
la variable (le contenant), adresse, c'est la constante (le contenu ou
la valeur d'un pointeur). A la place de 'adresse', on peut utiliser
'constante [de type] pointeur' (traduction foireuse de /pointer
constant/). C'est tellement plus simple de dire adresse.

--
A+

Emmanuel Delahaye

Emmanuel Delahaye wrote:

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

Pourquoi ? Un pointeur est un objet ?

Oui, donc modifiable.

int a;
int *p = NULL;

p = &a;

Mais &a n'est-il un pointeur ?

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

Emmanuel Delahaye wrote:

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

Pourquoi ? Un pointeur est un objet ?

Oui, donc modifiable.

int a;
int *p = NULL;

p = &a;

Mais &a n'est-il un pointeur ?
Le problème du fait que le même mot désigne à la fois un type, une

variable, une valeur (constante ou modifiable) n'en est pas un, puisque
c'est comme ça.

&a est une rvalue de type int*. Sa valeur n'est pas connue à la
compilation, mais je pense qu'on a le droit de la considérer comme une
valeur immédiate. En fait, dans ce cas où a est une variable
automatique, et s'il y a une pile, &a sera remplacé par une valeur
immédiate ajoutée ou retranchée au pointeur de pile.
J'imagine qu'en C, comme c'est courant en assembleur, &a, selon la
classe de stockage de a, peut-être une valeur immédiate résolue par le
loader.

Question aux gurus: il me semble évident qu'à partir du moment où une
variable est déclarée, et durant toute sa vie, l'opérateur adresse
renverra toujours la même valeur. Vous confirmez ?

--
Pierre Maurette

"Pierre Maurette" <maurettepierre@wanadoo.fr> a écrit dans le message de news:mn.fa2e7d634c6a755e.31483@laposte.net...

Question aux gurus: il me semble évident qu'à partir du moment où une
variable est déclarée, et durant toute sa vie, l'opérateur adresse
renverra toujours la même valeur. Vous confirmez ?

Oh, c'est étonnant comme question.
J'essaye d'imaginer qu'il en soit ainsi, l'opérateur adresse retournant pour un même variable une valeur différente ... Je ne le conçoit pas.
Ou alors, en revenant à la segmentation de la mémoire.

Le 30-03-2006, Yoxoman <yhpnfyrqber@tznvy.pbz> 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 ?)

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'.

Là, c'est moi qui ne comprend plus rien. Dans le premier cas, p pointe
vers un entier, non ? Tu as bien écrit "int* p", ou c'est mes yeux ? :)

Oui, mais l'entier et le tableau ont la même adresse.
C'est la notion de 'pointe sur' qui n'est pas claire.

Dans le premier cas, *p est de type
int, dans l'autre, il est de type int[4].

Oui, modulo 64. Ce que je dis, c'est que *p a une *valeur* (rvalue) de
type pointeur vers int.

Bof... A ce rythme là, il a aussi une valeur de type char*
(modulo sizeof(int)).

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é.

Oui, mais je dois mal m'exprimer. L'exception d'opérateurs dont je
parle, c'est celle mentionnée dans la faq (via le lien que je t'ai
donné).

Je ne t'accuse absolument pas de ne pas comprendre. Ce que je
dis, c'est que la phrase cité initiallement permet de comprendre
"un peu" ce qui se passe. Mais qu'elle est imprécise.

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'?

*p est de type array-to-T.

typedef int Tab64[64];
Tab64 a;
int* pi= a;
Trab64* pt= &a;

pi est de type pointer-to-int
*pi est de type int
pt est de type pointer-to-array-to-T
*pt est de type array-to-T

Ce dont je parlait ici, c'est des énoncés du type « Whenever we use the
name of an array as a value, that name represents a pointer to the
initial element of the array. » (Accelerated C++).

Sauf avec sizeof et &.

Ce qui me gène, c'est « name of an array », étant donné qu'il me semble
que cette règle s'applique également par exemple pour *p.

Oui.

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.

Pour moi, pointeur est un type. Ou plutôt un ensemble de types (pointeur
vers T). Je considère « un pointeur » comme synonyme de « une
expression de type pointeur ». Et une rvalue est une expression...

Faut faire attention avec ces raccourcis. Car alors 1 est un int,
et 0.0 un double.

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.

Ce singulier-pluriel (*la* valeur ; *ses* cases) peut-il avoir un sens ?
Ou alors la valeur de l'ensemble de ses cases ? Mais je ne sais pas ce
que c'est.

La valeur de l'ensemble de ses cases ? Tu ne vois pas ce que c'est ?

En cherchant dans la norme C, je trouve (§6.3.2.1/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). (...) », et (§6.3.2.1/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.
(...) ».

Le premier paragraphe parle de conversion vers une « valeur contenue »,
et le deuxième de conversion vers autre chose. On sent une similarité
entre ces deux paragraphes, notamment au niveau des operateurs qui sont
exclus (bien sûr, ++, --, et . ne peuvent s'appliquer à un tableau).

La norme C ne parle pas de rvalue. En note de bas de la page 46, on peut
lire : « What is sometimes called ??rvalue?? is in this International
Standard described as the ??value of an expression??. ».
On lit également (§3.17/1): « value : precise meaning of the contents of
an object when interpreted as having a specific type. ». Mais la norme
du C ne définit pas la « valeur » d'un tableau.

Pourtant, il faut bien donner une sémantique à
struct {
char tab[7];
double d;
} x , y= { "toto", 0.O } ;
x= y;

Je suis pas expert en recherche dans la norme, mais 6.5.16.1/1 définit
bien l'affectation comme le remplacement de 'value'. Donc, il faut
définir 'value' pour x et y. Et je ne vois pas comment faire sans
parler de 'value' pour tab.

Pour la norme C :

- Pour les lvalue qui ne sont pas de type tableau, on a une « valeur
contenue », synonyme de « valeur ». Pour les lvalue de type tableau, on
a une autre conversion, et on s'abstient de parler de valeur.

Et comment on exprime l'affectation entre tableaux dans des structures ?

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

Le 31-03-2006, Harpo <trashcan@hotmail.com> a écrit :

Emmanuel Delahaye wrote:

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

Pourquoi ? Un pointeur est un objet ?

Oui, donc modifiable.

int a;
int *p = NULL;

p = &a;

Mais &a n'est-il un pointeur ?

1 est il un int ?

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