Reference d'une fonction membre

Version imprimable

06/09/2009, 18h51
bountykiler

Reference d'une fonction membre

Vu qu'il est possible de créer des pointeurs vers de fonctions membres et des reference de fonction, je voulais savoir s'il était possible de créer des reference vers des fonctions membres d'une classe.

Merci
06/09/2009, 20h16
Klaim

Bonne question, j'ai jamais essayé mais je pense que ça ne dois pas être possible: un pointeur de fonction ne pointe pas sur une instance mais sur l'adresse en mémoire où se trouve la dite fonction (forçant a fournir une instance de classe dans le cas d'un fonction membre).

Or une référence n'est (théoriquement) utilisé que pour une instance de type (le fait que la référence soit implémentée comme un pointeur est un détail d'implémentation, on doit prendre la référence comme un surnom d'un objet).

Donc je dirais que ce n'est pas possible. Maintenant je m'en vais vérifier ce que dis VC9.

Au passage, si tu utilises std::tr1::function<> au lieu d'adresses de pointeurs "nus" alors tu as un fonctor qui lui est un objet et donc peut avoir une référence.

Oui, on peut.
Regarde:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <iostream> struct A { void foo(){std::cout<<"foo a"<<std::endl;} }; int main(int argc, char const *argv[]) { typedef void (A::*ptrAfct)(); ptrAfct ptr=&A::foo; const ptrAfct& ref=&A::foo; A a; (a.*ref)(); return 0; }
A noter que la référence doit être const. Au vu de l'erreur sortie par g++, je dirais que c'est car &A::foo doit renvoyer une copie et comme on ne peut lier une référence non const avec un temporaire, boom.

Sinon +1 pour les tr1::function/boost::function.

J'ai donc testé sous VC9 et visiblement j'arrive a faire en sorte d'utiliser une référence à une fonction globale.
Par contre je ne trouve pas la syntaxe pour déclarer le typedef d'une référence à une fonction membre. L'utilisation de & à la place de * ne passe pas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 #include <iostream> void test() { std::cout << "Global : It works!\n"; } class Test { public: void doIt() { std::cout << "Member : It works!\n" ; } }; typedef void (&SimpleFunction)(); typedef void (Test::*MemberFunction)(); int main() { SimpleFunction myfunc = test; myfunc(); Test myTest; MemberFunction myMemberFunc = &Test::doIt; (myTest.*myMemberFunc)(); std::cin.ignore(); return 0; }
Ce code marche, comme dit je n'ai pas trouvé de moyen d'avoir une référence à une fonction membre.

Peut être que quelqu'un plus au fait du standard pourrait donner des précisions là dessus? Ca m'étonne déjà que la référence a la fonction globale marche.

boost::function avec boost::bind te permet cela assez facilement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>
 
class A
{
	typedef boost::function< void() > callback_t;
public:
	void Foo() const
	{
		myCallback();
	}
 
	void BindFunc( const callback_t& cb )
	{
		myCallback = cb;
	}
 
	callback_t myCallback;
};
 
void foo()
{
	std::cout << "hello from global" << std::endl;
}
 
class B
{
public:
	void Foo()
	{
		std::cout << "hello from B" << std::endl;
	}
};
 
int main()
{
	A a;
	a.BindFunc( foo );
	a.Foo();
 
	B b;
	a.BindFunc( boost::bind( &B::Foo, &b ) );
	a.Foo();
	return 0;
}

06/09/2009, 22h29
Klaim

Par contre, est-ce que c'était prévu par le standard? (et est-ce que ça marche sur les autres compilo?)

Citation:
Envoyé par Klaim
J'ai donc testé sous VC9 et visiblement j'arrive a faire en sorte d'utiliser une référence à une fonction globale.
Par contre je ne trouve pas la syntaxe pour déclarer le typedef d'une référence à une fonction membre. L'utilisation de & à la place de * ne passe pas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 #include <iostream> void test() { std::cout << "Global : It works!\n"; } class Test { public: void doIt() { std::cout << "Member : It works!\n" ; } }; typedef void (&SimpleFunction)(); typedef void (Test::*MemberFunction)(); int main() { SimpleFunction myfunc = test; myfunc(); Test myTest; MemberFunction myMemberFunc = &Test::doIt; (myTest.*myMemberFunc)(); std::cin.ignore(); return 0; }
Ce code marche, comme dit je n'ai pas trouvé de moyen d'avoir une référence à une fonction membre.

Peut être que quelqu'un plus au fait du standard pourrait donner des précisions là dessus? Ca m'étonne déjà que la référence a la fonction globale marche.
En fait, j'ai la même chose avec gcc, d'ou ma question.
Pour être plus précis, mon but est de créer une classe template qui prend une fonction membre en paramètre template, le truc étant qu'en utilisant un pointeur cela ne marche pas.
Aussi je me demandais si cela ne venait pas de l'opérateur & utilisé dans ma déclaration pour obtenir l'adresse de ma fonction, d'ou l'idée d'utiliser une reference de fonction membre à la place.
Mais quand j'essaie de faire cela, comme dit plus haut: l'utilisation de & à la place de * ne passe pas car gcc me sort une erreur de syntaxe.

Ps: Davidbrcz > J'ai l'impression que ce que tu fais, c'est prendre une reference vers un pointeur de fonction, non?

08/09/2009, 14h40
Médinoc

Citation:

Envoyé par bountykiler

Ps: Davidbrcz > J'ai l'impression que ce que tu fais, c'est prendre une reference vers un pointeur de fonction, non?

J'ai la même impression...