result_of et functor

Version imprimable

Bonjour,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include <functional> 
 
struct Func{
 
	bool operator () () const
	{
		return true;
	}
};
 
int main()
{ 	  	 
	static_assert( std::is_void< std::result_of<Func()>::type >::value == true , "bad" ); //assertion valide
 
	system("pause");
}

Pourquoi result_of<Func()> est évalué comme étant de type void ?
quand on pase Func(), le compilo comprend quoi ?

Merci

22/12/2010, 22h21
Joel F

Par définition result_of<F()> est void quelque soit F
22/12/2010, 22h44
guillaume07

Citation:

Envoyé par Joel F

Par définition result_of<F()> est void quelque soit F

ça représente quoi <F()>, je pensais que c'était uen fonction qui renvoyer un F et qui ne prenait aucun arguement, a priori c'est pas le cas vu qu'ici Func est une classe et que ça compile, donc F() represente quoi ?

Bonsoir.

Je pense que tu te mérpends sur le fonctionnement de static_assert :

Citation:

If the value of the expression when so converted is true, the declaration has no effect. Otherwise, the program is ill-formed

(n3126, section 7, paragraphe 4).
Dans notre cas, le programme est invalide (tu recois le message "bad" à la compilation), ce qui signification que l'assertion est fausse, donc le type n'est pas void.

Tu peux le tester en essayant :
Code:

1 2 result_of<Func()>::type b = true;
Qui ne devrait pas poser de problème à la compilation (ca prouve juste que le type bool est convertible en result_of<Func()>::type, donc en particulier que ce n'est pas void).

Pour le fonctionnement, c'est le mecanisme des templates qui permet ceci. Quand le compialteur voit l'expression template :
Code:

1 2 std::result_of<Func()>::type
Il essay d'instancier la classe template std::result_of avec les paramètre qui lui sont donnés. Or la définition de std::result_of est (ou plutôt peut être) :
Code:

1 2 3 4 5 6 7 template<class Fn, class... ArgTypes> struct result_of; template<class Fn, class... ArgTypes> struct result_of<Fn(ArgTypes...)> { typedef decltype(std::declval<Fn>()(std::declval<ArgTypes>()...)) type; };
Il reconnait dans cette définition, un motif avec lequel il peut matcher (faire correspondre) les paramètres. Ce qui permet d'instancier la classe et de récupérer le typedef type.

Ce qui permet de reconnaitre ce motif (car il faut nécessairement que les paramètres templates soit des types (*)), c'est que Fn(ArgTypes...), est le type d'une fonction, même si, quand on l'utilise, ca ne correspond pas à une fonction, on n'utilise juste la syntaxe.

(*) Je simplifie, il y a d'autre possibilité, cf norme ou autre.

23/12/2010, 07h56
guillaume07

Merci pour ta réponse détaillée.
Cependant cette ligne :

Code:

boost::result_of<Func()>::type b = true;

me renvoie

error C2182: 'b'*: utilisation non conforme du type 'void'

sous VS2010 (même erreur si std::result_of )
23/12/2010, 11h04
Joel F

Citation:

Envoyé par guillaume07

ça représente quoi <F()>, je pensais que c'était uen fonction qui renvoyer un F et qui ne prenait aucun arguement, a priori c'est pas le cas vu qu'ici Func est une classe et que ça compile, donc F() represente quoi ?

Regarde ici pour l'explication

http://www.boost.org/doc/libs/1_45_0....htm#result_of

et ici :

http://anubis.dkuug.dk/jtc1/sc22/wg2...003/n1454.html
http://www.open-std.org/jtc1/sc22/wg...2005/n1836.pdf
23/12/2010, 12h33
guillaume07

Merci!
ça m'étonner que ça puisse marcher sans delctype pour les function object en même temps
23/12/2010, 13h01
Flob90

@Joel F: C'est pas sensé retourner le bon type de retour du foncteur d'après les derniers draft de la norme ? (section 20.7.7.6) Parce qu'il me semble bien que c'est sensé être ce que j'ai marqué au dessus, et que dans ce cas le resultat c'est pas void mais bien bool (avec decltype). C'est VS qui est en retard sur ce point ?
23/12/2010, 13h14
Joel F

Citation:

Envoyé par Flob90

@Joel F: C'est pas sensé retourner le bon type de retour du foncteur d'après les derniers draft de la norme ? (section 20.7.7.6) Parce qu'il me semble bien que c'est sensé être ce que j'ai marqué au dessus, et que dans ce cas le resultat c'est pas void mais bien bool (avec decltype). C'est VS qui est en retard sur ce point ?

Peut etre, j'ai pas pensé à regarder le standard. JE pense que VS est peut etre encore sur le draft proposal.

boost::result_of fait de meme anyway
01/01/2011, 13h09
guillaume07
Je n'ai finalement pas compris cet aspect là :
Code:

1 2 3 4 5 6 7 8 9 10 struct F{ }; template<class T> struct B { }; int main() { B<F(int)> f; }
ici, dans l'expresion B<F(int)> f; , le compilateur comprends F(int) comme étant quoi ? une signature de fonction ? pourtant il n' y a aucune fonction de déclarer retourner un F et prenant un int...

EDIT: il est assez malin pour comprendre qu'il s'agit d'un Functor , si oui comment peut il faire la différence avec une signature de contion F myfunc(int param);
01/01/2011, 14h28
Joel F

F(int) ets un type.
c'est le type d'une fonction prenant int en entrée et renvoyant un F.

Cette notation s'appelle la notation round-lambda, elle sert juste a passer en un seul type un liste arbitraire de type. Elle a l'avantage dans le cadre de result_of de *ressembler* a un appel de fonction.
01/01/2011, 14h58
guillaume07

pour autant on ne peut pas isoler dans la classe template, F et ses arguements
tu style
typedef F return_value;
typedef A arg_type;

pour
B<F(A)> b;
01/01/2011, 14h59
Joel F

Citation:

Envoyé par guillaume07

pour autant on ne peut pas isoler dans la classe template, F et ses arguements
tu style
typedef F return_value;
typedef A arg_type;

pour
B<F(A)> b;

Je comprends pas ta question tu n'en a pas besoin...

Admettons la classe suivante

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Foo
{
};
 
template<typename T>
struct Bar
{
//ici on ne peut pas distinguer Foo et int on a juste Foo(int), non??
};
void main()
{
Bar<Foo(int)> b;
}

01/01/2011, 15h06
Joel F

Citation:

Envoyé par guillaume07

Admettons la classe suivante

struct Foo
{
};

template<typename T>
struct Bar
{
//ici on ne peut pas distinguer Foo et int on a juste Foo(int), non??
};
void main()
{
Bar<Foo(int)> b;
}

tu veux faire quoi dans Bar aussi ?
Specialise Bar partiellement pour reconstruire le type F(A) c'est tout.

Je repete, je ne vois pas l'interet de ta question. Que cherche tu a faire.
01/01/2011, 15h10
guillaume07
Non je n'ai rien derrière la tête, j'essaye juste de comprendre comment ça marche, pour le moment. quand tu dis "Specialise Bar partiellement pour reconstruire le type F(A) c'est tout."

tu entends quoi par là finalement :
Code:

1 2 3 4 5 6 template<typename T> struct Bar<Foo(int)> { };
??

... non ...

Code:

1
2
3
4
5
6
template<class Function, class Arg>
struct bar<Function(Arg)>
{
  typedef Function return_type;
  typedef Arg arg0_type;
};

01/01/2011, 15h13
guillaume07

voilà :) c'est exactement ça que je voulais savoir ty

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
template<bool Condition,typename Action,typename P> struct F { };
 
template<typename Action,typename P>
struct F<true, Action(P)> {
	typedef Action execute;
	typedef P param;
};
 
struct Action1{
	bool operator()()const{return true;}
}; 
 
int main() {  
	F<1 , Action1()>::execute();
}

Pourquoi F<1 , Action1()>::execute(); ne compile pas ?
le compilateur visual 2KT m'indique nombre d'argument insuffisant ...

Citation:
Envoyé par guillaume07
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 template<bool Condition,typename Action,typename P> struct F { }; template<typename Action,typename P> struct F<true, Action(P)> { typedef Action execute; typedef P param; }; struct Action1{ bool operator()()const{return true;} }; int main() { F<1 , Action1()>::execute(); }
Pourquoi F<1 , Action1()>::execute(); ne compile pas ?
le compilateur visual 2KT m'indique nombre d'argument insuffisant ...
Action1() ne matche pas Action(P) ...

