Discussion :

[Glosialabolas]

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

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

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

[jmv]

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

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

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

[Glosialabolas]

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

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

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

[Glosialabolas]

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

Code :

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

boost::function<void (int, int, int)> f

[JolyLoic]

Regarde aussi boost::bind, ça va de paire avec boost::function

[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

[JolyLoic]

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

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

[Glosialabolas]

Ca marche nickel, merci bien