Reprise du message précédent :

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

ah ok, mais quelle fonction du C++ permet de nous l'indiquer ? je comprends bien que effectivment le compilateur sait de quelle fonction il s'agit mais dans le code source, comment peut-on faire ça ?

en utilisant le protocole result_of ...

ok lol

 
Comment faire quoi à partir de quelles données?

être en mesure de pouvoir identifier le type de retour d'une fonction, en fonction de ses paramatères, à priori  c'est de ça qu'il est question avec result_of

result_of te permet de savoir quel est le type du résultat de l'application de l'opérateur () avec des paramètres de type donné à des valeurs d'un type donné.  C'est principalement utile quand ce type est un paramètre template et déduit automatiquement.
 
Si ce type est un type appelable "de base" (fonction, pointeur sur fonction, pointeur sur fonction membre), result_of fonctionne tout seul.  Si ce type est une classe avec un opérateur (), il faut que cette classe respecte des conventions (ce que Joel appelle un protocole); celles-ci sont nécessaires car il peut y avoir plusieurs opérateurs () et les techniques de méta-programmation ne permettent pas d'effectuer la résolution de surcharge, on déplace le problème en demandant à celui qui écrit la classe de résoudre le problème tout seul.

présenté comme ça, ça passe tout seul, merci beaucoup

Et j'oubliais une des subtilites de result_of:  le type qu'on passe a result_of n'est pas le type sur lequel on applique l'operateur (), mais un type fonction retournant ce type la et prenant les parametres passes.  C'est un type un artificiel dont l'interet principal est qu'il permet de se passe de type lists.
 
Donc si tu cherches a savoir quel est le type resultat de l'operateur() avec un float applique a un pointeur sur fonction prenant un double et retournant un double en utilisant result_of, tu utilises

a part que personne ne le fait sans passer par un typedef:

ou meme deux:

Et dans quel contexte infiné à t-on besoin de recourir à result_of, ou autrement dit, de pouvoir déterminer le type retourné par l'operateur () ?

dans le cas où l'on a un foncteur templaté donc, c'est ça ?

 
Principalement quand tu ecris un template et que le type appelable est un parametre template.

et que l'on a besoin de connaitre son type de retour ?,c'est précisement ça:

dans le cas où l'on a un paramètre template qui est une fonction ou un pointeur sur fonction, et que l'on doit pouvoir déterminer le type de retour de la fonction ou du pointeur sur fonction appelée en interne, car cela peut être fonction de ses paramètres ?

bon oui ok rien de sorcier effectivment mais bon y a t-il un rappport entre le titre du sujet et le code avec le result_of je suis pas sur car au final le result_of ne prends pas un foncteur

Il prend un foncteur et la liste des types des parametres que tu veux lui passer le tout encode comme une fonction retournant ce foncteur.

dans le fichier result_of y a cette syntaxe :
 
template<typename F, typename FArgs>
struct result_of_nested_result : F::template result<FArgs>
{};
 
 
c'est quoi le : F::template result<FArgs> ????
 
Normalement pour l'héritage on spécifiie public,private etc

F::result est un nom dépendant d'un paramètre template.  Pour signifier qu'il est lui-même un template, il faut le template.  L'héritage suit ici son mode de protection par défaut, public puisque c'est défini comme struct.

c'est étonnant d'ailleurs car dans ce fichier result_of est  définit uniquement de cette sorte template<typename F> struct result_of;
 
ça serait intéréssant de savoir de quelle manière le compilo fait le lien avec les différents result_of_impl

@Programmeur: où vois-tu dans le fichier d'implémentation de result_of que result_of prend un foncteur?

 
Par spécialisation partielle sur des traits de F

pourtant dans le fichier result_of, la seule implémentation de result_of est celle que que j'ai mentionnée au dessus, donc quand on fait boost::result_of<T> ça appel quoi ???

y a pas de spécialisation partielle définit sur result_of, du moins pas directement, il n'y a que des spécialisations partielles sur la classe nommée: result_of_impl

comme indiqué dans le fichier, les surcharges de result_of appelant result_of_impl sont générées par une itération verticale du fichier detail/result_of_iterate

ok!  

 
FInalement je n'ai pas compris ce message, surtout la phrase  
 
Donc si tu cherches a savoir quel est le type resultat de l'operateur() avec un float applique a un pointeur sur fonction prenant un double et retournant un double
 
le type resultat de l'operateur() avec un float : C'est à dire avec un float?

ci-dessous un bout de code qui illustre bien l'intêrét, en pratique, de result_of :