Discussion :

[bountykiler]

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

[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.

[Davidbrcz]

Oui, on peut.
Regarde:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[JulienDuSud]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[Klaim]

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

[bountykiler]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[Médinoc]

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