Discussion :

[oodini]

Rebonjour !

J'ai ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
template <class TA, class TB, class TC, template <class, class, class, template <class UA, class UB> class TD> class TDerived>
class IInterface
{
    ...
};

Quand, dans l'implémentation de ma classe, je veux utiliser TDerived, il m'est demandé par le compilateur de donner les types dont il dépend pour qu'il puisse instancier TDerived.

Je me retrouve donc à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
template <class TA, class TB, class TC, template <class, class, class, template <class UA, class UB> class TD> class TDerived>
class IInterface
{
    void maFonction(TDerived<TA, TB, TC, TD<UA, UB> >& foo);
};

Mais Visual me dit qu'il ne connaît pas TD...

[oodini]

Bon, j'ai une mauvaise nouvelle : les template template template ne sont pas autorisés en C++.

C'est fâcheux : on ne peut pas faire de CRTP dont la classe enfant a un paramètre template template.

Pour ceux que le sujet intéresse, un lien vers Stackoverlow.

[Emmanuel Deloget]

Bon, j'ai une mauvaise nouvelle : les template template template ne sont pas autorisés en C++.

C'est fâcheux : on ne peut pas faire de CRTP dont la classe enfant a un paramètre template template.

Pour ceux que le sujet intéresse, un lien vers Stackoverlow.

Que ce soit une "mauvaise" nouvelle, je ne sais pas ; par contre, que ce que tu essaies de faire soit un peu trop complexe, là, oui, je suis d'accord

Une solution simple pour contourner ton problème est de passer par des classes de traits.

En gros, tu as :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
template <class TD>
struct some_traits
{
  template <class UA, class UB>
  class final_type
  {
    ...
  };
};
 
template <class TA, class TB, class TC, template <class, class, class, class TD> class TDerived>
class IInterface
{
    typedef some_traits<TD> traits_type;
 
    template <class UA, class UB>
    void maFonction(TDerived<TA, TB, TC, typename traits_type::final_type<UA,UB> > >& foo);
};

(il y a peut-être un mot-clef template qui manque quelque part, je n'ai pas testé).

Mais franchement, ça commence à devenir sérieusement compliqué. Il doit y avoir une architecture plus simple pour ce que tu souhaites faire (après tout, la librairie standard est elle-même très compliquée et pourtant n'a pas de besoin de template de template de templates).

[gb_68]

Bonjour,
quel est le vrai but ? passer un template déjà entièrement spécialisé ou un template avec ses paramètres ouverts ? Dans le premier cas, il est possible de déclarer template qui accepte un type "fini" puis de ne spécifier que ses spécialisations partielles voulues (faire du pattern matching).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<typename U>
struct TTest;
 
template<typename T1, typename T2, typename T3, template<typename, typename, typename> class T>
struct TTest< T<T1, T2, T3> >
{ /*...*/ }; // et l'on a accès à T1, T2, T3 
 
template<typename T1, typename T2, typename T3, template<typename, typename, typename> class T>
struct TTest_Bad
{ /*...*/ };
 
TTest<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > test1; // ok
TTest<std::string> test2; // ok aussi et un peu plus lisible
 
TTest_Bad<char, std::char_traits<char>, std::allocator<char>, std::basic_string> testbad; // seule écriture possible

Et avec le pattern matching, l'on peut aller très loin (mais il vaut mieux effectivement recourir à des traits, comme l'a proposé Emmanuel Deloget, avant d'aboutir à des usines à gaz ).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
template<typename U>
struct TTest_2;
 
template< typename T1, typename T2, typename T3
        , template<typename> class Traits
        , template<typename> class Alloc
        , template<typename, typename, typename> class T>
struct TTest_2< T<T1, Traits<T2>, Alloc<T3> > >
{ /* ... */ };
 
TTest_2<std::string> test_2;

[koala01]

Salut,

Mais franchement, ça commence à devenir sérieusement compliqué. Il doit y avoir une architecture plus simple pour ce que tu souhaites faire (après tout, la librairie standard est elle-même très compliquée et pourtant n'a pas de besoin de template de template de templates).

+1

C'est peut etre le moment de se rappeler le bon vieil adage de

all problems in computer science can be solved by another level of indirection .

[oodini]

Bon, désolé pour le délai de réponse. Je n'ai pas le temps de fréquenter pas le forum autant que je le voudrais.

J'allais partir sur les traits, mais le besoin fonctionnel a finalement disparu, ce qui fait que j'ai dû lâcher le code en question.

Mais je suis sûr que vos dernières réponses me serviront un jour.

Merci à tous !

[ternel]

Tant mieux pour toi si le besoin a disparu, avec un tel sac de nœuds…