C++ 指向对象数组内函数的指针数组

我有一个类Ghost，它有一个函数数组。这个班的鬼是一个 数组也是。如何调用main中的函数？我找不到调用此函数的方法。我见过一些例子，但没有这样的例子

class Ghost;

typedef void(Ghost::* Func)();

class Ghost
{
    public:
    Func func;

    public:

    void init() {};
    void running_random() {};
    void running_afraid() {};
    void dead() {};


    Ghost(){
        func = new Func[5];

        func[0] = &Ghost::init;
        func[1] = &Ghost::random;
        func[2] = &Ghost::running_afraid;
        func[4] = &Ghost::dead;
    }

};


int main()
{
    Ghost ph[4];

    ph[0]->*func[0](); //???
    ph[0]->(*func[0]()); //???
    (ph[0]->*func[0])(); //???
}

“我有一个类Ghost，它有一个函数数组”

这是不准确的。这些不仅仅是功能；它们是指向成员函数的指针，成员函数与它们自己的函数截然不同

这个代码中的错误

Func Func

应该是

Func*Func

你的方式，

Func

声明了一个指向成员变量的单指针，显然需要一个数组

错误的成员访问操作员。

您使用的是

操作符->*

，它应该用于指向对象的指针和指向成员的指针。但您没有指向对象的指针。给定<代码>幻影ph[4]这意味着

ph[0]

不是

Ghost*

，而是

Ghost

。因此，应使用

运算符。*

对

func

成员的访问不正确。

包含指向成员的指针的数组是

Ghost

的成员。使用成员访问操作符（

operator.*

或

operator->*

）不会神奇地授予成员

func

的访问权限。这正是您选择存储这些成员函数指针的地方。这些操作符的行为不像

操作符。

和

操作符->

对象和构件耦合不正确。

当使用

运算符将指向成员的指针与具体对象耦合。*

（或使用

运算符->*

将指向对象的指针）时，耦合的完整表达式应括在括号中，然后参数列表应在其自身的括号中。简言之，只有最后一个是有意义的（但由于上面的问题太多，它仍然被打破）

摘要

在所有这些之后，我们可以设计出一些实际可行的东西：

#include <iostream>

class Ghost;
typedef void(Ghost::*Func)();

class Ghost
{
public:
    Func* func;

public:

    void init() {std::cout << "here!!\n"; };
    void running_random() {};
    void running_afraid() {};
    void dead() {};

    Ghost(){
        func = new Func[5];

        func[0] = &Ghost::init;
        func[1] = &Ghost::running_random;
        func[2] = &Ghost::running_afraid;
        func[4] = &Ghost::dead;
    }
};


int main()
{
    Ghost ph[4];

    (ph[0].*ph[0].func[0])();
}

---

我留下了随之而来的内存泄漏，并意识到这可能不是您最初真正想要处理的体系结构。但这就是问题所在，也是您发布的代码的解决方案。

缺少的一点是您收到的实际错误。

（ph[0].*ph[0].func[0]）和顺便说一句，你的
Func是错误的。应该是
Func*Func。否则
func=newfunc[5]是胡说八道。同样被破坏的是，没有
Ghost:：random
。这应该是
Ghost:：running_random
@OP--我建议使用一个公共成员函数，通过指针调用该函数
void调用_func（int num）{（this->*func[num]）（）；}
--那么它就是
ph[0]。调用_func（0）main（）中的code>
。这是一个选项吗，即添加一个成员函数，使调用看起来更愉快？
#include <iostream>

class Ghost;
typedef void(Ghost::*Func)();

class Ghost
{
public:
    Func* func;

public:

    void init() {std::cout << "here!!\n"; };
    void running_random() {};
    void running_afraid() {};
    void dead() {};

    Ghost(){
        func = new Func[5];

        func[0] = &Ghost::init;
        func[1] = &Ghost::running_random;
        func[2] = &Ghost::running_afraid;
        func[4] = &Ghost::dead;
    }
};


int main()
{
    Ghost ph[4];

    (ph[0].*ph[0].func[0])();
}

here!!