c'est quoi F::template ??

C'est quand apply est une méta-fonction de la classe définie par F.
 
On aurai tendance a écrire F::apply, mais la syntaxe est F::template apply
 
[edit] Il y a une brève explication ici : http://www.boost.org/doc/libs/1_40 [...] order.html
[re edit] Je viens de voir que ton exemple venais justement de la...   Ben, lit un peu plus bas...

c'est à dire métafonction ? tu peux me donner un exmple de code de ce que apply

Une méta-fonction est une fonction qui s'applique sur des types. Par exemple, tu peux définir la méta-fonction AddPointer qui permet de passer du type int a int* comme ça:
 

 
Après dans ton exemple d'avant tu prenais dans tes arguments une méta-fonction et un type sur lequel tu applique ta méta-fonction.
Donc tu l'utiliserai comme ça:
 

 
Et donc la syntaxe veut que quand tu veux appeler une structure au sein d'un type générique F, tu fais F::template apply (avec apply ta structure qui se trouve dans F). Pour accéder au F::apply
 
Pas sur d'être super clair  

nikel merci
 
en faite je me demande à quoi ça sert davoir un truc :
 

 
qui sert in finé à définir un int* , ça ressemble un peu à un marteau pour tuer une mouche

et le Addpointer, je capte pas pourquoi ce nom , ça ajoute des pointeurs ??

Oui, tout a fait cela permet de définir int* a partir de int.  
 
Bah, la tout de suite l'utilité... Ça serai au moment ou l'on a besoin d'une meta-fonction pour definir un pointeur sur le type passé en paramètre.
 
Je conclurai par dire qu'il y a des choses plus intéressante a faire avec de la méta-prog et que ce type de fonction peuvent servir dans l'élaboration des choses intéressante.
 
Et pour le nom, j'ai rien inventé : cela viens de boost : http://www.boost.org/doc/libs/1_40 [...] inter.html

en faite .. ça permets de faire quoi concrétement la méta prog et particulièrement en cpp

Bah, a plein de choses... Si tu prend l'exemple de boost il est en est bourré de méta-prog. Ca permet d'avoir de belle interface comme boost::function, boost::sprit, ... D'automatiser la génération de code...
 
Pour moi, un des grand principe de la méta-prog c'est aussi d'arriver a repousser les erreur du run-time a la compilation. Pour que ça soit ton compilo qui vérifie la cohérence de ton code (par exemple tu peux voir l'analyse dimensionnelle qui est proposée dans les tutoriaux de la MPL)
 
après, j'ai envie de te dire d'attendre l'avis des ténors de la cat'. Je reste quand même un gros débutant, je suis sur qu'ils auront des choses a rajouter sur cette question de l'intéret

Meta-programmer c'est analyser, modifier et generer du code à aprtir de code, et ce à la compilation. En c++, cela passe par le détournement des mécanismes de spécialisations et de résolutions de types et le fait que les templates C++ soit turing-complet et beta-reductibles. C'est une des pierres angulaires de la Programmation Générique ( http://www.generic-programming.org ) qui est une ensemble d'idiome bien plus puissant que le simple OO.

A quoi ça sert, à plein de chose. Et en premier lieu à écrire du code générique, réutilisable au niveau source en garantissant un bon typage, de bonnes performances car la totalité des trucs est résolue à la compilation et osuvent une interface humainement lisible et intuitive. En terme d'usages : le calcul de type complexe, la manipulation de structure à la volée (boost.Fusion), l'introspection de type (boost.traits), les Expressions Tempaltes qui ne sont que meta-prog (boost.proto) etc. En terme d'applications concrètes, je te renvois à ma liste de publications scientifiques
mais en outre grâce à ça, y a des outils de parallélisations automatiques, de générations d'architectures matérielles, d'accès pervasives à des réseaux de capteurs etc.

Et à quoi ca sert AddPointer ? A avoir qqs choses de génériques pour passer de T à T* car si dans le cas général, y a pas d'astuce si T est une référence, T* n'existe pas. Au lieu de devoir prendre  ce cas particulier en compte dans ton code, il te suffit d'utilsier systematiquement add_pointer<T>::type pour etre sur de pas faire de conneries.

Sinon
 
typename F::template foo
 
est la synatxe pour acceder à des types templates interne à des classes.
De la meme maniere que typename aide le compilo à pas se vautrer en lui disant qu'il s'agit d'un type, le ::tempalte lui indique la validité de la syntaxe foo<???> qui va suivre.

d'ac merci