template de template

Bonjour
Je me suis posé la question sur la déclaration de template de template

J'ai essayé cela:

Code:

---

1 2 3 4 5 6

template<template<typename Y> typename X> struct Meta_class { //typedef template<T> type;   };

---

Mais cela me renvoie une erreur: déclaration de paramètre inconnus.


Ensuite j'ai essayé ca:

Code:

---

1 2 3 4 5 6

template<template<typename Y> class X> struct Meta_class { //typedef template<T> type;   };

---

et ca compile. Je voudrais savoir quelle est la différence entre les deux?
Surtout que je pensais que typename et class étaient identiques dans un template.
Merci

Heu, pourquoi obliger un paramètre d'un template à être un template ?

C'est très "border line" comme situation, non ? :aie:

Non, et ça a plus d'une utilité.


template<template<typename> class X>


Est la bonne syntaxe car c'est ce que tu veux (ie une classe template).


template<template<typename> typename X>

n'a aucun sens ici.

Pas la peine de nommer le paramètre template template (Y chez toi), il ne sera jamais utilisé.

Citation:

---

Non, et ça a plus d'une utilité.

---

tu peux m'en donner une?

si tu veux avoir une classe template qui prends une classe template

Code:

---

1 2 3 4 5 6 7 8

template < template<typename> class X> class Foo {   };   //main Foo< vector<string> > f;

---

Utilité : Design à base de classes de politique (cf Loki), et surment pas mal d'outils de méta-prog plus avancé (cf MPL, pas assez d'expérience sur MPL pour donner un exemple plus concret*, Goten devrait pouvoir le faire)

* Cependant je dirais bien pour faire un algo qui créé un nouveau conteneur de type en appliquant une méta-fonction sur tout les éléments d'un autre conteneur. Ca serait donc une méta-fonction qui prend en paramètre un conteneur de type et une autre méta-fonction.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

template< template <class> class F, class List> struct Algo; template< template <class> class F, class OldHead, class OldTail> struct Algo<F, TypeList<OldHead, OldTail> > { typedef typename F<OldHead>::Result NewHead; typedef typename Algo<F, OldTail>::Result NewTail; typedef TypeList<NewHead, NewTail> Result; };   template< template<class> class F> struct<F, NullType> { typedef NullType Result; }

---

Quelque chose de ce gout là (aucune garantie que ca compile :aie:)

Non je pensais bien aux design à base de politiques en effet ;). Pour la MP ça a son utilité aussi mais j'ai pas d'exemple en tête là.
Quant à MPL non car les metafunctions traite avec des types en général et non des classes templates.

L'exemple le plus souvent montré (enfin celui que je vois le plus fréquemment) est de montré qu'ainsi on peut laisser choisir le type de conteneur à l'utilisateur.
Sa reste un mauvais exemple, il vaut mieux passer un range sans se soucier du type sous-jacent. (tant qu'il respecte les concepts)

Oui, en général une méta-fonction prend en paramètre un type et retourne un type. mais si on veut faire ce que j'ai proposé, un algo (dans une méta-fonction), qui applique à un range (dans mon exemple j'a pris une liste, je ne sais pas comment gérer les ranges, je connait pas assez le sujet) une méta-fonction sur tout les éléments, tu es bien obligé de passer une méta-fonction, donc un paramètre template template, ou tu fais autrement ?

