Question

我有一个MyClass类。在其中，我想创建一个函数指针数组，并使用另一个类（MemberClass）的函数初始化该数组。 MyClass有一个指向MemberClass的指针作为成员。但我得到这个编译时错误错误C2440：'初始化'：无法从'void（__ thiscall MyMemberClass :: *）（void）'转换为'F'

//This class has the function that I want to create a function pointer to
class MemberClass
{

private:

int myValue1;
int myValue2;

public: 

int GetValue1() //I want to point to this function from a function pointer in another class
{

    return myvalue1;
}

int GetValue2() //I want to point to this function from a function pointer in another class
{

    return myvalue2;
}


}




//This has array of function pointer that I want to point to member function of another class

Class MyClass
{

typedef void(*F)();


private:
MemberClass* mclass;
F[] f;
Process();
}

.cpp

MyClass::MyClass()
{
f[2] = {&MemberClass::GetValue1, &MemberClass::GetValue2} //This line throws error

//error C2440: 'initializing' : cannot convert from 'void (__thiscall MyMemberClass::* )(void)' to 'F'

}

void     MyClass::Processing()
{

//This is how I am hoping to use the function pointer array
F[Index]();

}

Answer 1

F被声明为函数的指针，没有返回void的参数。但是你的函数返回int，并且是MemberClass的成员函数，而不是普通的普通函数。所以你需要的类型是

typedef int (MemberClass::*F)();

调用它也更有趣：

int result = (mclass->*f[index])();

Answer 2

建议：使用C ++ 11的functional库而不是方法指针。

我正在略微扫描OP的示例代码以简化示例。

MemberClass大致保持不变。我删除了成员变量，因为这些方法现在被硬编码为返回1和2，以便于分辨。

#include <iostream>
#include <functional>

class MemberClass
{
public:
    int GetValue1()
    {
        return 1;
    }

    int GetValue2()
    {
        return 2;
    }
};

myClass会被扯掉，因为这就是行动所在。

class MyClass
{
private:

我正在使用std::function数组而不是typedef和typedef数组。请注意模板参数int()。这是一系列函数，它们不需要任何内容并返回int。 Magic中的std::bind将提供方法所需的隐藏this参数。如果函数具有绑定时未知的参数，请使用std::placeholders在方法的参数列表中为它们节省空间。

由于方法绑定到它们的对象，因此不再需要存储MemberClass* mclass;

    std::function<int()> f[2]; 

public:

调用函数很简单：索引数组并将括号括起来。

    int Process(int index)
    {
        return f[index]();
    }

构造函数要么有点棘手，要么不那么棘手，这取决于你的思想流派。我正在使用初始化列表，因为它更清晰（对我来说，无论如何）并且通常具有性能优势。首先，您可以将数组替换为std :: vector或大多数其他容器，而无需更改除变量定义之外的一行代码。

f[0] = std::bind(&MemberClass::GetValue1, mem); 
f[1] =...

构造函数体内的

仍然是一个选项。

    MyClass(MemberClass * mem):
        f{std::bind(&MemberClass::GetValue1, mem), 
          std::bind(&MemberClass::GetValue2, mem)}
    {
    }

};

这是一个愚蠢的测试代码，以确保这一切都有效。为什么？因为每次你不以最简单的形式测试代码，你就会冒不必要的风险。如果它不起作用，它就不会起作用。

int main()
{
    MemberClass c;
    MyClass d(&c);
    std::cout << d.Process(0) << std::endl;
    std::cout << d.Process(1) << std::endl;
}

一起切割和粘贴一块：

#include <iostream>
#include <functional>

class MemberClass
{

public:

    int GetValue1()
    {

        return 1;
    }

    int GetValue2()
    {

        return 2;
    }

};

class MyClass
{

private:
    std::function<int()> f[2];
public:
    int Process(int index)
    {
        return f[index]();
    }

    MyClass(MemberClass * mem):
        f{std::bind(&MemberClass::GetValue1, mem), 
          std::bind(&MemberClass::GetValue2, mem)}
    {
    }

};

int main()
{
    MemberClass c;
    MyClass d(&c);
    std::cout << d.Process(0) << std::endl;
    std::cout << d.Process(1) << std::endl;
}

指向不同类的函数的函数指针数组

2 个答案: