Discussion :

[Halloula]

Bonjour

j'ai une classe A avec une methode AMethode(arg1,arg2..)
je veux passer en argument la methode AMethode de la classe A à une methode d'une classe B,comment faire ?

le passage sera du genre ClassB::BMethode(AMethode,..) {}
il faut noter que je donne pas à AMethode passé en argument à BMethode,ses propres methodes à elle.

Merci d'avance

[Charlemagne]

C'est rare, mais c'est possible avec ::*

Regarde du coté de la fonction mem_fun (et ses variantes) dans la STL pour des exemples.

Code :

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

1
2
3
4
5
6
7
8
9
template<class Result, class Type>
   mem_fun_t<Result, Type> mem_fun (
      Result(Type::* _Pm )( ) 
);
 
template<class Result, class Type, class Arg>
   mem_fun1_t<Result, Type, Arg> mem_fun(
      Result (Type::* _Pm )( Arg ) 
);

[deadalnix]

Tu as deux façon de faire cela. Les pointeurs de fonction et les foncteurs.

Tu devrais trouver ton bonheur à l'aide de ces mots clefs.

[Shydow]

Un petit lien pour les foncteurs :
http://www.cplusplus.com/reference/std/functional/

[camboui]

Au délà, il est aussi possible de passer des méthodes/fonctions en paramètre template.

[Lightness1024]

bon vieux boost::bind, comme tout le monde...

[Goten]

Ouai sauf que bind ne sert pas à ça...

[Lightness1024]

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
 
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>
 
struct A
{
    void a(boost::function<void()> const& f)
    {
        f();
    }
};
 
struct B
{
    void b(int arg)
    {
        std::cout << "appel a B::b(" << arg << ")" << std::endl;
    }
};
 
int main(int,char**)
{
    A sa;
    B sb;
    sa.a(boost::bind(&B::b, &sb, 42));
}

si ca l'embête d'avoir les arguments enregistrés dans le bind, il n'a qu'a utiliser function<void(int)> et ne pas placer 42 tout de suite, mais dans f(42).

[Goten]

Tu viens de démontrer ce que je disais... pour passer des poiteurs de fonctions (des foncteurs généralisés) à une fonction c'est boost::function et pas boost::bind. bind ne sert qu'a "binder" des arguments. (même si je te l'accorde on utilise généralement les deux mains dans la main)...

[Lightness1024]

Absolument.
Seulement il n'est pas obligatoire, un boost function peut se créer a partir du type du boost bind, mais on peut garder l'objet "bind" et appeler la fonction directement avec.

par exemple:

Code :

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

1
2
 
boost::bind(B::b, &sb, num) ();  // appel immediat.

donc on peut imaginer prendre l'objet bind directement en référence constante (car c'est un function object aussi) et appeller l'operateur ().

Code :

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

1
2
3
4
5
6
7
8
9
10
 
struct A
{
 template< typename T >
 void a(T const& fobject)
 {
   fobject();
 }
};
struct B ....  // puis pareil ensuite

[Halloula]

j'avoue que j'ai pas tres bien saisi..bon je réxplique ,et cette fois en mettant du code :
j'ai ma methode de la classe Pick :

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
49
50
51
52
53
54
55
56
57
58
59
60
 
SbVec3f * Pick :: ivEvent_PointByMouse(void *userData, SoEventCallback *eventCB)
//===========================================================
// Fonction qui capture  une mesure de distance a la souris
{
 
 static SbVec3f *XYZ1=NULL;
  SbVec3f *XYZ2=NULL; 
 
  SoSeparator *root = (SoSeparator *) userData;
  const SoEvent *event = eventCB->getEvent();
 
   // Check for mouse button being pressed
   if (SO_MOUSE_PRESS_EVENT(event, ANY)) {
     // Fenetre dans laquelle a ete fait le clique
      const SbViewportRegion &myRegion = 
         eventCB->getAction()->getViewportRegion();
      //      SbVec3f *XYZ1=GetPointXYZ(root, myRegion,
      XYZ1=GetPointXYZ(root, myRegion,
                      event->getPosition(myRegion));
      if ( XYZ1 != NULL ){
	//	float x,y,z;
	//	XYZ1->getValue(x,y,z); 
	//	printf("Premier point est : %f %f %f\n",x,y,z);
	eventCB->grabEvents(); // on capture tous les evenements
      } else eventCB->setHandled(); // ON abandonne...
   } 
   // Pour faire une mesure de distance on teste un autre evenement :
   if (SO_MOUSE_RELEASE_EVENT(event, ANY)) {
      const SbViewportRegion &myRegion = 
         eventCB->getAction()->getViewportRegion();
      //      SbVec3f *XYZ2=GetPointXYZ(root, myRegion,
      XYZ2=GetPointXYZ(root, myRegion,
                      event->getPosition(myRegion));
 
      eventCB->releaseEvents(); 
     eventCB->setHandled(); //testtttt
 
   // Si la distance entre les 2 points est trop faible
      const float EPSILON=1.e-5; // il faut le calculer en % de la fenetre ecran
   // on ne renvoi les coordonnees du point
   // sinon la distance entre les 2
      if (( XYZ1 != NULL ) && (XYZ2 != NULL)){ 
	// XYZ1 != NULL normalement 
	SbVec3f V ;
	V=(*XYZ2)-(*XYZ1);
	 d=V.length();
 
	if (d > EPSILON ) {
 
	//  printf("Distance entre les points : %f\n",d);
	} else {
	  float x,y,z;
	  return XYZ2 ;
	// XYZ2->getValue(x,y,z); // Comment ca marche ?
	//  printf(" XYZ= %f %f %f\n",x,y,z);
	}
      }
   }
}

je lui fais appel dans cette methodee là de la classe CViewer

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void CViewer :: Oimage() {
///....
 myEventCB->addEventCallback(
      SoMouseButtonEvent::getClassTypeId(),

        (SoEventCallbackCB*)ivEvent_PointByMouse, // là est mon problem comment faire passer ivEvent_PointByMouse ?
      //      myMousePressCB,
      myViewer->getSceneManager()->getSceneGraph()); 
///....
}

en C j'aurai juste ecris

Code :

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

1
2
3
4
5
6
 myEventCB->addEventCallback(
      SoMouseButtonEvent::getClassTypeId(),

        (SoEventCallbackCB*)ivEvent_PointByMouse,
      //      ca passe
      myViewer->getSceneManager()->getSceneGraph());,

j'espere que c'est plus clair.
merci

[Halloula]

on m'avait suggéré de mettre Pick :: ivEvent_PointByMouse en la passant en arguement à la methode AddEventCallback,mais ca marche pas

[Lavock]

Il faut que ta fonction prenne en argument un SoEventCallback * (Pick::*).

[Halloula]

le addEventCallback est une fonction prédéfinie,je ne peux la modifier.
par contre,j'ai deja essayé avec Pick :: * iv_point_bymouse et rien :/

[Lavock]

Donc tu as besoin d'une callback c comme je le pensais... et ça c'est moche.

Un vieux hack, c'est de faire une fonction extern stdcall ami de ta fonction, en lui fourgant un pointeur sur this.

Mais vu que c'est pas toi qui appelle ta callback >< ! Sinon, y a un vieux hack pas portable du tout qui pique les yeux. Cherche Callback C\C++, tu devrais trouver. Attentions, ça touche carrément l'assembleur >< !

[3DArchi]

Salut,
Pour pouvoir appeler un pointeur d'une fonction membre, tu as besoin d'une instance de la classe. Or ta callback efface probablement les types et doit trimballer quelque part des void*.
Les solutions à la boost sont les plus mainstream avec le C++ actuel.
Sinon, une autre alternative, mais moins 'sécurisée' du point de vue typage :

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
 
class Pick {
/* ...*/
static SbVec3f * s_cb_ivEvent_PointByMouse(void *userData, SoEventCallback *eventCB);
SbVec3f * ivEvent_PointByMouse(SoEventCallback *eventCB)
};
 
SbVec3f * Pick :: s_cb_ivEvent_PointByMouse(void *userData, SoEventCallback *eventCB)
{
   return reinterpret_cast<Pick*>(userData)->ivEvent_PointByMouse(eventCB);
}
 
SbVec3f * Pick :: ivEvent_PointByMouse(SoEventCallback *eventCB)
{
   /*... */
}

et l'appel :

Code :

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

1
2
3
4
5
6
7
 myEventCB->addEventCallback(
      SoMouseButtonEvent::getClassTypeId(),
        s_cb_ivEvent_PointByMouse, 
       myMousePressCB, 
      myViewer->getSceneManager()->getSceneGraph()); 
///....
}

Un des arguments doit correspondre à un objet Pick qui dans l'appel correspondra à userData.