Question

在C ++中有可能吗？例如，我有一个指向函数的指针，该函数不带参数，返回类型为void：

void (*f)();

和一个函数对象：

class A
{
public:
    void operator()() { cout << "functor\n"; }
};

是否可以将f对象的地址分配给A？当我致电f()来致电A仿函数？

我尝试了这个，但它不起作用：

#include <iostream>
using namespace std;

class A
{
public:
    void operator()() { cout << "functorA\n"; }
};

int main()
{
    A ob;
    ob();
    void (*f)();
    f = &ob;
    f();       // Call ob();
    return 0;
}

我得到C:\Users\iuliuh\QtTests\functor_test\main.cpp:15: error: C2440: '=' : cannot convert from 'A *' to 'void (__cdecl *)(void)' There is no context in which this conversion is possible

有没有办法实现这个目标？

Answer 1

您无法按照指定的方式执行此操作，因为：

operator（）必须是非静态函数（标准要求）
指向非静态函数的指针必须具有隐式参数 - 指向类实例的指针
你对f（）的调用没有给出任何关于你的函数被称为对象A的实例的指示

使用C ++ 11和std :: function，就像Stephane Rolland指出的那样，可能会做到这一点 - 你将在绑定中指定对象的指针：

std::function<void(void)> f = std::bind(&A::operator(), &ob);

（关于在成员函数上使用std :: function，请参阅question）

Answer 2

如果您使用C ++ 11，可以使用std::function

#include <functional>

std::function<void()> f;

int main()
{
    A ob;
    ob();

    f = ob;    // f refers to ob
    f();       // Call ob();
    return 0;
}

Answer 3

是的，有可能使用C ++ 1 / C ++ 0x功能，但要实现这一点，你应该使用 std :: function ，它可以解决两种类型，功能和对象函数。

#include <functional>

 class A
{
public:
    void operator()() { }
};

int main()
{
    std::function<void(void)> aFunction;
    A ob;

    aFunction = ob;

// or as another user said
// aFunction = std::bind(&A:operator(), &ob);

    aFunction();

    void (*f)();

    aFunction = f;

    aFunction();

    return 0;
}

如果您遇到C ++ 03，可以使用std::mem_fun和std::ptr_fun

Answer 4

这样的解决方法怎么样：

基本上，您希望有一种调用成员函数和函数的通用方法。那么也许你可以创建一个包装器来表示一个函数或成员函数的泛型指针。假设您有Base类，并且希望能够调用所有派生类的operator()。然后你也有一个你想要调用的function()：

class Base
{
public:
    virtual void operator()() = 0;
};

class A : public Base
{
public:
    void operator()(){ std::cout << "A()" << std::endl; }
};

void function()
{
    std::cout << "function" << std::endl; 
}

如果您创建一个包装器，允许您构建自定义指针（MyFncPtr）：

typedef void (Base::*BaseFncPtr)();
typedef void (*FncPtr)();

class MyFncPtr
{
public:
    MyFncPtr(FncPtr f) : fnc(f), baseObj(NULL), baseFnc(NULL) { }
    MyFncPtr(BaseFncPtr fPtr, Base* objPtr) : baseFnc(fPtr), baseObj(objPtr), fnc(NULL)  { }
    void invoke()
    {
        if (baseObj && baseFnc)
            (baseObj->*baseFnc)();
        else if (fnc)
            fnc();
    }

private:
    BaseFncPtr baseFnc;
    Base* baseObj;
    FncPtr fnc;
};

你可以这样做：

A a;
MyFncPtr myPtr(&Base::operator(), &a);
myPtr.invoke();
MyFncPtr myPtr2(function);
myPtr2.invoke();

输出：

A()
function

希望这会有所帮助：）

将指向函数的指针分配给指向函数对象的指针的地址

4 个答案: