Pointeur de fonctions sur méthode

Version imprimable

03/12/2005, 15h48
Glosialabolas

Pointeur de fonctions sur méthode

Bonjour, alors je suis en train de réaliser un petit programme, et je ne demande pas de réponse pour un TP quelconque :D (si seulement je faisais ca en cours :D)

Donc j'ai une classe fait 2 3 trucs et je voudrais connecter les évènements de cette classe à une autre classe (cette classe peut etre hérité, ce n'est pas un problème). J'ai deja chercher sur le net, j'ai vu qu'on pouvait pas, fallais que la fonction soit static. Mais je peux pas.
Pourtant il doit bien y avoir un moyen de le faire d'une facon ou d'une autre car avec GtkMM on connecte bien des signaux. Donc voila si vous pouviez me donner un point de départ ou une astuce pour faire ca, ca m'aiderais beaucoup :)

merci d'avoir lu ce superbe message surement plein de fautes :)
03/12/2005, 16h13
TobyKaos

Un pointeur sur fonction ce n'est pas un foncteur? il me semble.
Bref si j'ai bien compris tu veux qu'une classe B soit à l'écoute de A et agisse en conséquence.
Bon je vois pas trop comment faire.

salut,
est-ce que ce petit bout de code peut t'aider ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
 
class A
{
public:
	int f(int);
};
 
int A::f(int n) 
{
	return n;
}
 
int main()
{
	int (A::*ptr)(int); // ptr est un pointeur sur méthode de A
	ptr = A::f;         // ptr pointe sur A::f()
 
	A una;
	cout << (una.*ptr)(3) << endl; // appel de la méthode pointée par ptr pour l'objet una
}

03/12/2005, 16h41
Luc Hermitte

Sinon. Avec boost.function, tu trouveras tout ce qu'il faut pour recevoir des functions (membre ou non).
Cf également boost.signal dans la thématique de ton problème.

Citation:
Envoyé par jmv
salut,
est-ce que ce petit bout de code peut t'aider ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <iostream> using namespace std; class A { public: int f(int); }; int A::f(int n) { return n; } int main() { int (A::*ptr)(int); // ptr est un pointeur sur méthode de A ptr = A::f; // ptr pointe sur A::f() A una; cout << (una.*ptr)(3) << endl; // appel de la méthode pointée par ptr pour l'objet una }
Ca n'ira car la classe ou y'a la fonction pointé n'est pas connu a l'avance et faut que ca marche pour n'importe quel classe.

Voila un peu le genre de truc que je veux :)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Opla{ public: void fonction() { cout << "Test" << endl; } }; class Utile{ void (*signal)(); public: void signal_connect(void (*f)()) { signal = f; } void fonction_truc() { //appel de la fonction pointé par signal } };
Je vais regarder du coté de boost alors merci :)

PS : Si d'autres ont des solutions je prend :D

03/12/2005, 20h46
Glosialabolas

Je viens de tester avec boost, elle il aime pas non plus que je lui passe des méthode pour un ca :

Code:

boost::function<void (int, int, int)> f
03/12/2005, 21h04
JolyLoic

Regarde aussi boost::bind, ça va de paire avec boost::function
03/12/2005, 22h50
Glosialabolas

Je pense pas que cela va convenir a mon programme, je vais essayer de détailler un peu plus.

Donc j'ai une classe qui s'occupe d'afficher diverses choses. Cette classe doit etre réutilisable dans d'autres programmes. Et donc je voudrais rajouter la gestion d'évènements tel que le clic, l'appuie d'une touche ou autre.
Et donc j'aimerais mettre des méthodes genre
signal_connect_clic(fonction quand y'a un clic)

Ou si j'ai mal vu sur le site de boost, si vous auriez d'autres sites qu'en parle en francais si possible, mais l'anglais ira bien :)

merci :)

En utilisant juste boost::function et boost::bind :

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
enum BoutonSouris{/*...*/};
 
struct Bouton
{
  void signal_connect_clic(boost::function<void(BoutonSouris));
  void processEvents();
  typedef vector<boost::function<void(BoutonSouris)> > ClickHandlers;
  ClickHandlers my_click_handlers;
};
 
void Bouton::processEvents()
{
  /*...*/
  for (ClickHandlers::iterator it = my_click_handlers.begin();
        it != my_click_handlers.end();
       ++it)
  {
     *it(buttonClicked);
  } 
}
 
struct Autre
{
  void f(BoutonSouris bs);
};
 
void f(BoutonSouris bs, int autreDonnee);
 
int main()
{
  Bouton b;
  Autre a;
  b.signal_connect_clic(boost::bind(&A::f, boost::ref(a), _1));
  b.signal_connect_clic(boost::bind(f, _1, 42));
}

Sachant qu'il y a boost signal qui encapsule ça (je ne sais pas trop ce que ça apporte par rapport à function+bind, je n'ai jamais essayé.

04/12/2005, 14h55
Glosialabolas

Ca marche nickel, merci bien :)