Question

说我有以下代码：

class A
{
public:
    A() {}

    int f(void*, void*)
    {
        return 0;
    }
};

template <typename T>
class F {
public:
    F(int(T::*f)(void*,void*))
    {
        this->f = f;
    }

    int(T::*f)(void*,void*);

    int Call(T& t,void* a,void* b)
    {
        return (t.*f)(a,b);
    }
};

A a;
F<A> f(&A::f);
f.Call(a, 0, 0);

这很有效我可以轻松地调用该函数但是我怎么能在不知道类型的情况下得到这些函数的数组呢？

我希望能够将任何类f函数作为回调调用。我通常使用静态或c函数并完成它但我想尝试调用C ++成员函数。

想想我在C＃中作为代表所做的事情。我已经在Boost和其他地方看到了非常复杂的实现，但是我想要最低限度，没有复制，创建，删除等只需要我可以调用的简单回调。

这是一只白日梦吗？任何建议将不胜感激。

Answer 1

正如我在评论中提到的那样使用std::function和std::bind，你可以这样做：

#include <functional>

class A
{
public:
    A() {}

    int f(void*, void*)
    {
        return 0;
    }
};

class F {
public:
    F(std::function<int(void*, void*)>& func)
        : func_(func)
    { }

    std::function<int(void*, void*)>& func_

    int Call(void* a, void* b)
    {
        return func_(a, b);
    }
};

int main()
{
    using namespace std::placeholders; //for _1, _2, _3...

    A a;
    F f(std::bind(&A::f, a, _1, _2));

    f.Call(nullptr, nullptr);
}

要使用这些函数的向量，只需使用例如

std::vector<std::function<int(void*, void*)>> my_function_vector;

然后调用向量中的每个函数，只需迭代它：

for (auto& f : my_function_vector)
{
    int result = f(some_pointer_1, some_pointer_2);
}

如果您在标准库中没有新的C ++ 11功能，那么使用boost::bind和boost::function也可以正常工作。并且您使用旧式迭代器循环来迭代向量。

Answer 2

我认为最低限度的实现如下：

std::vector<std::function<bool(int, int)>> my_delegate;

然后，您可以向矢量添加许多不同类型的可调用项。如：

bool mycompare(int a, int b)
{
    return a < b;
}

struct predicate
{
    bool operator()(int a, int b)
    {
        return a < b;
    }
};

struct myclass
{
    bool function(int a, int b)
    {
        return a < b;
    }
};

my_delegate.push_back(predicate());
my_delegate.push_back(mycompare);
my_delegate.push_back([](int a, int b){return a < b;});
myclass c;
my_delegate.push_back(std::bind(std::bind(&myclass::function, &c, std::placeholders::_1, std::placeholders::_2));

调用代理中的所有函数只需循环遍历它们并依次调用每个函数。

如何进行简单的C ++泛型回调？

2 个答案: