template de template

**deubelte** · 13/09/2010, 00h42

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

J'ai essayé cela:

Code :

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

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 :

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

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

**bacelar** · 13/09/2010, 13h05

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

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

**Goten** · 13/09/2010, 13h48

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é.

**deubelte** · 13/09/2010, 14h20

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

tu peux m'en donner une?

**guillaume07** · 13/09/2010, 17h57

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

Code :

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

1
2
3
4
5
6
7
8
template < template<typename> class X>
class Foo
{
 
};
 
//main
Foo< vector<string> > f;

**Flob90** · 13/09/2010, 18h13

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 :

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

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

)

**Goten** · 13/09/2010, 19h02

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)

**Flob90** · 13/09/2010, 19h15

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 ?

**Goten** · 13/09/2010, 19h29

(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 :

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

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 :

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

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 :

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

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

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

Code :

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

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

**loufoque** · 13/09/2010, 21h06

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.

**guillaume07** · 13/09/2010, 21h11

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 :

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

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 :

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

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 :

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

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

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

Code :

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

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 ?

**guillaume07** · 13/09/2010, 22h35

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

**Flob90** · 13/09/2010, 23h19

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.

**deubelte** · 14/09/2010, 08h57

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!!

**Joel F** · 14/09/2010, 09h43

<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.

**guillaume07** · 14/09/2010, 10h14

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?

**Joel F** · 14/09/2010, 10h35

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

**guillaume07** · 14/09/2010, 12h35

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