Discussion :

[superspag]

Bonjour à tous

Je me pose la question suivante (y'a des matins comme ça ) :

Est-il possible de passer une fonction membre non static en paramètre d'une fonction, pour un appel de callback déclarée en "cdecl".
J'utilise souvent ce mécanisme avec boost::function et boost::bind... Alors je me dis : ça ne coute rien d'essayer... (Ca serait pratique de pouvoir câbler ses callbacks de cette manière avec GLUT par exemple...)

Résultat :

Voici un code minimal :

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
 
#define BOOST_MEM_FN_ENABLE_CDECL
 
#include <boost/function.hpp>
#include <boost/bind.hpp>
 
class A {
public:
 
  typedef boost::function<void(void)> CB1;
  typedef void ( _cdecl * CB2 )( void );
 
  void setCB1( CB1 cb ) { _callback1 = cb; } ;
  void setCB2( CB2 cb ) { _callback2 = cb; } ;
 
  CB1 _callback1;
  CB2 _callback2;
};
 
class B {
public:
  void f(void) { } ;
  static void g(void) { } ;
};
 
int main(int argc, char* argv[])
{
  A a;
  B b;
 
  a.setCB1( &B::g ); // OK
  a.setCB2( &B::g ); // OK
 
  a.setCB1( boost::bind(&B::f, &b) ); // OK
  a.setCB2( boost::bind(&B::f, &b) ); // Pas OK : ne compile pas !!!
}

Quelqu'un saurait me dire s'il y a une manière de faire ?

[PierroElMito]

J'ai fait a peu près le même test il y a quelques jours, et j'étais arrivé a la conclusion que c'etait pas possible...
Mais si il existe une solution, ça m'intéresse aussi!

[Laurent Gomila]

Comment voudrais-tu faire passer un boost::function en tant que void (*)() ? Ce n'est absolument pas compatible au niveau des types, il faut que le callback soit pris en tant que boost::function.

[superspag]

Oui oui, j'ai bien vu que la conversion n'était pas possible, le compilo fait son caprice comme je m'y attendais :

Code :

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

1
2
3
4
5
6
7
8
9
 
c:\...\Source.cpp(35) : error C2664: 'A::setCB2'*: impossible de convertir le paramètre 1 de 'boost::_bi::bind_t<R,F,L>' en 'A::CB2'
        with
        [
            R=void,
            F=boost::_mfi::mf0<void,B>,
            L=boost::_bi::list1<boost::_bi::list_av_1<B *__w64 >::B1>
        ]
        Aucun opérateur de conversion définie par l'utilisateur disponible qui puisse effectuer cette conversion, ou l'opérateur ne peut pas être appelé

Ma question est : est-il possible de passer f en callback (f membre non static de B) et si oui comment ? Je me demandais s'il existait un moyen de reproduire le mécanisme boost::bind/boost::function...

[Laurent Gomila]

Ma question est : est-il possible de passer f en callback (f membre non static de B) et si oui comment ? Je me demandais s'il existait un moyen de reproduire le mécanisme boost::bind/boost::function...

Ma réponse sous-entendait "non"

Il ne faut pas inverser les rôles. C'est boost::function qui est suffisamment flexible pour accepter n'importe quel type de fonction, mais pas l'inverse. Un void(*)() n'acceptera qu'un void(*)(). Et comme ici le void(*)() n'existe nulle part, j'imagine mal qu'on puisse faire une quelconque conversion pour le rendre compatible.

[Alp]

Ce que tu peux faire par contre c'est essayer de wrapper ce que propose tes libs pour les fonctions de façon à pouvoir te servir de boost::function.

[superspag]

Oky, ça n'est pas possible => j'ai la réponse à ma question... Merci beaucoup à vous tous pour vos commentaires

Pour le wrapper je ne voit pas trop comment faire... je vais y réfléchire. En attendant je vais garder mes fonctions et variables static toutes moches, on va faire avec, tampis !

[PierroElMito]

Comment voudrais-tu faire passer un boost::function en tant que void (*)() ? Ce n'est absolument pas compatible au niveau des types, il faut que le callback soit pris en tant que boost::function.

ce serait théoriquement possible si boost::function implementait un operateur de cast comme ceci:

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
 
typedef void tCallback(void);
 
class Pipo
{
 
public:
 
	static void Mito(void)
	{
		cout<<"pipo mito!"<<endl;
	}
 
	operator tCallback* ()
	{
		return(Mito);
	}
 
};
 
void MaFonction(tCallback *_pfFunction)
{
	(*_pfFunction)();
}
 
int Main()
{
	Pipo kPipo;
	MaFonction(kPipo);
}

[Laurent Gomila]

ce serait théoriquement possible si boost::function implementait un operateur de cast comme ceci:

Oui, mais comme je l'ai dit juste après, vu que la callback en tant que void(*)() n'existe nulle part, c'est impossible. Et c'est encore plus impossible de convertir un pointeur sur fonction membre en pointeur sur fonction non-membre.

Pour le wrapper je ne voit pas trop comment faire...

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
class Wrapper
{
public :
 
    static void OnDisplay()
    {
        DisplayCB();
    }
 
    static void SetDisplayCallback(boost::function<void()> Func)
    {
        DisplayCB = Func;
        glutDisplayCallback(&Wrapper::OnDisplay);
    }
 
private :
 
    static boost::function<void()> DisplayCB;
};
 
Wrapper::SetDisplayCallback(boost::bind(&MaClasse::Display, MonObjet));

[superspag]

Merci Laurent pour l'exemple C'est beaucoup plus simple que je ne me l'imaginais... Je vais jouer un peu avec ça

[loufoque]

Ce n'est pas possible avec GLUT car les fonctions ne prennent pas de paramètre void*.