(j'avais zappé ton code)
Oui c'est une possibilité mais c'est pas ce qu'ils ont choisi pour la MPL. Les metafunctions prennent des types en paramètres, les "high order" metafunction n'échappent pas à la régle.
Du coup ce genre de chose n'est pas valide :

Code:

---

1 2	typename mpl::transform<vec1, vec2, mpl::plus>::type foo;

---

parce que mpl::plus est une classe template et non un type et que ta metafunction attend un type.
Mais tout problème peut se résoudre en introduisant une couche d'abstraction (tm). On utilise une metafunction class qui à cette gueule :

Code:

---

1 2 3 4 5

struct plus_ { template <class T1, T2> struct apply : mpl::plus<T1,T2> {}; };

---

et voilà on a un type qu'on peut utiliser avec notre high order metafunction :

Code:

---

typename mpl::transform<vec1, vec2, plus_>::type foo;

---

Bon ok ça va vite devenir lourd, heureusement les lambda sont là :

Code:

---

1 2	typename mpl::transform<vec1, vec2, mpl::plus<_1,_2> >::type foo;

---

C'est marrant la question originale, ça montre que dans certains contextes tu as class/typename et d'en d'autres tu as class/struct.

class est donc un mot-clé magique qui veut dire plusieurs choses.

Citation:

---

Envoyé par Goten

(j'avais zappé ton code)
Oui c'est une possibilité mais c'est pas ce qu'ils ont choisi pour la MPL. Les metafunctions prennent des types en paramètres, les "high order" metafunction n'échappent pas à la régle.
Du coup ce genre de chose n'est pas valide :

Code:

---

1 2	typename mpl::transform<vec1, vec2, mpl::plus>::type foo;

---

parce que mpl::plus est une classe template et non un type et que ta metafunction attend un type.
Mais tout problème peut se résoudre en introduisant une couche d'abstraction (tm). On utilise une metafunction class qui à cette gueule :

Code:

---

1 2 3 4 5

struct plus_ { template <class T1, T2> struct apply : mpl::plus<T1,T2> {}; };

---

et voilà on a un type qu'on peut utiliser avec notre high order metafunction :

Code:

---

typename mpl::transform<vec1, vec2, plus_>::type foo;

---

Bon ok ça va vite devenir lourd, heureusement les lambda sont là :

Code:

---

1 2	typename mpl::transform<vec1, vec2, mpl::plus<_1,_2> >::type foo;

---

---

a quoi sert mpl concrètement ? quel genre de problème peut elle résoudre ?

c'est toujours pareil lol, personne n'a assez de recul pour pouvoir fournir une réponse simple et relativement précise

MPL est une bibliothèque de méta-programmation.

La méta-programmation c'est le fait de faire executer une partie du code au compilateur pour alléger la partie des calcul effectuer à l'execution (calcul matriciel par exemple), ou pour générer du code complexe à faire manuellement.

On parlait des classes de politique au début, dans Loki, Alexandrescu utilise quelques éléments de méta-programmation pour générer des hiérarchie de classes basé sur des classes utilisateur dans l'optique d'appliquer certains design pattern : visiteur, multi-methodes. Faire ceci à la main demande beaucoup de travail et en demanderais encore énormément pour peu qu'on effectue une petite modification, alors qu'avec la méta-programmation ca revient à rajouter un élément dans une liste.

MPL permet surment plein d'autre chose, la méta-programmation est un langage à part entière.

C'est marrant que je suis en train d'étudier la MPL.
Je sais pas vraiment a quoi cela va me servir.
J'aimerais bien savoir à quoi cela peut servir dans l'industrie bien sur.

De toute facon, je vois le niveau général moyen de C++, a moins d'avoir a faire à un expert C++, aucune chance que ce soit utilisé. Aucune!!

<semi-troll>
Faut aussi voir le niveau abyssale de la formation en C++ quasiment partout. </semi-troll>

Je passe aussi sur la blague de "a quoi ça sert dans l'industrie" mais bref ...
Ca sert proncipalement à régler des problèmatiques d'interfaces et de généricités au sein des codes en déléguant de manière élégante le choix d'implantations à des tests de propriétés sur les types.

Citation:

---

Envoyé par Joel F

<semi-troll>
Faut aussi voir le niveau abyssale de la formation en C++ quasiment partout. </semi-troll>

Je passe aussi sur la blague de "a quoi ça sert dans l'industrie" mais bref ...
Ca sert proncipalement à régler des problèmatiques d'interfaces et de généricités au sein des codes en déléguant de manière élégante le choix d'implantations à des tests de propriétés sur les types.

---

Tu pourrais préciser ce que tu entends par interface ici stp?

EN TRES Raccourcie on peut dire que ça revient à faire :

si type = char alors faire ceci sinon faire cela?

oui mais avec des trucs plus utiles genre:

si j'ai un constructeur trivial, faire ceci,
sinon si j'accepte l'appel de la methode foo() faire cela
sinon appeler make_foo()

Enormement de propriétés des types sont testables en C++ au niveau meta et permettent d'optimiser du code via ce genre d'astuce

Citation:

---

Envoyé par Joel F

oui mais avec des trucs plus utiles genre:

si j'ai un constructeur trivial, faire ceci,
sinon si j'accepte l'appel de la methode foo() faire cela
sinon appeler make_foo()

Enormement de propriétés des types sont testables en C++ au niveau meta et permettent d'optimiser du code via ce genre d'astuce

---

ok cool merci

Citation:

---

Envoyé par guillaume07

c'est toujours pareil lol, personne n'a assez de recul pour pouvoir fournir une réponse simple et relativement précise

---

Ou peut être qu'on passe pas notre temps à F5 sur le forum.

Citation:

---

Envoyé par Goten

Ou peut être qu'on passe pas notre temps à F5 sur le forum.

---

oui ça rentre en jeux aussi effectivement