Question

问题在于：

1）我有一个类似的课程：

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

2）在some_function内，我使用some_values对象中的some_class来获得结果。

3）所以，我有一个具体的对象，我想得到一个指向这个对象some_function的指针。

有可能吗？我不能使用some_fcn_ptr，因为此函数的结果取决于对象的具体some_value。

如何获得指向对象some_function的指针？感谢。

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

Answer 1

你不能，至少它不只是指向函数的指针。

成员函数对于此类的所有实例都很常见。所有成员函数都有隐式（第一个）参数 - this。要为特定实例调用成员函数，您需要指向此成员函数和此实例的指针。

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

C++ FAQ

中的更多信息

使用 Boost ，这看起来像（C ++ 11提供了类似的功能）：

#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的labdas：

#include <functional>

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

Answer 2

您可以编写某种Wrapper，它可以同时使用函数或方法作为参数。

我使用以下类来启动函数（它在我的SDL程序中使用）：

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);
}

这个“方法”的扩展名：

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);
}

然后将其用作：

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

我发现了宏：

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

非常有用

Answer 3

不，你不能得到一个指向C ++类方法的指针（除非该方法被声明为static）。原因是类方法总是有指针this，指向类实例的指针。但是你是通过指针调用该方法，该指针无法封装this指针，然后就没有附加实例，因此这种行为是不合法的。

Answer 4

虽然不完全符合您的要求，但如果您可以使用C ++ 11，则以下内容可能仍然适合您的需求（未经测试）：

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); };
}

Answer 5

我使用了Boost库。我包括了＃34; boost / bind.hpp＆＃34;在我的代码中。然后是一个名为＆＃34; fn＆＃34;可以定义为

auto fn = boost :: bind（ClassName :: methodName，classInstanceName，boost :: placeholders :: _ 1）;

获取指向对象成员函数的指针

5 个答案: