调用指向成员函数的数组元素

Question

我在A类中有一个指向成员函数的数组，需要访问类B中的元素。我的问题是在尝试访问数组元素时返回1或者彼此不匹配的类型。

到目前为止我得到的是：

啊：

#include <vector>

class A {

public:
    typedef void(*func_ptr)(void);

    A();

    void func1();
    void func2();
    void func3();

    std::vector<void(A::*)()> aFuncs;

private:
    void appendFunc(void(A::*function)());

};

A.cpp

#include "A.h"

void A::func1 {...}
void A::func2 {...}
void A::func3 {...}

void A::appendFunc(void(A::*function)()) {
    aFuncs.push_back(function);
}

A::A() {
    appendFunc(&A::func1);
    appendFunc(&A::func2);
    appendFunc(&A::func3);
}

B.h

#include "A.h"

class B {

    A a;

    void test(int value);

};

B.cpp

#include "B.h"

void B::test(int value) {
    // here i need to access the elements of the array aFuncs, so that i can 
    // call the functions of A
    // something like
    a.aFuncs[value];
}

这里的问题，例如是的，如果我像这样使用a.aFuncs [value]总是返回1。

到目前为止，唯一对我有用的是：

void B::test(int value) {
    typedef void (a::*fn)();

    fn funcPtr = &a::func1;

    (a.*funcPtr)();
}

但是这个解决方案并没有使用数组，所以现在不是很有用。有人可以帮我解决这个问题吗？有什么基本的我不理解？

Answer 1

您需要使用a两次才能调用该函数。一旦访问向量然后再次调用该函数。怪异的样子

void B::test(int value) {
    (a.*a.aFuncs[value])();
}

为了使它更清洁，您可以将函数指针复制到变量中，然后使用该函数指针来调用该函数。那看起来像

void B::test(int value) {
    auto func = a.aFuncs[value];
    (a.*func)();
}

你可以看到它在这个Live Example工作。

Answer 2

如果(a.*aFuncs[value])()是全球性的，aFuncs的作品。在你的例子中，你应该能够做(a.*a.aFuncs[value])()。

#include <iostream>
#include <array>
struct Foo {
    int one()   { std::cout << "one\n"; return 1; }
    int two()   { std::cout << "two\n"; return 2; }
    int three() { std::cout << "three\n"; return 3; }
};
std::array<int(Foo::*)(), 3> a = {{
    &Foo::one,
    &Foo::two,
    &Foo::three,
}};
int main() {
    Foo f;
    std::cout << "1: " << (f.*a[0])() << "\n";
    std::cout << "2: " << (f.*a[1])() << "\n";
    std::cout << "3: " << (f.*a[2])() << "\n";
}

输出：

one
1: 1
two
2: 2
three
3: 3

https://ideone.com/dd5TWP

Answer 3

如果您的编译器支持，您还可以通过利用std :: function来使用替代方法：

std::array<std::function<void(Foo&)>, 3> a = {
    &Foo::one,
    &Foo::two,
    &Foo::three
};

然后打电话：

foo.a[0](foo);