Classe imbriquee et deductabilite

"Jean-Marc Bourguet" <jm@bourguet.org> a écrit dans le message de news:
pxbr7yw94zl.fsf@news.bourguet.org...

Si j'ai bonne memoire, il vaut mieux ne pas definir des classes
imbriquees dans des classes templates pour des problemes de
deductabilites.

Quelqu'un aurait il un exemple sous la main ou le probleme se pose?

J'ai déjà utilisé des classes imbriquées dans des templates sans problèmes,
peut-être que le problème que tu soulignes vient du fait que parfois une
telle classe imbriquée est superflue lorsqu'une classe externe peut faire le
même boulot pour toutes les instances de cette classe template ? Sinon, je
n'ai pas d'exemples avec des problèmes dans cette situation.

"Thomas Parle" <concombre.masque@legume.net> writes:

"Jean-Marc Bourguet" <jm@bourguet.org> a écrit dans le message de news:
pxbr7yw94zl.fsf@news.bourguet.org...

Si j'ai bonne memoire, il vaut mieux ne pas definir des classes
imbriquees dans des classes templates pour des problemes de
deductabilites.

Quelqu'un aurait il un exemple sous la main ou le probleme se pose?

J'ai déjà utilisé des classes imbriquées dans des templates sans
problèmes, peut-être que le problème que tu soulignes vient du fait
que parfois une telle classe imbriquée est superflue lorsqu'une
classe externe peut faire le même boulot pour toutes les instances
de cette classe template ?

Non, ce n'est pas ca. Le probleme dont je me souviens est que les
regles ne permettaient pas la deduction du type d'un argument d'une
fonction template quand ce type etait une classe imbriquee d'une
classe template. Mais je ne me souviens plus des details.

J'ai retrouve une vague reference dans Google Dans
m3d6kqiql7.fsf@uniton.integrable-solutions.net Gaby disait entre
autres:

C'est une vieille disussion : si conteneur<type>::iterator est
réellement une classe imbriquée alors souvent type sera dans un
contexte non déductible. James en avait fait l'expérience, je crois.

C'est des exemples de contextes que je voudrais.

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:

| > C'est une vieille disussion : si conteneur<type>::iterator est
| > réellement une classe imbriquée alors souvent type sera dans un
| > contexte non déductible. James en avait fait l'expérience, je crois.
|
| C'est des exemples de contextes que je voudrais.

Cela arrive quand les gens veulent écrire des fonctions templates,
en exprimant la contrainte que la classe est vraiment imbriquée dans
une certaine classe donnée, par exemple ils veulent que leurs
fonctions opèrent sur un vector<T>::iterator et pas sur un
list<T>::iterator. Alors, typiquement ils vont exprimer la contrainte
comme cela ; évidemment cela ne marche pas.

template<class T>
struct vector {
struct iterator { /* ... */ };
// ...
};

template<class T>
struct list {
struct iterator { /* ... */ };
// ...
};

template<class T>
void sort(typename vector<T>::iterator f, typename vector<T>::iterator l);


Ou, cela peut être aussi des contraintes sur le T, i.e. distinguer un
T* d'un U...


En général, j'utilise quand même les classes imbriquées dans les
templates. J'exprime les contraintes différemment -- et cela demande
un peu plus de travail mais on peut vivrte avec.

-- Gaby

Alors, typiquement ils vont exprimer la contrainte
comme cela ; évidemment cela ne marche pas.

template<class T>
struct vector {
struct iterator { /* ... */ };
// ...
};

template<class T>
struct list {
struct iterator { /* ... */ };
// ...
};

template<class T>
void sort(typename vector<T>::iterator f, typename vector<T>::iterator
l);

Pourquoi est ce que cela ne marche évidemment pas ?

--
Vincent

[ je ne me souviens pas avoir répondu à cette question. ]

"Vincent Lascaux" <nospam@nospam.org> writes:

| > Alors, typiquement ils vont exprimer la contrainte
| > comme cela ; évidemment cela ne marche pas.
| >
| > template<class T>
| > struct vector {
| > struct iterator { /* ... */ };
| > // ...
| > };
| >
| > template<class T>
| > struct list {
| > struct iterator { /* ... */ };
| > // ...
| > };
| >
| > template<class T>
| > void sort(typename vector<T>::iterator f, typename vector<T>::iterator
| l);
|
| Pourquoi est ce que cela ne marche évidemment pas ?

parce que le paramètre de générique « T » apparaît dans un contexte
non déductible (vector<T>::iterator).

-- Gaby