Hi,
 
On ne peut pas passer un functor comme paramètre template?
 

 
Merci.

si sauf que ton ap^pel est faux :
 
 

 
Sidenote : les functor c'est so 1990, le hype c'ets les Polymorphic Function Object

Polymorhpic (...) je connaissais pas , merci

 
c'est quoi la différence en deux mots, y a beaucoup à lire et je me sens pas le courage today

un PFO est un foncteur qui supporte le protocole result_of. Il prend des arguments template et sait seul calculer le type de retour afferent.
 
On peut soit appeller un PFO comme un foncteur en l'instanciant et utilsiant son operator() soit utiliser la meta-fonctionr esult_of pr rensigner son type de retour.
 

merde je comprends rien à ton code lol

ça sert à koi ce bout de code :
 

 
Le This(T) surtout

non en faite c'est le Addpointer qu'est ce qu'il vient foutre ici

la structure interne result permet de supporté le protocole result_of :
http://www.boost.org/doc/libs/1_37 [...] #result_of

Il prend un type fonction pr transferer les information pr calculer le type de retour du foncteur. Maintenant ... quel est el type de &t ou T est de type T ???
T* et devine ce que add_pointer<T>::type peut bien renvoyait ...

ça compile pas chez moi, d'une le compilo gueule parcequ'il faut mettre typedef typename devant boost::addpointer et le  take_adress(T)
 

 
renvoit : error C2275: 'T' : utilisation non conforme de ce type comme expression
 
 
Normal ?

t'as quoi comme compilateur antediluvien, VC6 ?  
t'as bien boost d'installer ?

oui j'ai boost d'installer, qui marhe correctement, et j'utilise visual 2008 express

ce qui me surprends aussi,c'est que le type de retour typename result<take_adress(T)>::type de la fonction operator() utilise cette fonction avant même qu'elle soit défini, je pensais pas que ça pouvais marcher!

et puis à quoi cela sert d'utiliser result<take_adress(T)> plutot que simplement result<T> étant donné que boost::ad_pointer ne prend que T ??

Y a qu'une fonction : operator(), result c'ets une meta-fonction.
t'as lu les liens du dessus ou pas ?  

bon  oui je vais lire un peu plus "profondément" , mais  je capte toujours pas pourquoi est ce que le compilo ne veut pas du code. En etnête je mets ça  
 
#include <boost/utility.hpp>
#include  <boost/type_traits/add_pointer.hpp>

address pas adress

oui erreur de frappe sur le forum

a non ! lol :$

merci

Je crois que ce qui déroute, c'est la syntaxe result<take_adress(T)>

passage d'un type fonction en parametre template
toto(titi) = fonction renvoyant un type toto et prenant en argument un type titi.
 
C'ets une expression de type valide en C++, on s'en sert donc comme parametre template pr faciliter l'extraction d'information de type composés.

mais y a un soucis aussi  
 

vu que &t est const et que le type de retour est non const

ouais peut etre, mais bon, pas dur de completer pour que ça marche à titre d'exercice

une autre chose que je comprends pas:
 
 

 
Pourquoi est ce que a un endroit du code on utilise take_adress()() et un à autre take_adresse() ?

également :
 
dans cette partie là du code :
 

 
quel est le véritable paaramètre passé à result :
 
- take_adress(T)
ou  
- &t  
 
?

 
le premeir on construit un objet take_address et on appelle son operateur()
le deuxieme on construit un type fonction renvoyant un take_address.
 

- take_adress(T)  
 
result calcul un type et non une valeur

 
Avec cette syntaxe là, take_address(T), on appel donc pas l'opérateur() ?

non on construit un type qui est :
"fonction prenant un argument de Type T et renvoyant take_address"
il n'ets la que pour transporter les infos sur le lieu d'evaluation du type de result

donc take_adress(T) est équivalent à "take_adress f(T)" , sauf que l'on ne donne pas de nom à la fonction ?

oui et non, ce qui nous interesse c'ets juste son type

que veux donc tu dires par,
 
 
"fonction prenant un argument de Type T et renvoyant take_address"

bah c'ets le type de take_address(T)

, j'arrive pas avec ce code à compredre le pourquoi du comment , ça me rend ouf
 
ce qui m'échappe c'est qu'au final on aurait écrit :
 

 
ça serait revenu au meme non?... et c'est en l'écrivant que je m'apperçois que non, y a effectivement un soucy avec le result_of<int>

oui, t'as pas lu la doc que je t'ai passer.
Ensuite, un protocole on le suit sinon ca sert à rien

oui mais j'ai rien capté à la doc :

The class template result_of helps determine the type of a call expression. Given an lvalue f of type F and lvalues t1, t2, ..., tN of types T1, T2, ..., TN, respectively, the type result_of<F(T1, T2, ..., TN)>::type defines the result type of the expression f(t1, t2, ...,tN). The implementation permits the type F to be a function pointer, function reference, member function pointer, or class type. When F is a class type with a member type result_type, result_of<F(T1, T2, ..., TN)> is F::result_type. Otherwise, result_of<F(T1, T2, ..., TN)> is F::result<F(T1, T2, ..., TN)>::type when N > 0 or void when N = 0. For additional information about result_of, see the C++ Library Technical Report, N1836, or, for motivation and design rationale, the result_of proposal.

comment est ce  que l'expression f(t1, t2, ...,tN) peut avoir un type???

c'est un appel de fonction, son result_type est son type de retour qui depend polymorphqiuement des types de ces entrées. Point y a rien de sorcier, c'est les trucs de bases sur le typage des fonctions.

bah rien de sorcier rien de sorcier elle est bien bonne celle là!
le type que retourne une fonction, à ce que je saches   , n'est pas fonction de ses entrées....

 
Le C++ ne supporte pas la surcharge uniquement sur le type de retour des fonctions.  Donc quand tu as le nom et le type des paramètres, tu as le type de retour (sauf s'il y a une ambiguité).