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

bonjour
pour continuer sur les template et metafonctions, dans le livre de Abrahams, on définit à la page 44 une Metaclass:

Code:

---

1 2 3 4 5 6 7 8 9

struct plus_f{ template<class T1,class T2> struct apply { typedef typename mpl::plus<T1,T2>::type type; };   };

---

comment peut-on accéder à T1 et T2?
comment le type template apply sera instanciée, et avec quelles valeurs de T1 et de T2?

Je vous remercie.

A partir d'où veux-tu accéder à T1 et T2?

Généralement, je suis pour ma part plus tenté par l'écriture :

Code:

---

1 2 3 4 5 6 7 8 9 10

struct plus_f { template<class T1,class T2> struct apply { typedef T1 Type1; typedef T2 Type2; typedef typename mpl::plus<T1,T2>::type type; }; };

---

Ce qui permet de camoufler de façon légère le type passé en paramètre (si besoin, pour une lecture...)...

Pour accéder à l'objet apply tu peux faire :

Code:

---

plus_f::apply<T1, T2> inst;

---

comment est codé mpl::plus ?

Regarde la doc de MPL tu pourras avoir une idée du fonctionnement si tu connais un peu le fonctionnement de base de la méta-prog.

Sans en être certains, mpl::plus va matcher chacun de ces paramètres template avec un type représentant un entier pour pouvoir définir un nouveau type qui représente l'entier égal à la somme de tout les entiers.

Code:

---

1 2 3 4 5 6 7

template<size_t t> struct integral { enum { value = t }; };   template<class A, class B> struct plus { typedef integral<A::value + B::value> result; };

---

(C'est surment un truc du genre mais en beaucoup mieux :aie:)

oui voilà c'est ça! merci
le integral il me semble qu'il est définit via static const int et non enum...ça m'amène une question... qu'est ce que ça change :)?
un exemple complet :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

template<class A,class B, class C> struct DoOp { typedef typename C::template apply<A,B>::type type; };   template <int N> struct int_ { static const int value = N; };   template<class A, class B> struct plus { typedef int_< A::value + B::value> type; };     struct plus_f { template<class T1,class T2> struct apply { typedef typename plus<T1,T2>::type type; }; };   template<class A, class B> struct minus { typedef int_< A::value - B::value> type; };     struct minus_f { template<class T1,class T2> struct apply : minus<T1,T2>{}; //"forwarding" autre technique a priori meilleur };   void main() { std::cout << DoOp< int_<9>, int_<1>, plus_f>::type::value << "\n"; std::cout << DoOp< int_<9>, int_<1>, minus_f>::type::value << "\n"; std::cin.ignore(); }

---

On n'accede jamais ni au parametres passés au appyl ni à appyl lui même.
Le apply n'est qu'un articifce du protocole de meta-fonctions.

Les meta-fonctions acceptents de IntegralConstant qui sont définies comme exposant un ::value et ::value_type dans leur interface. On calcule tout avec ça et on n'a pas a se préoccuper du reste.

Pour enum vs static const, ca remonte au temps ou certain compilo ne compilaient pas static const proprement

Citation:

---

Envoyé par Joel F

On n'accede jamais ni au parametres passés au appyl ni à appyl lui même.

---

Code:

---

1 2 3 4 5 6

template<class A,class B, class C> struct DoOp { typedef typename C::template apply<A,B>::type type; };

---

Un code comme ça ne doit pas exister ?

Citation:

---

Envoyé par guillaume07

Code:

---

1 2 3 4 5 6

template<class A,class B, class C> struct DoOp { typedef typename C::template apply<A,B>::type type; };

---

Un code comme ça ne doit pas exister ?

---

Non, on fait plutot :

Code:

---

1 2 3 4

template<class A,class B> struct DoOp : mpl::apply1<A,B> {};

---

On passe par la lambda abstraction qui gère tout ça.

ok

J'ai du mal a comprendre le code suivant:

Code:

---

1 2 3

template<class A,class B> struct DoOp : mpl::apply1<A,B> {};

---

qu'on va simplier en

Code:

---

1 2 3

template<class A,class B> struct DoOp :apply1<A,B> {};

---

C'est le type template DoOp, qui va hérité du type templaté apply1<A,B>.

Pour une classe ce serait l'équivalent de
class A:public B{}

mais ce qui me gène ici, c'est l'absence du mot clé public.

Merci

Pour une struct l'héritage par défaut est publique, pour une classe c'est private. C'est la différence entre class et struct qui se retrouve aussi au niveau de la visibilité par défaut.