template de template

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.