是否可以在C ++中使用参数创建函数指针

Question

I'm trying to capture a function pointer to hand to a functor and I don't understand why I can't.

Functor Class:

template <class C>
class MyFunctor : public BaseFunctor {
  public:
    typedef long (C::*t_callback)(const long, const char *);

    MyFunctor (void) : BaseFunctor(), obj(NULL), callback(NULL) {}
    virtual long operator() (const long a, const char *b) {
        if ( obj && callback ) {
            (obj->*callback)(a,b);
        }
    }

    C *obj;
    t_callback callback;
};

Elsewhere in the code:

The function signature is long C::Func (const long, const char *)

MyFunctor funky;
funky.obj = this;
funky.callback = Func;

Then I get the error:

... function call missing argument list; ...

Why does this not work?

EDIT: In working through the suggestions below, I came across a simple solution to make my particular implementation work.

funky.callback = &C::Func;

Answer 1

I'm not 100% sure what your trying to do from your code but two C++ features that are much easier to use than function pointers are std::function and std::mem_fn here's an example of using std::function from the site.

#include <functional>
#include <iostream>

struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};

void print_num(int i)
{
    std::cout << i << '\n';
}

struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};

int main()
{
    // store a free function
    std::function<void(int)> f_display = print_num;
    f_display(-9);

    // store a lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();

    // store the result of a call to std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();

    // store a call to a member function
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    Foo foo(314159);
    f_add_display(foo, 1);

    // store a call to a function object
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
}

This is the function pointer in your code:

typedef long (C::*t_callback)(const long, const char *);

To make this an std::funciton do:

std::function<long(const long,const char*)> t_callback = something ;

Answer 2

You can't assign a function with signature unsigned long Func (const long, const char *) to a variable of type long (C::*)(const long, const char *) because

1. One returns unsigned long and the other returns long .
2. One is a pointer-to-member, the other is the name of a non-member "free" function.

If you want Func to simply be called without a C object, then you need to remove C:: from t_callback . If Func is actually a member function and your signature is not copied faithfully in the question ( do not paraphrase code!! ), you must use the :: operator when forming a pointer-to-member value, as in &ThisClass::Func .

The peculiar error you see is due to overload resolution being performed on the name. The compiler sees you have something of that name, but it's reporting that none of the things with that name (there could potentially be many) work in the given expression.

---

As others have mentioned, this isn't something you should actually use in a project. This kind of functionality is covered by std::function and std::bind , which are available even in C++03 using the standardized TR1 library, so doing it yourself is best kept to a self-contained exercise.

Without writing any custom code, you can do

std::function< long( long, char * ) > funky = std::bind( &MyClass::Func, this );

This gets a pointer-to-member to the Func method, attaches the current this pointer to it, then creates an indirect-call wrapper around it all which is valid for the lifetime of this .

funky( 3, "hello" );

To avoid the indirect call, use auto to avoid declaring a std::function . You will get an object of a one-off type. (You can't assign another function to it.)

auto funky = std::bind( &MyClass::Func, this );