Question

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

到目前为止，我得到的是：

A.H：

#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

如果onActivityResult(...)是全局的，则{p> (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";
}

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);

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

3 个答案: