Obtenir un pointeur vers l'objet en fonction de membre

Voici le problème:

1) j'ai une classe comme ceci:

class some_class
{
public:
    some_type some_value;
    int some_function(double *a, double *b, int c, int d, void *e);
};

2) à l'Intérieur de some_function, j'utilise some_values de some_class objet pour obtenir un résultat.

3) Donc, j'ai un objet concret et je veux obtenir un pointeur vers cet objet some_function.

Est-il possible? Je ne peux pas utiliser some_fcn_ptr parce que le résultat de cette fonction dépend du béton some_value d'un objet.

Comment puis-je obtenir un pointeur vers some_function d'un objet? Merci.

typedef  int (Some_class::*some_fcn_ptr)(double*, double*, int, int, void*);

Vous parlez de la pointeur-à-états-fonctions
Voir stackoverflow.com/questions/130322/... pour plus de détails. Vous ne pouvez pas obtenir de pointeur de fonction pour certains, objet concret, vous avez besoin de pointeur de l'objet et du pointeur de fonction membre d'appeler la méthode d'un objet.

InformationsquelleAutor Alex Hoppus | 2012-01-14

c++function-pointers member

Vous ne pouvez pas, au moins il ne sera pas seulement un pointeur à une fonction.

Fonction membre est commun pour toutes les instances de cette classe. Toutes les fonctions membres ont implicite (premier) paramètre - this. Pour appeler une fonction membre pour une instance spécifique vous avez besoin de pointeur sur cette fonction de membre et cette instance.

class Some_class
{
public:
    void some_function() {}
};

int main()
{
    typedef void (Some_class::*Some_fnc_ptr)();
    Some_fnc_ptr fnc_ptr = &Some_class::some_function;

    Some_class sc;

    (sc.*fnc_ptr)();

    return 0;
}

Plus d'infos ici dans C++ FAQ

À l'aide de Boost cela peut ressembler à (C++11 fournit une fonctionnalité similaire):

#include <boost/bind.hpp>
#include <boost/function.hpp>

boost::function<void(Some_class*)> fnc_ptr = boost::bind(&Some_class::some_function, _1);
Some_class sc;
fnc_ptr(&sc);

C++11 est labdas:

#include <functional>

Some_class sc;
auto f = [&sc]() { sc.some_function(); };
f();
//or
auto f1 = [](Some_class& sc) { sc.some_function(); };
f1(sc);

Boost et C++11.

InformationsquelleAutor Andriy Tylychko

Vous pouvez écrire une sorte de Wrapper qui est capable d'utiliser à la fois la fonction ou de la méthode en paramètre.

J'ai utilisé les classes suivantes pour le lancement de fonctions (il a été utilisé dans un de mes SDL programme):

class CallbackFunction {
public:
    //Constructor, copy constructor and destructor

    virtual int execute( SDL_keysym* keysym) const;
    virtual int operator()( SDL_keysym* keysym) const;

protected:
    int( *callback)( SDL_keysym*));
}

int CallbackFunction::execute( SDL_keysym* keysym) const{
    return callback(keysym);
}

int CallbackFunction::operator()( SDL_keysym* keysym) const{
    return callback( keysym);
}

Et cette extension pour les "méthodes":

template<class T>
class CallbackMethod : public CallbackFunction {
public:
    //Constructor, copy constructor and destructor
    CallbackMethod( T *object, int(T::*callback)( SDL_keysym* keysym));

    int execute( SDL_keysym* keysym) const;
    int operator()(SDL_keysym* keysym) const;

protected:
    T *object;
    int(T::*method)( SDL_keysym* keysym);
};

//Object initialization (constructor)
template<class T>
CallbackMethod<T>::CallbackMethod( T *object, int(T::*callback)( SDL_keysym* keysym)):
    CallbackFunction( NULL),object(object),method(callback){
}


//Responsible for executing
template<class T>
int CallbackMethod<T>::execute( SDL_keysym* keysym) const {
    return (object->*method)(keysym);
}
template<class T>
int CallbackMethod<T>::operator()( keysym) const {
    return (object->*method)( keysym);
}

Et ensuite l'utiliser comme:

CallbackFunction *callback;
callback = new CallbackFunction( myFunction);
callback = new CallbackMethod<A>( instanceOfA, instanceOfA::myMethod);
callback = new CallbackMethod<B>( instanceOfB, instanceOfB::myMethod);
...
callback( keysym);

J'ai trouvé une macro comme ceci:

CALLBACK(object,method) new CallbackMethod<typeof(*object)>( object, &method)

vraiment utile

InformationsquelleAutor Vyktor

9

Non, vous ne pouvez pas obtenir un pointeur vers une classe C++ méthode (sauf si la méthode est déclarée statique). La raison en est qu'une méthode de la classe a toujours le pointeur this, un pointeur vers l'instance de classe. Mais étiez-vous à l'appel de la méthode à travers un pointeur, pointeur ne pouvait pas encapsuler les this pointeur, et puis alors il n'y aurait pas d'exemple ci-joint, et par conséquent, ce comportement n'est pas légal.

InformationsquelleAutor Dov Grobgeld

Bien que pas exactement ce que vous avez demandé, si vous pouvez utiliser C++11 dans ce qui suit, peut néanmoins en fonction de vos besoins (non testé):

std::function<int(double*, double*, int, int, void*)>
  some_function_of(Some_class& obj)
{
  return [&](double* a, double* b, int c, int d, void* e){
    return obj.some_func(a, b, c, d, e); };
}

InformationsquelleAutor celtschk

2

J'ai utilisé le Boost de la bibliothèque. J'ai inclus "boost/bind.hpp" dans mon code. Ensuite, une méthode nommée "fn" peut être définie comme

auto fn = boost::bind(ClassName::methodName, classInstanceName, boost::espaces réservés::_1);

InformationsquelleAutor Zoob

Vous devez vous connecter pour publier un commentaire.