Gabriel Dos Reis wrote in message
news:...Dimitri Papadopoulos-Orfanos
writes:
| réécrire des centaines de classes. Chose que je ne peux pas faire.
| Je pense que genre de changements met en cause la pertinence du C++
| pour l'écriture de gros projets destinés à vivre plusieurs années.
Ces règles n'ont pas été inventées hier.
[...]
Elles datent du temps même de la conception des templates.
Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient implémentées
dans CFront 3.0 ? N'exagérons rien.
Gabriel Dos Reis <gdr@cs.tamu.edu> wrote in message
news:<m31xgj1dgr.fsf@merlin.cs.tamu.edu>...
Dimitri Papadopoulos-Orfanos <dpo.remove@club-internet.decoy.fr>
writes:
| réécrire des centaines de classes. Chose que je ne peux pas faire.
| Je pense que genre de changements met en cause la pertinence du C++
| pour l'écriture de gros projets destinés à vivre plusieurs années.
Ces règles n'ont pas été inventées hier.
[...]
Elles datent du temps même de la conception des templates.
Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient implémentées
dans CFront 3.0 ? N'exagérons rien.
Gabriel Dos Reis wrote in message
news:...Dimitri Papadopoulos-Orfanos
writes:
| réécrire des centaines de classes. Chose que je ne peux pas faire.
| Je pense que genre de changements met en cause la pertinence du C++
| pour l'écriture de gros projets destinés à vivre plusieurs années.
Ces règles n'ont pas été inventées hier.
[...]
Elles datent du temps même de la conception des templates.
Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient implémentées
dans CFront 3.0 ? N'exagérons rien.
| > Elles datent du temps même de la conception des templates.
|
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient implémentées
| dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
[...]
| > Elles datent du temps même de la conception des templates.
|
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient implémentées
| dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
[...]
| > Elles datent du temps même de la conception des templates.
|
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient implémentées
| dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
[...]
writes:
| Gabriel Dos Reis wrote in message
| news:...
| > Dimitri Papadopoulos-Orfanos
| > writes:
| > | réécrire des centaines de classes. Chose que je ne peux pas
| > | faire. Je pense que genre de changements met en cause la
| > | pertinence du C++ pour l'écriture de gros projets destinés à
| > | vivre plusieurs années.
| > Ces règles n'ont pas été inventées hier.
| Qu'importe quand elles ont été inventées.
Cela importe parce que l'histoire de cette règle fait partie de la
confusion et de ses conséquences.
| Elles ne sont pas particulièrement intuitives.
« intuitives » est une question d'opinion, et non une vérité. Je ne me
fierais pas à ton intuition -- je me méfies déjà de la mienne.
| Surtout, elles représentent un changement par rapport à ce que les
| compilateurs faisaient jusqu'il y a peu.
On a eu ce débat plusieurs fois. À chaque fois, tu répètes les mêmes
choses et à chaque fois tu dois te faire corriger. Par moi, ou par
David Vendevoorde. Je ne désespère pas qu'un jour cela va rentrer.
Les compilateurs ont choisi d'ignorer la règle, cela ne veut pas dit
qu'elle date d'hier.
Je t'ai déjà donné des références publiques remontant au moins à 1992,
qui montrent que la notion de recherche en deux phases étaient
considérées bien avant qu'on ait eu les aspects les plus avancés des
templates.
| > Elles datent du temps même de la conception des templates.
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
| implémentées dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
L'implémentation qui était livrée avec CFront ne contient pas tout ce
que le concepteur des templates envisageait.
| La situation est complexe. L'idée d'utiliser une recherche à deux
| temps est apparue assez vite (2-3 ans ?) après les premières
| implémentations des templates, et bien avant la plupart des
| implémentations.
Tu doutes que je travaille pour celui qui a conçu les templates, que
je travaille tous les jours sur les templates avec celui qui les a
conçus et qu'on discute quotidiennement des points techniques,
non-techniques et de son histoire ; et donc que j'ai accès à
l'information de première main que les allégations très approximatives
que racontes ?
| Je crois que l'intention d'imposer une recherche à deux temps est
| apparue assez tôt dans le groupe de travail qui s'occupait des
| templates dans le comité de normalisation.
Tu racontes cela comme si tu y étais,
alors même que tu ne savais pas que cela existait jusqu'à ce que je te
montre le papier en question et que tu me répondes quelque chose du
genre « eh bin, peut-être qu'ils en parlaient, mais moi je n'étais pas
dans ce groupe, et puis de toute façon, même ceux qui savaient n'en
parlaient pas, et puis j'ai raison. » <G>.
| Ce qui veut dire que les implémenteurs des compilateurs en étaient
| probablement au courants, au moins pour la plupart. Ils ont
| effectivement choisi de l'ignorer, de façon à ce que leurs
| utilisateurs aient davantage de problèmes maintenant.
Et David Vandevoorde t'a raconté son expérience personnelle de
l'époque où il travaillait sur le compilateur d'HP. Ils avaient
implémenté la règle en question vers 1997 ; après des tests sur des
programmes, ils avaient décidé de désactiver.
Et comme David le rappelle à chaque fois, cette règle est discutée
dans D&E.
| Pour monsieur tout le monde, évidemment, les templates, c'était ce
| que faisait CFront, étant donné que c'était le seul compilateur qui
| les implémentait. Pendant longtemps, d'ailleurs, ce que faisait
| CFront faisait figure de norme pour les utilisateurs et les autres
| implémenteurs. Jusqu'au point d'en dupliquer les bugs. Même
| aujourd'hui, certains compilateurs conforme (exprès) plus à ce que
| faisait CFront qu'à la norme.
| > Certaines personnes (avec le complice de certains compilateurs)
| > essayeront de te faire croire que c'est pas vrai.
| Tu peux montrer qui, et où ?
Ben lis tes deux messages, je n'ai pas besoin d'aller chercher plus
loin. Ou fais un google pour tes messages dans ce groupe où toi et moi
en avons discuté, ou dans comp.lang.c++.moderated ou comp.std.c++ où
David Vandevoorde était intervenu.
kanze@gabi-soft.fr writes:
| Gabriel Dos Reis <gdr@cs.tamu.edu> wrote in message
| news:<m31xgj1dgr.fsf@merlin.cs.tamu.edu>...
| > Dimitri Papadopoulos-Orfanos <dpo.remove@club-internet.decoy.fr>
| > writes:
| > | réécrire des centaines de classes. Chose que je ne peux pas
| > | faire. Je pense que genre de changements met en cause la
| > | pertinence du C++ pour l'écriture de gros projets destinés à
| > | vivre plusieurs années.
| > Ces règles n'ont pas été inventées hier.
| Qu'importe quand elles ont été inventées.
Cela importe parce que l'histoire de cette règle fait partie de la
confusion et de ses conséquences.
| Elles ne sont pas particulièrement intuitives.
« intuitives » est une question d'opinion, et non une vérité. Je ne me
fierais pas à ton intuition -- je me méfies déjà de la mienne.
| Surtout, elles représentent un changement par rapport à ce que les
| compilateurs faisaient jusqu'il y a peu.
On a eu ce débat plusieurs fois. À chaque fois, tu répètes les mêmes
choses et à chaque fois tu dois te faire corriger. Par moi, ou par
David Vendevoorde. Je ne désespère pas qu'un jour cela va rentrer.
Les compilateurs ont choisi d'ignorer la règle, cela ne veut pas dit
qu'elle date d'hier.
Je t'ai déjà donné des références publiques remontant au moins à 1992,
qui montrent que la notion de recherche en deux phases étaient
considérées bien avant qu'on ait eu les aspects les plus avancés des
templates.
| > Elles datent du temps même de la conception des templates.
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
| implémentées dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
L'implémentation qui était livrée avec CFront ne contient pas tout ce
que le concepteur des templates envisageait.
| La situation est complexe. L'idée d'utiliser une recherche à deux
| temps est apparue assez vite (2-3 ans ?) après les premières
| implémentations des templates, et bien avant la plupart des
| implémentations.
Tu doutes que je travaille pour celui qui a conçu les templates, que
je travaille tous les jours sur les templates avec celui qui les a
conçus et qu'on discute quotidiennement des points techniques,
non-techniques et de son histoire ; et donc que j'ai accès à
l'information de première main que les allégations très approximatives
que racontes ?
| Je crois que l'intention d'imposer une recherche à deux temps est
| apparue assez tôt dans le groupe de travail qui s'occupait des
| templates dans le comité de normalisation.
Tu racontes cela comme si tu y étais,
alors même que tu ne savais pas que cela existait jusqu'à ce que je te
montre le papier en question et que tu me répondes quelque chose du
genre « eh bin, peut-être qu'ils en parlaient, mais moi je n'étais pas
dans ce groupe, et puis de toute façon, même ceux qui savaient n'en
parlaient pas, et puis j'ai raison. » <G>.
| Ce qui veut dire que les implémenteurs des compilateurs en étaient
| probablement au courants, au moins pour la plupart. Ils ont
| effectivement choisi de l'ignorer, de façon à ce que leurs
| utilisateurs aient davantage de problèmes maintenant.
Et David Vandevoorde t'a raconté son expérience personnelle de
l'époque où il travaillait sur le compilateur d'HP. Ils avaient
implémenté la règle en question vers 1997 ; après des tests sur des
programmes, ils avaient décidé de désactiver.
Et comme David le rappelle à chaque fois, cette règle est discutée
dans D&E.
| Pour monsieur tout le monde, évidemment, les templates, c'était ce
| que faisait CFront, étant donné que c'était le seul compilateur qui
| les implémentait. Pendant longtemps, d'ailleurs, ce que faisait
| CFront faisait figure de norme pour les utilisateurs et les autres
| implémenteurs. Jusqu'au point d'en dupliquer les bugs. Même
| aujourd'hui, certains compilateurs conforme (exprès) plus à ce que
| faisait CFront qu'à la norme.
| > Certaines personnes (avec le complice de certains compilateurs)
| > essayeront de te faire croire que c'est pas vrai.
| Tu peux montrer qui, et où ?
Ben lis tes deux messages, je n'ai pas besoin d'aller chercher plus
loin. Ou fais un google pour tes messages dans ce groupe où toi et moi
en avons discuté, ou dans comp.lang.c++.moderated ou comp.std.c++ où
David Vandevoorde était intervenu.
writes:
| Gabriel Dos Reis wrote in message
| news:...
| > Dimitri Papadopoulos-Orfanos
| > writes:
| > | réécrire des centaines de classes. Chose que je ne peux pas
| > | faire. Je pense que genre de changements met en cause la
| > | pertinence du C++ pour l'écriture de gros projets destinés à
| > | vivre plusieurs années.
| > Ces règles n'ont pas été inventées hier.
| Qu'importe quand elles ont été inventées.
Cela importe parce que l'histoire de cette règle fait partie de la
confusion et de ses conséquences.
| Elles ne sont pas particulièrement intuitives.
« intuitives » est une question d'opinion, et non une vérité. Je ne me
fierais pas à ton intuition -- je me méfies déjà de la mienne.
| Surtout, elles représentent un changement par rapport à ce que les
| compilateurs faisaient jusqu'il y a peu.
On a eu ce débat plusieurs fois. À chaque fois, tu répètes les mêmes
choses et à chaque fois tu dois te faire corriger. Par moi, ou par
David Vendevoorde. Je ne désespère pas qu'un jour cela va rentrer.
Les compilateurs ont choisi d'ignorer la règle, cela ne veut pas dit
qu'elle date d'hier.
Je t'ai déjà donné des références publiques remontant au moins à 1992,
qui montrent que la notion de recherche en deux phases étaient
considérées bien avant qu'on ait eu les aspects les plus avancés des
templates.
| > Elles datent du temps même de la conception des templates.
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
| implémentées dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
L'implémentation qui était livrée avec CFront ne contient pas tout ce
que le concepteur des templates envisageait.
| La situation est complexe. L'idée d'utiliser une recherche à deux
| temps est apparue assez vite (2-3 ans ?) après les premières
| implémentations des templates, et bien avant la plupart des
| implémentations.
Tu doutes que je travaille pour celui qui a conçu les templates, que
je travaille tous les jours sur les templates avec celui qui les a
conçus et qu'on discute quotidiennement des points techniques,
non-techniques et de son histoire ; et donc que j'ai accès à
l'information de première main que les allégations très approximatives
que racontes ?
| Je crois que l'intention d'imposer une recherche à deux temps est
| apparue assez tôt dans le groupe de travail qui s'occupait des
| templates dans le comité de normalisation.
Tu racontes cela comme si tu y étais,
alors même que tu ne savais pas que cela existait jusqu'à ce que je te
montre le papier en question et que tu me répondes quelque chose du
genre « eh bin, peut-être qu'ils en parlaient, mais moi je n'étais pas
dans ce groupe, et puis de toute façon, même ceux qui savaient n'en
parlaient pas, et puis j'ai raison. » <G>.
| Ce qui veut dire que les implémenteurs des compilateurs en étaient
| probablement au courants, au moins pour la plupart. Ils ont
| effectivement choisi de l'ignorer, de façon à ce que leurs
| utilisateurs aient davantage de problèmes maintenant.
Et David Vandevoorde t'a raconté son expérience personnelle de
l'époque où il travaillait sur le compilateur d'HP. Ils avaient
implémenté la règle en question vers 1997 ; après des tests sur des
programmes, ils avaient décidé de désactiver.
Et comme David le rappelle à chaque fois, cette règle est discutée
dans D&E.
| Pour monsieur tout le monde, évidemment, les templates, c'était ce
| que faisait CFront, étant donné que c'était le seul compilateur qui
| les implémentait. Pendant longtemps, d'ailleurs, ce que faisait
| CFront faisait figure de norme pour les utilisateurs et les autres
| implémenteurs. Jusqu'au point d'en dupliquer les bugs. Même
| aujourd'hui, certains compilateurs conforme (exprès) plus à ce que
| faisait CFront qu'à la norme.
| > Certaines personnes (avec le complice de certains compilateurs)
| > essayeront de te faire croire que c'est pas vrai.
| Tu peux montrer qui, et où ?
Ben lis tes deux messages, je n'ai pas besoin d'aller chercher plus
loin. Ou fais un google pour tes messages dans ce groupe où toi et moi
en avons discuté, ou dans comp.lang.c++.moderated ou comp.std.c++ où
David Vandevoorde était intervenu.
Gabriel Dos Reis wrote:
[ ... a propos des regles templates a deux phases ... ]| > Elles datent du temps même de la conception des templates.
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
| implémentées dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
[...]
Gabriel a raison, mais peut-etre que James le sait puisque c'est aussi
decrit dans D&E (p. 339). Plus specifiquement, Object Design (ODI)
avait implemente en 1989 les "class templates" dans leurs copie de
Cfront 2.x (ils avaient une licence pour la source). Ils ont ensuite
donne cette implementation a USL qui y ajoute les "function templates"
sous la direction de Stan Lippman (maintenant a Microsoft). Ca c'etait
Cfront 3.0 (Septembre 1991), mais en pratique cette version ne
marchait pas. John Spicer (maintenant mon collegue a EDG) a ensuite
pris la place de Stan Lippman pour produire Cfront 3.0.1 qui etait au
moins utilisable (mais pas vraiment super-solide non plus).
Gabriel Dos Reis <gdr@cs.tamu.edu> wrote:
[ ... a propos des regles templates a deux phases ... ]
| > Elles datent du temps même de la conception des templates.
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
| implémentées dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
[...]
Gabriel a raison, mais peut-etre que James le sait puisque c'est aussi
decrit dans D&E (p. 339). Plus specifiquement, Object Design (ODI)
avait implemente en 1989 les "class templates" dans leurs copie de
Cfront 2.x (ils avaient une licence pour la source). Ils ont ensuite
donne cette implementation a USL qui y ajoute les "function templates"
sous la direction de Stan Lippman (maintenant a Microsoft). Ca c'etait
Cfront 3.0 (Septembre 1991), mais en pratique cette version ne
marchait pas. John Spicer (maintenant mon collegue a EDG) a ensuite
pris la place de Stan Lippman pour produire Cfront 3.0.1 qui etait au
moins utilisable (mais pas vraiment super-solide non plus).
Gabriel Dos Reis wrote:
[ ... a propos des regles templates a deux phases ... ]| > Elles datent du temps même de la conception des templates.
| Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
| implémentées dans CFront 3.0 ? N'exagérons rien.
Ce que tu ne sais pas, c'est que les templates dans CFront ne sont pas
implémentés par son concepteur, ni par le « maintainer officiel. »
Mais par un utilisateur C++ qui avait lu certaines descriptions.
[...]
Gabriel a raison, mais peut-etre que James le sait puisque c'est aussi
decrit dans D&E (p. 339). Plus specifiquement, Object Design (ODI)
avait implemente en 1989 les "class templates" dans leurs copie de
Cfront 2.x (ils avaient une licence pour la source). Ils ont ensuite
donne cette implementation a USL qui y ajoute les "function templates"
sous la direction de Stan Lippman (maintenant a Microsoft). Ca c'etait
Cfront 3.0 (Septembre 1991), mais en pratique cette version ne
marchait pas. John Spicer (maintenant mon collegue a EDG) a ensuite
pris la place de Stan Lippman pour produire Cfront 3.0.1 qui etait au
moins utilisable (mais pas vraiment super-solide non plus).
wroteGabriel Dos Reis wrote in message
news:...Dimitri Papadopoulos-Orfanos
writes:
| réécrire des centaines de classes. Chose que je ne peux pas
| faire. Je pense que genre de changements met en cause la
| pertinence du C++ pour l'écriture de gros projets destinés à
| vivre plusieurs années.
Ces règles n'ont pas été inventées hier.
[...]Elles datent du temps même de la conception des templates.
Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
implémentées dans CFront 3.0 ? N'exagérons rien.
Elles n'etaient certainement pas implementees dans Cfront 3.0, mais
l'ARM en fait ne parle pas du probleme du tout.
Le fait que l'ARM a une grammaire pour les templates me fait
soupconner qu'en fait l'intention etait que les templates soit
"parsees" dans leur formes generiques, et donc des regles differentes
de celles de Cfront etaient envisagees.
(Trivia: Cfront 3.0 etait une version essentiellement inutilisable du
au grand nombre de bogues.
La version 3.0.1 corrigait les problemes les plus grossiers, et fut le
premier compilo a vraiment permettre l'exploration des templates.
Neanmoins, de beaucoup de points de vues, l'implementation Cfront des
templates etait un "hack" que la plupart des implementation
ulterieures etaient forcees d'imiter.)
kanze@gabi-soft.fr wrote
Gabriel Dos Reis <gdr@cs.tamu.edu> wrote in message
news:<m31xgj1dgr.fsf@merlin.cs.tamu.edu>...
Dimitri Papadopoulos-Orfanos <dpo.remove@club-internet.decoy.fr>
writes:
| réécrire des centaines de classes. Chose que je ne peux pas
| faire. Je pense que genre de changements met en cause la
| pertinence du C++ pour l'écriture de gros projets destinés à
| vivre plusieurs années.
Ces règles n'ont pas été inventées hier.
[...]
Elles datent du temps même de la conception des templates.
Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
implémentées dans CFront 3.0 ? N'exagérons rien.
Elles n'etaient certainement pas implementees dans Cfront 3.0, mais
l'ARM en fait ne parle pas du probleme du tout.
Le fait que l'ARM a une grammaire pour les templates me fait
soupconner qu'en fait l'intention etait que les templates soit
"parsees" dans leur formes generiques, et donc des regles differentes
de celles de Cfront etaient envisagees.
(Trivia: Cfront 3.0 etait une version essentiellement inutilisable du
au grand nombre de bogues.
La version 3.0.1 corrigait les problemes les plus grossiers, et fut le
premier compilo a vraiment permettre l'exploration des templates.
Neanmoins, de beaucoup de points de vues, l'implementation Cfront des
templates etait un "hack" que la plupart des implementation
ulterieures etaient forcees d'imiter.)
wroteGabriel Dos Reis wrote in message
news:...Dimitri Papadopoulos-Orfanos
writes:
| réécrire des centaines de classes. Chose que je ne peux pas
| faire. Je pense que genre de changements met en cause la
| pertinence du C++ pour l'écriture de gros projets destinés à
| vivre plusieurs années.
Ces règles n'ont pas été inventées hier.
[...]Elles datent du temps même de la conception des templates.
Tu veux dire comme au temps de l'ARM ? Ou qu'elles étaient
implémentées dans CFront 3.0 ? N'exagérons rien.
Elles n'etaient certainement pas implementees dans Cfront 3.0, mais
l'ARM en fait ne parle pas du probleme du tout.
Le fait que l'ARM a une grammaire pour les templates me fait
soupconner qu'en fait l'intention etait que les templates soit
"parsees" dans leur formes generiques, et donc des regles differentes
de celles de Cfront etaient envisagees.
(Trivia: Cfront 3.0 etait une version essentiellement inutilisable du
au grand nombre de bogues.
La version 3.0.1 corrigait les problemes les plus grossiers, et fut le
premier compilo a vraiment permettre l'exploration des templates.
Neanmoins, de beaucoup de points de vues, l'implementation Cfront des
templates etait un "hack" que la plupart des implementation
ulterieures etaient forcees d'imiter.)
le Friday 17 September 2004 08:47, écrivit :N'empêche que l'idée de base me semble bien -- seulement, je n'aime
pas que ce soit le compilateur (et non moi) qui choisit quels noms
sont dépendants, et quels noms ne le sont pas, d'une façon assez
subtile et non toujours très transparente.
en l'occurence, pour rendre le nom dépendant, on a le choix entre :
template <typename T> struct B : public A<T> {
typedef A<T> base_type; // dependant base
void foo() { base_type::x = 1; }
};
et
template <typename T> struct B : public A<T> {
void foo() { this->x = 1; }
};
, non ?
y-a-t'il des arguments pour préferer l'un ou l'autre ?
(j'aurais tendance à prendre la 2° façon, plus courte et qui ne dit
que ce qu'il faut : il s'agit d'un membre)
le Friday 17 September 2004 08:47, kanze@gabi-soft.fr écrivit :
N'empêche que l'idée de base me semble bien -- seulement, je n'aime
pas que ce soit le compilateur (et non moi) qui choisit quels noms
sont dépendants, et quels noms ne le sont pas, d'une façon assez
subtile et non toujours très transparente.
en l'occurence, pour rendre le nom dépendant, on a le choix entre :
template <typename T> struct B : public A<T> {
typedef A<T> base_type; // dependant base
void foo() { base_type::x = 1; }
};
et
template <typename T> struct B : public A<T> {
void foo() { this->x = 1; }
};
, non ?
y-a-t'il des arguments pour préferer l'un ou l'autre ?
(j'aurais tendance à prendre la 2° façon, plus courte et qui ne dit
que ce qu'il faut : il s'agit d'un membre)
le Friday 17 September 2004 08:47, écrivit :N'empêche que l'idée de base me semble bien -- seulement, je n'aime
pas que ce soit le compilateur (et non moi) qui choisit quels noms
sont dépendants, et quels noms ne le sont pas, d'une façon assez
subtile et non toujours très transparente.
en l'occurence, pour rendre le nom dépendant, on a le choix entre :
template <typename T> struct B : public A<T> {
typedef A<T> base_type; // dependant base
void foo() { base_type::x = 1; }
};
et
template <typename T> struct B : public A<T> {
void foo() { this->x = 1; }
};
, non ?
y-a-t'il des arguments pour préferer l'un ou l'autre ?
(j'aurais tendance à prendre la 2° façon, plus courte et qui ne dit
que ce qu'il faut : il s'agit d'un membre)
L'ARM était en effet assez vague en ce qui concerne les templates.
Personellement, j'ai l'impression d'avoir lu quelque part que les
châpitres sur les templates et sur les exceptions étaient «
expérimentales ». En revanche, je n'arrive pas à trouver où.
L'ARM était en effet assez vague en ce qui concerne les templates.
Personellement, j'ai l'impression d'avoir lu quelque part que les
châpitres sur les templates et sur les exceptions étaient «
expérimentales ». En revanche, je n'arrive pas à trouver où.
L'ARM était en effet assez vague en ce qui concerne les templates.
Personellement, j'ai l'impression d'avoir lu quelque part que les
châpitres sur les templates et sur les exceptions étaient «
expérimentales ». En revanche, je n'arrive pas à trouver où.
Ceux d'entre vous dont le souci premier est d'écrire des programmes
qui marchent auraient dû savoir que « this->f() » marche dans
les deux cas (recherche de noms en deux phases ou non).
Ceux d'entre vous dont le souci premier est d'écrire des programmes
qui marchent auraient dû savoir que « this->f() » marche dans
les deux cas (recherche de noms en deux phases ou non).
Ceux d'entre vous dont le souci premier est d'écrire des programmes
qui marchent auraient dû savoir que « this->f() » marche dans
les deux cas (recherche de noms en deux phases ou non).
L'ARM était en effet assez vague en ce qui concerne les templates.
Personellement, j'ai l'impression d'avoir lu quelque part que les
châpitres sur les templates et sur les exceptions étaient
« expérimentales ». En revanche, je n'arrive pas à trouver où.
Le fait que l'ARM a une grammaire pour les templates me fait
soupconner qu'en fait l'intention etait que les templates soit
"parsees" dans leur formes generiques, et donc des regles differentes
de celles de Cfront etaient envisagees.
Je crois que tout le monde reconnaissait que la solution CFront était un
hack.
Un hack bien utile, évidemment ; ceux de nous qui avaient
implémenté des classes génériques à la base de <generic.h> en attendait
avec impatience.(Trivia: Cfront 3.0 etait une version essentiellement inutilisable du
au grand nombre de bogues.
C'est le cas habituel des vrai .0, malheureusement.
Encore que quand tu
considères ce dont on avait l'habitude à l'époque... (Jusqu'en 94
environ, je comptais deux boggues dans le compilateur pour chaque erreur
dans mon propre code. Avec des compilateurs « stabiles ».)
La version 3.0.1 corrigait les problemes les plus grossiers, et fut le
premier compilo a vraiment permettre l'exploration des templates.
Neanmoins, de beaucoup de points de vues, l'implementation Cfront des
templates etait un "hack" que la plupart des implementation
ulterieures etaient forcees d'imiter.)
Parce que c'était CFront. Le compilateur « officiel ».
C'est intéressant de savoir l'histoire de CFront maintenant. Mais il ne
faut pas oublier qu'à l'époque, c'était le compilateur qui sortait de
AT&T. La référence. Les (ré)vendeurs n'ont certainement pas tiré notre
attention sur le faut que ce n'était plus l'oeuvre de l'équipe Bell
Labs.
L'ARM était en effet assez vague en ce qui concerne les templates.
Personellement, j'ai l'impression d'avoir lu quelque part que les
châpitres sur les templates et sur les exceptions étaient
« expérimentales ». En revanche, je n'arrive pas à trouver où.
Le fait que l'ARM a une grammaire pour les templates me fait
soupconner qu'en fait l'intention etait que les templates soit
"parsees" dans leur formes generiques, et donc des regles differentes
de celles de Cfront etaient envisagees.
Je crois que tout le monde reconnaissait que la solution CFront était un
hack.
Un hack bien utile, évidemment ; ceux de nous qui avaient
implémenté des classes génériques à la base de <generic.h> en attendait
avec impatience.
(Trivia: Cfront 3.0 etait une version essentiellement inutilisable du
au grand nombre de bogues.
C'est le cas habituel des vrai .0, malheureusement.
Encore que quand tu
considères ce dont on avait l'habitude à l'époque... (Jusqu'en 94
environ, je comptais deux boggues dans le compilateur pour chaque erreur
dans mon propre code. Avec des compilateurs « stabiles ».)
La version 3.0.1 corrigait les problemes les plus grossiers, et fut le
premier compilo a vraiment permettre l'exploration des templates.
Neanmoins, de beaucoup de points de vues, l'implementation Cfront des
templates etait un "hack" que la plupart des implementation
ulterieures etaient forcees d'imiter.)
Parce que c'était CFront. Le compilateur « officiel ».
C'est intéressant de savoir l'histoire de CFront maintenant. Mais il ne
faut pas oublier qu'à l'époque, c'était le compilateur qui sortait de
AT&T. La référence. Les (ré)vendeurs n'ont certainement pas tiré notre
attention sur le faut que ce n'était plus l'oeuvre de l'équipe Bell
Labs.
L'ARM était en effet assez vague en ce qui concerne les templates.
Personellement, j'ai l'impression d'avoir lu quelque part que les
châpitres sur les templates et sur les exceptions étaient
« expérimentales ». En revanche, je n'arrive pas à trouver où.
Le fait que l'ARM a une grammaire pour les templates me fait
soupconner qu'en fait l'intention etait que les templates soit
"parsees" dans leur formes generiques, et donc des regles differentes
de celles de Cfront etaient envisagees.
Je crois que tout le monde reconnaissait que la solution CFront était un
hack.
Un hack bien utile, évidemment ; ceux de nous qui avaient
implémenté des classes génériques à la base de <generic.h> en attendait
avec impatience.(Trivia: Cfront 3.0 etait une version essentiellement inutilisable du
au grand nombre de bogues.
C'est le cas habituel des vrai .0, malheureusement.
Encore que quand tu
considères ce dont on avait l'habitude à l'époque... (Jusqu'en 94
environ, je comptais deux boggues dans le compilateur pour chaque erreur
dans mon propre code. Avec des compilateurs « stabiles ».)
La version 3.0.1 corrigait les problemes les plus grossiers, et fut le
premier compilo a vraiment permettre l'exploration des templates.
Neanmoins, de beaucoup de points de vues, l'implementation Cfront des
templates etait un "hack" que la plupart des implementation
ulterieures etaient forcees d'imiter.)
Parce que c'était CFront. Le compilateur « officiel ».
C'est intéressant de savoir l'histoire de CFront maintenant. Mais il ne
faut pas oublier qu'à l'époque, c'était le compilateur qui sortait de
AT&T. La référence. Les (ré)vendeurs n'ont certainement pas tiré notre
attention sur le faut que ce n'était plus l'oeuvre de l'équipe Bell
Labs.