01/01/2011, 19h09
guillaume07

dans ce cas pourquoi est ce que Action1(void) ne match pas non plus ?
01/01/2011, 19h31
Joel F

f(void) est un synonime de f(), void n'est jamais passé comme type dans ce cas

en passant un int j'ai le même message du compilo, pourtant j'ai l'impression que le matching est nickel

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
template<bool f,typename Action,typename P> struct F{ };
 
template<typename Func,typename Arg>
struct F<true,Func(Arg)>
{
	typedef Func exec;
	typedef Arg param;
};
 
struct Action{
	bool operator()(int){return true;}
};
 
 
int main() 
{  
	F<1, Action(int)> f;
 
	system("pause");
}

01/01/2011, 20h42
Joel F

ta definition est fausse. Ceci compile :

http://codepad.org/EQjE3b0S

tu melanges le nbr de parametres template de ta classe et le nombre de type pour les définir
01/01/2011, 20h49
guillaume07

ah ok je pensais pas qu'on pouvait modifier le nombre ou type de paramètre d'une classe template, là on passe de bool+typename à typename+typename c'est assez déroutant
01/01/2011, 21h12
Joel F

non, c'est une specialisation partielle, tu definie ce qui te faut pour specialiser
02/01/2011, 00h06
Alp
L'endroit que tu dois regarder pour les paramètres de ta classe, c'est "struct F<true, Func(Arg)>", pas "template" au-dessus.

Ce que tu mets après "template" c'est "bon, je vais avoir besoin de ces choses là", pas "je vais donner ces choses là en paramètre de ma classe telles quelles".

C'est un peu comme pour ça :
Code:

1 2 3 template < template <class> class Container, class Element> void f(const Container<Element>& c)
T'as qu'un argument dans ta fonction, mais t'as deux paramètres qui rentrent en jeu.

Quand tu spéciales partiellement de manière non triviale, t'introduis souvent d'autres genres de paramètres, mais ce ne sont pas forcément ceux que tu passeras tels quels à ta classe.
02/01/2011, 00h41
guillaume07

OK, y a pas de bons liens qui traînent sur le net qui traitent de ce sujet ? je trouve rien d'extra via notre ami google
02/01/2011, 00h48
Flob90

http://cpp.developpez.com/cours/cpp/?page=page_14#LXIV

Ca devrait suffire à comprendre la spécialisation des templates.
02/01/2011, 01h10
guillaume07

la limite de ton lien c'est qu'il n' y a pas d'exemple où le nombre de paramètre de la classe spécialisé apparaissant à droite du nom de la classe est inférieur aux nombres de paramètres figurant dans la déclaration de la classe template non spécialisée...

c'est finalement précisément cette règle que je découvre ici
02/01/2011, 01h17
Flob90

Citation:

On notera que le nombre des paramètres template déclarés à la suite du mot clé template peut varier, mais que le nombre de valeurs fournies pour la spécialisation est toujours constant (dans l'exemple précédent, il y en a trois).

Les exemple sont fait dans l'auter sens, mais ca marche dans les deux, il n'y a rien de compliquer la-dedans, ou alors précise ce que tu veux savoir, parce que là je vois pas !

Le cas que tu veux arrive dès que tu auras un type composé d'autre type, ou du même grene. (Comme les types des fonctions ou les types d'un tableau C-like)
02/01/2011, 01h30
guillaume07
ok j'ai "buggé" mon dernier post est faux, justement le nombre match toujours....
Code:

1 2 template< bool Action,typename P> struct F{ }; // =2
Code:

1 2 struct F<true,Func(Arg)> //=2
autant pour moi
02/01/2011, 01h55
guillaume07
Citation:
Envoyé par guillaume07

ok j'ai "buggé" mon dernier post est faux, justement le nombre match toujours....

Code:

1 2 template< bool Action,typename P> struct F{ }; // =2

Code:

1 2 struct F<true,Func(Arg)> //=2

autant pour moi
@Flob90 : ce que tu m'avais déjà dit dans un autre post :aie: