Discussion :

[flow10000]

Bonjour, je suis actuellement sur un projet SFML et j'aimerais créer un peu ma propre GUI.

J'aimerais donc créer une classe Bouton telle que :

Lorsque le bouton est détecté comme relâché, celà appelle une méthode de la classe dans laquelle il est déclaré.
Par exemple :

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
 
// interfacegraphique.h
class InterfaceGraphique
{
public:
   InterfaceGraphique();
   void MethodeAAppeller();
 
private:
   Bouton bouton;
};
 
// interfacegraphique.cpp
InterfaceGraphique::InterfaceGraphique()
{
   /* J'aimerais donc, lorsque j'instancie mon bouton, stocker "l'action" qui va être exécutée lorsque le bouton aura été activé. */
   this->bouton = new Bouton(MethodeAAppeller);
 
}

J'aimerais donc savoir comment faire ça simplement.
D'avance merci pour vos réponses.
Si vous avez besoin de plus de précisions sur mon problème n'hésitez pas.

[Bousk]

Bonjour,

oui c'est tout à fait possible, il s'agit de foncteur ou pointeur sur fonction.

Quel code as-tu déjà à ce niveau ? Quel problème rencontres-tu ?

[flow10000]

Alors voilà où j'en suis. J'ai déjà tenté un bon nombre de chose mais sans succès.

// Classe Bouton

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
 
// bouton.h
class Bouton
{
private:
   // La fonction que l'on passe en paramètre
   TYPE function;
 
public:
   Bouton(Type t);
   void Update();
   void Click();
}
 
// bouton.cpp
Bouton::Bouton(Type t)
{
   this->funtion = t;
}
 
Bouton::Update()
{
   /* Ici on test si la souris à cliqué sur le bouton */
   If(sourisClick)
      this->Click();
}
 
Bouton::Click()
{
   // on exécute la fonction...
   this->function();
}

// Classe InterfaceGraphique

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
 
// InterfaceGraphique.h
class InterfaceGraphique
{
private:
   Bouton bouton;
 
public:
   InterfaceGraphique();
   void Update();
   void LaFonctionAAppeller();
}
 
// InterfaceGraphique.cpp
InterfaceGraphique::InterfaceGraphique()
{
   // J'aimerais faire un truc du genre :
   this->bouton = new Bouton(this->LaFonctionAAppeller);
}
 
InterfaceGraphique::Update()
{
   this->bouton->Update();
}

J'ai déjà essayer d'utiliser std::function mais le problème était que lorsque la fonction était appelé, elle utilisait les attribut de la classe tels qu'ils étaient initialisés au début.
J’espère que j'ai été suffisamment clair.
Si il vous faut encore des précisions n'hésitez pas.

[Bousk]

D'où sort TYPE ? c'est la brique qu'il te manque ?

Tu peux aussi chercher du côté du DesignPattern Visitor (visiteur).

Pour pouvoir utiliser this->function(); function (de type TYPE) doit posséder un operator().

J'ai déjà essayer d'utiliser std::function mais le problème était que lorsque la fonction était appelé, elle utilisait les attribut de la classe tels qu'ils étaient initialisés au début.

pas compris

[flow10000]

Oui voilà, TYPE c'est ce qu'il me manque. Je ne sais pas exactement ce que doit être cet attribut.


J'ai déjà essayer d'utiliser std::function mais le problème était que lorsque la fonction était appelé, elle utilisait les attribut de la classe tels qu'ils étaient initialisés au début, par exemple :

J'initialise un objet InterfaceGraphique avec un attribut i = 0;
LaFonctionAAppeller est telle que :

Code :

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

1
2
3
4
5
 
LaFonctionAAppeller()
{
   cout >> i >> endl;
}

Durant le déroulement du programme, je passe i à la valeur 2.
Apres cela, je clique sur le bouton, cela va donc appeler LaFonctionAAppeller et cela va m'afficher 0, comme si i n'avais jamais été modifié.

J’espère avoir été plus clair.
Je vais faire quelque recherche sur le DesignPattern Visitor pour voir.

[flow10000]

Bon je retente à présent de passer par des pointeurs de fonction mais je suis un peu largué syntaxiquement :

// Classe Bouton

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
 
// bouton.h
typedef void(*Action)();	
 
class Bouton
{
private:
   // La fonction que l'on passe en paramètre
   Action action;
 
public:
   Bouton(Action a);
   void Update();
   void Click();
}
 
// bouton.cpp
Bouton::Bouton(Action a)
{
   this->action = a;
}
 
Bouton::Update()
{
   /* Ici on test si la souris à cliqué sur le bouton */
   If(sourisClick)
      this->Click();
}
 
Bouton::Click()
{
   // on exécute la fonction...
   this->action();
}

// Classe InterfaceGraphique

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
 
// interfacegraphique.h
class InterfaceGraphique
{
private:
   Bouton bouton;
 
public:
   InterfaceGraphique();
   void Update();
}
 
// interfacegraphique.cpp
InterfaceGraphique::InterfaceGraphique()
{
   // J'aimerais faire un truc du genre :
   // mais voilà j'ai beau essayer pas mal de truc ça fail à ce moment là..
   // this->bouton = new Bouton(this->LaFonctionAAppeller);
 
   // J'ai essayé ça sans succès :
   Action a = this->Connect;
   this->bouton = new Bouton(a);
}
 
InterfaceGraphique::Update()
{
   this->bouton->Update();
}

Je pense que cette fois je ne suis pas très loin du résultat voulu mais je bloque encore...

[Bousk]

Le souci est que la fonction que tu veux pointer est une fonction membre. Sa signature est différente d'une fonction statique ou libre.

Tu devrais avoir un code un peu comme ça

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
template< class T >
struct Callback
{
  typedef void(T::*ptrFct)(void);
  Callback(T* object, ptrFct method) : m_obj(object), m_method(method) {}
 
  void operator()(void) { m_obj->m_method(); }
 
 private:
  T* m_obj;
  ptrFct m_method;
};
 
InterfaceGraphique::InterfaceGraphique()
{
   this->bouton = new Bouton(this, InterfaceGraphique::LaFonctionAAppeller);
}

J'ai des sources chez moi, je te présenterai une implémentation plus correcte ce soir si j'y pense.

[flow10000]

D'accord merci, je vais essayer de mon coté de m'inspirer de ton post cet après midi. Mais j'aimerais bien effectivement pouvoir jeter un petit coup d'oeuil à ton code ce soir.

Encore merci

[Bousk]

Voilà ce que j'ai de simple pour des callback

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
48
class CCallback
	{
		public:
			CCallback() {}
			virtual ~CCallback() {}
			virtual void Call()=0;
	};
	class CStaticCallback : public CCallback
	{
		typedef void(*ptrfct)();
		public:
			CStaticCallback(ptrfct _pCallback)
				: m_pFct(_pCallback)
			{
 
			}
			virtual ~CStaticCallback() {}
 
			virtual void Call()
			{
				(*m_pFct)();
			}
 
		protected:
			ptrfct	m_pFct;
	};
	template< class T >
	class CEventCallback : public CCallback
	{
		typedef void(T::*ptrfct)();
		public:
			CEventCallback(T* _pObj, ptrfct _pCallback)
				: m_pObj(_pObj)
				, m_pFct(_pCallback)
			{
 
			}
			virtual ~CEventCallback() {}
 
			virtual void Call()
			{
				(m_pObj->*m_pFct)();
			}
 
		protected:
			T*		m_pObj;
			ptrfct	m_pFct;
	};