Position de const

Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> wrote in message
news:<flfzinqs16.fsf@sel.cmla.ens-cachan.fr>...

kanze@gabi-soft.fr writes:

| légal comme simple-type-specifier. En fait, pour savoir ce qui est
| permis dans un simple-type-specifier, il faut regarder dans §7.1.5.2
| (section qui s'appelle « Simple type specifiers » -- qui l'aurait
| cru),

nous sommes en train de parler de « decl-specifier » et non de «
simple-type-specifier ». Et pour savoir ce qui est permis dans un
decl-specifier, il faut regarder dans 7.1 qui porte le nom de «
specifer » -- qui l'eut cru ?.

Nous sommes en train de parler des composants d'un
« decl-specifier-seq ». Et §7.1 dit bien qu'un « decl-specifier-seq »
comporte un ou plusieurs « decl-specifier », un « decl-specifier » étant
soit un « storage-class-specifier », soit un « type-specifier », soit un
« function-specifier », soit le mot clé « friend », soit le mot clé
« typedef ».

Rien ici ni sur unsigned, ni sur un nom de type défini par
l'utilisateur. Tous les deux tombent dans la catégorie
« type-specifier », et en particulier « simple-type-specifier ». Décrit
en §7.1.5.2, où il est bien précisé, sans ambigüité, que la combinaison
« unsigned typedef-name » est illégal.

Mais je remarque avec ta mauvaise fois habituelle, tu as négligé à citer
tes commentaires sur la légalité de :

typedef int I ;
unsigned I i ;

qui était le point de départ de mes commentaires. Est-ce que tu
continues à prétendre que c'est légal ? C'est au fond le seul point
technique du débat.

[...]

| > | Maintenant, est-ce que tu accepteras également « int extern
| > | unsigned » ? Voire même « int unsigned const extern » ?

| > si je dois accepter « int const », pourquoi ne pas accepter
| > d'autres avatards ?

| Peut-être parce que tu n'es pas seul au monde,

si je ne suis pas seul au monde, alors il est presque certain que toi
non plus tu n'es pas seul au monde et si je dois accepter « int
const », je ne vois aucune raison de ne pas accepter les autres
avatards.

Je ne suis pas seul au monde. C'est pourquoi j'adopte un style
préconcisé par d'autres. Est-ce que tu connais des règles de
programmation qui préconcise des choses comme « int extern unsigned » ?
Ou est-ce que c'est simplement une fantasie de ta part ?

Note bien que je t'accorde le poid de la tradition en faveur de «@const
int ». C'est un aspect à ne pas négliger dans la considération d'un
choix. Moi-même, j'étais convaincu assez vite de la logique derrière
mettre le const à la fin (peut-être plus alors d'ailleurs
qu'aujourd'hui), et j'étais probablement parmi les premiers à adopter
l'innovation dans mon propre code. En revanche, j'ai continué à utiliser
« const int » pendant longtemps dans mon code professionnel, par souci
de cohérence, et parce que c'était une convention nouvelle, et non
répandue.

Aujourd'hui, la situation a évoluée, et je crois bien qu'on peut parler
de deux traditions. C'est vrai qu'une est plus récente, et moins
répandue, mais c'est aussi vrai qu'elle semble avoir un certain
momentum. Dans l'ensemble, j'estîme qu'il y a des arguments techiniques
en faveur d'une façon -- pas aussi forts que certains prétendent, mais
des arguments techniques quand même. Et que le poids de la tradition
favorise toujours l'autre. Mais plus d'une façon absolue. Je dis donc
que ces deux formes sont acceptables. Je n'accepte pas a priori d'autres
fantasies, mais je suis ouvert si on veut me présenter des raisons
techniques pour éventuellement justifier rompre avec la tradition.

(Et je le trouve assez incroyable que pour une fois, c'est toi qui
argues pour la tradition, et moi pour l'innovation:-).)

| et que d'autres auraient éventuellement à travailler sur ton code ?

oui, et cela veut dire que je ne dois pas accepter les autres avatards
si j'acceptes « int const » ?

Je ne sais pas ce que tu entends par « avatar ». Il y a une séquence
«@traditionnelle ». Et la tradition n'est pas sans poids. Pour en
rompre, il faut de bonnes raisons.

Que tu trouves que les raisons présentées ne sont pas assez bonnes, je
comprends. C'est en fin de compte une question d'opinion, et les
opinions peuvent variées. J'accepte totalement ce point de vue ; je ne
le partage pas dans ce cas particulier, mais je reconnais le bien fondé
de ne pas rompre avec la tradition aussi. Si on avait à travailler sur
un projet ensemble, on discuterait avec les autres collègues, pour
décider que faire -- s'il n'y avait que nous deux, c'est probable que
j'adopterais ta façon, parce que tu as l'air d'y tenir, tandis que pour
moi, les avantages de ma façon ne sont pas assez importants pour que ça
vaut la peine d'insister.

En revanche, si toi, ou qui que ce soit d'autres, veut me faire avaler
d'autres entorses à la tradition, il va aussi falloir présenter des
raisons techniques pourquoi c'est préférable.

| Personne n'en discute la légalité.

Alors pourquoi tu écris cette phrase ? Pour remplir ton message qui
aurait été vide sinon ? Très certainement, parce que plus haut tu
discutes de « légalité ».

Tu as traité deux sujets dans ton posting : j'avais dit qu'un
déclaration de « unsigned I » était illégal, et tu as dis que
divaguait ; or, je ne divaguais pas -- c'est illégal selon la norme C++,
qui ne fait que réprendre la norme C, qui lui n'a rien changé de K&R. Et
je n'ai jamais vu un compilateur qui l'accepte.

De l'autre part, tu sembles préconciser (d'une façon ironique)
declarations du genre « unsigned extern int ». Là, personne ne discute
la légalité.

| On ne parle pas ici de ce qu'on peut faire, mais de ce qu'on doit
| faire.

c'est qui « on » ?

Ce que je fais dans mon code est certainement différent de ce que les
autres font dans leurs codes. Dans mon propre code, j'utilise de
manière cohérente « const T ».

Ce qui ne me pose aucun problème. Comme j'ai dit, si jamais on devait
travailler ensemble, j'adopterais probablement ta forme, simplement
parce que tu as l'air d'y tenir plus que moi.

À partir du moment où je dois accepter des formes variantes, je
considère que je dois accepter d'autres avatards. C'est une règle que
j'adapte à l'environnement.

En effet -- s'il y a un consensus dans le projet d'écrire « unsigned
extern int »...

Disons que d'une part, j'ai des fortes doutes que tu trouves jamais un
tel consensus, et que d'autre, pour s'écarter de la tradition (qui
correspond à ta façon d'écrire), j'aimerais entendre des arguments
techniques. En ce qui concerne la post-positionnement du const, il y en
a. Il ne sont pas aussi forts que j'avais cru au départ (il y a environ
dix ans), mais entretemps, il s'est développé une deuxième tradition.
Mois importante que la première, mais assez pour rendre la seule
d'acceptation plus bas.

Enfin : c'est mon avis. Je comprends que tu puisses en avoir un autre ;
je crois vraiment que c'est une question de style ou de goût. Pour la
reste, tu sembles d'accord sur ce que je considère l'essentiel : tu
t'adapte à l'environement.

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16

kanze@gabi-soft.fr writes:

[...]

| Rien ici ni sur unsigned, ni sur un nom de type défini par
| l'utilisateur. Tous les deux tombent dans la catégorie
| « type-specifier », et en particulier « simple-type-specifier ». Décrit
| en §7.1.5.2, où il est bien précisé, sans ambigüité, que la combinaison
| « unsigned typedef-name » est illégal.

où vois-tu cette précision ? Le passage que tu as cité dans ton
précédent message ne le dit pas.

| Mais je remarque avec ta mauvaise fois habituelle,

c'est l'hôpital qui se fout de la charité.

| tu as négligé à citer
| tes commentaires sur la légalité de :
|
| typedef int I ;
| unsigned I i ;

Non, je ne l'ai pas negligé puisque le passage auquel tu répondais ci
haut le couvre. Mais, c'est vrai que pour toi il faut tout repeter.

[...]

| > | > | Maintenant, est-ce que tu accepteras également « int extern
| > | > | unsigned » ? Voire même « int unsigned const extern » ?
|
| > | > si je dois accepter « int const », pourquoi ne pas accepter
| > | > d'autres avatards ?
|
| > | Peut-être parce que tu n'es pas seul au monde,
|
| > si je ne suis pas seul au monde, alors il est presque certain que toi
| > non plus tu n'es pas seul au monde et si je dois accepter « int
| > const », je ne vois aucune raison de ne pas accepter les autres
| > avatards.
|
| Je ne suis pas seul au monde. C'est pourquoi j'adopte un style
| préconcisé par d'autres.

Mais c'est ton droit le plus absolu. Quelqu'un l'a-t-il remis en cause
dans ce thread ?

| Est-ce que tu connais des règles de
| programmation qui préconcise des choses comme « int extern unsigned » ?

Je n'en connais pas mais où est le rapport avec ce thread.

| Ou est-ce que c'est simplement une fantasie de ta part ?

Non. Mais, t'es-tu demandé si tu n'es pas encore une fois victime de
ton « a priori » en ce qui me concerne ? Au cas où cela t'aurait
échappé, je répète

si j'accepte « int const », pourquoi ne pas accepter les autres
avatards ?

« les avatards » incluant bien sûr le machine avec « extern ».
Relis bien ce que je viens de repeter avant de te précipiter sur la
touche « send ».

[...]

| que ces deux formes sont acceptables. Je n'accepte pas a priori d'autres
| fantasies, mais je suis ouvert si on veut me présenter des raisons
| techniques pour éventuellement justifier rompre avec la tradition.
|
| (Et je le trouve assez incroyable que pour une fois, c'est toi qui
| argues pour la tradition, et moi pour l'innovation:-).)

Moi, je ne trouve rien d'incroyable là dedans. Apparemment, tu sembles
croire que si je suis d'un côté, tu dois être de l'autre, si je suis
jeune alors tu dois être vieux, si je trouve une nouveauté intéressante,
alors tu dois arguer pour le conservatisme aveugle, si tu crois que tu
as raison alors je dois être de mauvaise foi

[...]

| En revanche, si toi, ou qui que ce soit d'autres, veut me faire avaler
| d'autres entorses à la tradition, il va aussi falloir présenter des
| raisons techniques pourquoi c'est préférable.

et puisque je n'ai nullement l'intention de te faire avaler une
quelconque entorse à quelque tradition, je n'ai rien à te présenter.

|
| > | Personne n'en discute la légalité.
|
| > Alors pourquoi tu écris cette phrase ? Pour remplir ton message qui
| > aurait été vide sinon ? Très certainement, parce que plus haut tu
| > discutes de « légalité ».
|
| Tu as traité deux sujets dans ton posting : j'avais dit qu'un
| déclaration de « unsigned I » était illégal, et tu as dis que
| divaguait ; or, je ne divaguais pas -- c'est illégal selon la norme C++,
| qui ne fait que réprendre la norme C, qui lui n'a rien changé de K&R. Et
| je n'ai jamais vu un compilateur qui l'accepte.
|
| De l'autre part, tu sembles préconciser (d'une façon ironique)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

aies l'obligeance de fourner preuve de ton allegation.

[...]

| > Ce que je fais dans mon code est certainement différent de ce que les
| > autres font dans leurs codes. Dans mon propre code, j'utilise de
| > manière cohérente « const T ».
|
| Ce qui ne me pose aucun problème. Comme j'ai dit, si jamais on devait
| travailler ensemble, j'adopterais probablement ta forme, simplement
| parce que tu as l'air d'y tenir plus que moi.

tu n'as rien compris. Tu semble plus pressé d'accuser de mauvaise foi que
de comprendre ce que tu lis.

| > À partir du moment où je dois accepter des formes variantes, je
| > considère que je dois accepter d'autres avatards. C'est une règle que
| > j'adapte à l'environnement.
|
| En effet -- s'il y a un consensus dans le projet d'écrire « unsigned
| extern int »...
|
| Disons que d'une part, j'ai des fortes doutes que tu trouves jamais un
| tel consensus, et que d'autre, pour s'écarter de la tradition (qui
| correspond à ta façon d'écrire), j'aimerais entendre des arguments
| techniques.

Pour utiliser l'écriture traditionnelle ? Je t'ai déjà expliquer.

[...]

| reste, tu sembles d'accord sur ce que je considère l'essentiel : tu
| t'adapte à l'environement.

et tu ne t'en es jamais rendu compte avant ?

-- Gaby

Jean-Marc Bourguet <jm@bourguet.org> writes:

[...]

| > c'est vrai que les gens aiment les mot clés pour faire des greps.
| >
| > i : int
| >
| > ne nécessite comme mot-clé que « : ». Mais il y a fort à parier qu'il
| > servira déjà de séparateur/ponctuateur.
|
| A part l'introduction de definition, tu vois quel usage (ok, ?:)>

en fait, je trouve que l'opérateur ternaire « ? : » est assez concis
et je le retiendrais très certainement.

| > Oh, j'irai même à proposer le lispesque
| >
| > :i int;
| >
| > ou [:i int] ou [i : int]
| >
| >
| > [...]
| >
| > | Il ne faut pas oublier non plus que pour peu qu'on sait tapper (ce que
| > | doit savoir tout programmeur), on tappe des lettres jusqu'à dix fois
| > | plus vite que les caractères spéciaux. Je sais qu'il me faut moins de
| > | temps à tapper « begin » que de tapper un « { ». Et je parle encore d'un
| >
| > tout programmeur C++ digne de ce nom sait taper { 20 fois plus que que
| > begin. <g>
|
| entre CTRL-U 20 { et begin, je sais ce que je prefere. :-)

il te faut un CTRL-U 20 sur ton clavier ? (c'est lequel ?)

-- Gaby

Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:

Jean-Marc Bourguet <jm@bourguet.org> writes:

[...]

| > c'est vrai que les gens aiment les mot clés pour faire des greps.
| >
| > i : int
| >
| > ne nécessite comme mot-clé que « : ». Mais il y a fort à parier qu'il
| > servira déjà de séparateur/ponctuateur.
|
| A part l'introduction de definition, tu vois quel usage (ok, ?:)

en fait, je trouve que l'opérateur ternaire « ? : » est assez concis
et je le retiendrais très certainement.

Mais une autre syntaxe est possible, ( cond | vrai | faux ) pour n'en
citer qu'une disponible en Algol 68 avec l'avantage d'etre une
structure fermee et posant moins de probleme de memorisation de
priorite. (Mais bon, tout depend de savoir si on est en train de
definir un nouveau langage ou bien de modifier le C++ incrementalement
dans le second cas on va necessairement examiner moins
d'alternatives).

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:

Jean-Marc Bourguet <jm@bourguet.org> writes:
| > | Il ne faut pas oublier non plus que pour peu qu'on sait tapper (ce que
| > | doit savoir tout programmeur), on tappe des lettres jusqu'à dix fois
| > | plus vite que les caractères spéciaux. Je sais qu'il me faut moins de
| > | temps à tapper « begin » que de tapper un « { ». Et je parle encore d'un
| >
| > tout programmeur C++ digne de ce nom sait taper { 20 fois plus que que
| > begin. <g>
|
| entre CTRL-U 20 { et begin, je sais ce que je prefere. :-)

il te faut un CTRL-U 20 sur ton clavier ? (c'est lequel ?)

Pour taper 20 {, j'utilise ctrl-U 20.

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Jean-Marc Bourguet <jm@bourguet.org> writes:

| Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:
|
| > Jean-Marc Bourguet <jm@bourguet.org> writes:
| >
| > [...]
| >
| > | > c'est vrai que les gens aiment les mot clés pour faire des greps.
| > | >
| > | > i : int
| > | >
| > | > ne nécessite comme mot-clé que « : ». Mais il y a fort à parier qu'il
| > | > servira déjà de séparateur/ponctuateur.
| > |
| > | A part l'introduction de definition, tu vois quel usage (ok, ?:)
| >
| > en fait, je trouve que l'opérateur ternaire « ? : » est assez concis
| > et je le retiendrais très certainement.
|
| Mais une autre syntaxe est possible, ( cond | vrai | faux ) pour n'en
| citer qu'une disponible en Algol 68 avec l'avantage d'etre une
| structure fermee et posant moins de probleme de memorisation de
| priorite.

l'inconvenient que j'en trouve est que cette notation ne retient plus
le caractère binaire de « | » -- que j'aurais pour un « ou ».

| (Mais bon, tout depend de savoir si on est en train de
| definir un nouveau langage ou bien de modifier le C++ incrementalement
| dans le second cas on va necessairement examiner moins
| d'alternatives).

yup.

-- Gaby

Jean-Marc Bourguet <jm@bourguet.org> writes:

| Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:
|
| > Jean-Marc Bourguet <jm@bourguet.org> writes:
| > | > | Il ne faut pas oublier non plus que pour peu qu'on sait tapper (ce que
| > | > | doit savoir tout programmeur), on tappe des lettres jusqu'à dix fois
| > | > | plus vite que les caractères spéciaux. Je sais qu'il me faut moins de
| > | > | temps à tapper « begin » que de tapper un « { ». Et je parle encore d'un
| > | >
| > | > tout programmeur C++ digne de ce nom sait taper { 20 fois plus que que
| > | > begin. <g>
| > |
| > | entre CTRL-U 20 { et begin, je sais ce que je prefere. :-)
| >
| > il te faut un CTRL-U 20 sur ton clavier ? (c'est lequel ?)
|
| Pour taper 20 {, j'utilise ctrl-U 20.

OK.

Mais pourquoi tapes-tu 20 « { » ?

-- Gaby, curieux

Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:

Jean-Marc Bourguet <jm@bourguet.org> writes:

| Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:
|
| > Jean-Marc Bourguet <jm@bourguet.org> writes:
| > | > | Il ne faut pas oublier non plus que pour peu qu'on sait tapper (ce que
| > | > | doit savoir tout programmeur), on tappe des lettres jusqu'à dix fois
| > | > | plus vite que les caractères spéciaux. Je sais qu'il me faut moins de
| > | > | temps à tapper « begin » que de tapper un « { ». Et je parle encore d'un
| > | >
| > | > tout programmeur C++ digne de ce nom sait taper { 20 fois
| > | > plus que que begin. <g>
| > |
| > | entre CTRL-U 20 { et begin, je sais ce que je prefere. :-)
| >
| > il te faut un CTRL-U 20 sur ton clavier ? (c'est lequel ?)
|
| Pour taper 20 {, j'utilise ctrl-U 20.

OK.

Mais pourquoi tapes-tu 20 « { » ?

C'est toi qui dit que "tout programmeur C++ digne de ce nom sait taper
{ 20 fois plus que que begin." que j'ai analyse comme "tout
programmeur C++ digne de ce nom sait (taper { 20 fois) plus [vite] que
que begin".

A+

--
Jean-Marc FAQ de fclc++:
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF:
http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de
usenet-fr: http://www.usenet-fr.news.eu.org

Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:

Jean-Marc Bourguet <jm@bourguet.org> writes:

| Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:

| > | > | entre CTRL-U 20 { et begin, je sais ce que je prefere. :-)
| > | >
| > | > il te faut un CTRL-U 20 sur ton clavier ? (c'est lequel ?)
| > |
| > | Pour taper 20 {, j'utilise ctrl-U 20.
| >
| > OK.
| >
| > Mais pourquoi tapes-tu 20 « { » ?
|
| C'est toi qui dit que "tout programmeur C++ digne de ce nom sait taper
| { 20 fois plus que que begin." que j'ai analyse comme "tout
| programmeur C++ digne de ce nom sait (taper { 20 fois) plus [vite] que
| que begin".

je voulais effectivement dire 20 fois plus vite, mais pas 20 « { »
de suite plus vite ! T'as un demi-point en moins. Cela t'apprendras.

Je parie que je met moins que 20 fois le temps de taper un { pour
taper ctrl-u 20 { :-) et que je sais toujours ce que je prefere avec
begin. De toute maniere, begin je prefere ne taper ni { ni begin :-)

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Jean-Marc Bourguet <jm@bourguet.org> writes:

| Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:
|
| > Jean-Marc Bourguet <jm@bourguet.org> writes:
| >
| > | Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> writes:
|
| > | > | > | entre CTRL-U 20 { et begin, je sais ce que je prefere. :-)
| > | > | >
| > | > | > il te faut un CTRL-U 20 sur ton clavier ? (c'est lequel ?)
| > | > |
| > | > | Pour taper 20 {, j'utilise ctrl-U 20.
| > | >
| > | > OK.
| > | >
| > | > Mais pourquoi tapes-tu 20 « { » ?
| > |
| > | C'est toi qui dit que "tout programmeur C++ digne de ce nom sait taper
| > | { 20 fois plus que que begin." que j'ai analyse comme "tout
| > | programmeur C++ digne de ce nom sait (taper { 20 fois) plus [vite] que
| > | que begin".
| >
| > je voulais effectivement dire 20 fois plus vite, mais pas 20 « { »
| > de suite plus vite ! T'as un demi-point en moins. Cela t'apprendras.
|
| Je parie que je met moins que 20 fois le temps de taper un { pour
| taper ctrl-u 20 { :-) et que je sais toujours ce que je prefere avec
| begin. De toute maniere, begin je prefere ne taper ni { ni begin :-)

OK. Je m'incline.

-- Gaby