Question

考虑以下代码：

class A
{
public:
    void aFoo() {}
};

class B
{
public:
    void bFoo() {}
};

class C
{
public:
    void c1Foo() {}
    void c2Foo() {}
};

无论代码架构如何，是否可以创建指向成员函数的指针向量，即使这些函数属于多个类？

在这种情况下，继承不是解决方案，因为我们不知道我们想在一个类中使用多少函数（C类有两个函数）。但我们知道它们都有相同的原型。

Answer 1

不同类的成员函数有不同的类型。因此，为了拥有任何同类容器（如std::vector或std::array），您需要将它们包装在一些可能代表它们的值类型中（如boost::variant或{{ 1}}）。

另一方面，如果您需要的只是特定类型的成员函数（例如boost::any）并且您不介意传递应该在其上调用它们的对象，那么您可以只存储它们为void()（对于此特定示例），只需在它们上面调用std::function<void()>，然后将它们存储在容器中。

作为一个例子，给出：

std::bind

您可以致电：

A a; B b; C c;
std::vector<std::function<void()>> vector {
    std::bind(&A::aFoo, a),
    std::bind(&B::bFoo, b),
    std::bind(&C::c1Foo, c),
    std::bind(&C::c2Foo, c)
};

Live demo

Answer 2

我不确定你想要达到什么目标，所以这可能不是很有帮助，但无论如何它都在这里。

正如其他人所说，你不能为此创建一个std :: vector，因为原型是不同的。但是你可以像这样创建一个std :: tuple：

std::tuple<void (A::*)(), void (B::*)(), void (C::*)()> x(&A::aFoo, &B::bFoo, &C::c1Foo);

假设您有一个类的实例，比如说A a，那么您可以在(a.*std::get<0>(x))()中调用该函数。

如果您已将对象存储在元组中，则可以迭代它们。以下代码将执行此操作（假设您的系统中有C ++ 14和Boost）

#include <iostream>
#include <tuple>
#include <type_traits>
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/adapted/std_tuple.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <functional>

class A
{
public:
    void aFoo()
    {
        std::cout << "A" << std::endl;
    }
};

class B
{
public:
    void bFoo()
    {
        std::cout << "B" << std::endl;
    }
};

class C
{
public:
    void c1Foo()
    {
        std::cout << "C1" << std::endl;
    }

    void c2Foo() {}
};

// functor used by boost to iterate over the tuple

template <class Tuple>
struct functor
{
    functor(Tuple t)
    : m_tuple(t)
    {
    }

    template <class X>
    void operator()(X& x) const
    {
        using namespace boost::mpl;
        using iter = typename find_if<Tuple, std::is_same < placeholders::_1, void (X::*)()> >::type;
        using type = typename deref<iter>::type;
        return (x.*std::get<type>(m_tuple))();
    }

private:
    Tuple m_tuple;
};

template <class Tuple>
functor<Tuple> make_functor(Tuple t)
{
    return functor<Tuple>(t);
}

int main()
{
    std::tuple<void (A::*)(), void (B::*)(), void (C::*)() > x(&A::aFoo, &B::bFoo, &C::c1Foo);
    std::tuple<A, B, C> y;
    boost::fusion::for_each(y, make_functor(x));
}

现场演示： http://coliru.stacked-crooked.com/a/e840a75f5b42766b

指向成员函数的指针向量与多个对象c ++

2 个答案: