指向不同類函數的函數指針數組

Question

我有一堂MyClass。 在其中，我想創建一個函數指針數組，並使用另一個類（MemberClass）的函數初始化該數組。 MyClass具有一個指向MemberClass的指針作為成員。 但是我得到這個編譯時錯誤錯誤C2440：'initializing'：無法從'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的函數數組。 std::bind Magic將提供方法所需的hidden 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;
}