Question

在大多数通用术语中，我的问题是以下一个：在编译时定义一系列异构函数指针（具有可能不同的arity），稍后需要在运行时以任意顺序迭代和调用。

将自己约束到C ++，最合适的容器，迭代和调用机制是什么？

这个问题是由一个真实世界的情况所驱动的，我后来发现了一个更简单的解决方案，不涉及元组，但它本质上更专业。

最初我试图做这样的事情：

//type variables Y... have to be convertible to parameters of every function from the tuple std::tuple<T...> in order for this to compile
template<size_t n, typename... T, typename... Y>
void callFunNth(std::tuple<T...> &tpl, size_t i, Y... args) {
    if (i == n)
        std::get<n>(tpl)(args...); 
    else
        callFunNth<(n < sizeof...(T)-1? n+1 : 0)>(tpl, i, args...);
}
template<typename... T, typename... Y>
void  callFun(std::tuple<T...> &tpl, size_t i, Y... args) {
    callFunNth<0>(tpl,i, args...);
}

int main() 
{
    using T1 = int;
    namespace mpi = boost::mpi;
    //Several instantiations of boost::mpi::reduce algorithm I am interested in
    auto algs = make_tuple(boost::bind((void (*)(const mpi::communicator&, const T1*, T1, T1*, std::plus<T1>, int))mpi::reduce<T1, std::plus<T1>>, _1, _2, _3, _4, std::plus<T1>(), _5),
                           boost::bind((void (*)(const mpi::communicator&, const T1*, T1, T1*, mpi::minimum<T1>, int))mpi::reduce<T1, mpi::minimum<T1>>, _1, _2, _3, _4, mpi::minimum<T1>(), _5),
                           boost::bind((void (*)(const mpi::communicator&, const T1*, T1, T1*, std::minus<T1>, int))mpi::reduce<T1, std::minus<T1>>, _1, _2, _3, _4, std::minus<T1>(), _5)
                          );

    //Iterate through the tuple and call each algorithm
    for(size_t i=0; i < std::tuple_size<decltype(algs)>::value;i++)
        callFun(algs, i, /*actual arguments to each algorithm*/);
}

这种方法的问题在于，callFunNth在所有提供的参数中进行编译必须是类型可转换为所提供的元组内所有函数的参数，这严重限制了所述函数的异构性并迫使一个人使用std :: bind或boost :: bind来解决这个问题。

当类型可以相互转换时，可以写下以下内容：

template <typename T, typename U>
void fja(T x, U y) { 
    std::cout << x << std::endl;
}
auto funs = std::make_tuple(fja<int,std::string>, fja<double,std::string>, fja<char,std::string>);
callFun(funs, 2, 'a', "Char");
callFun(funs, 1, 2.45, "Decimal");
callFun(funs, 0, 1, "Integer");

分别向stdout发送'a'，'2.45'和'1'

Answer 1

您应该将函数对象存储为std::vector<std::function<const boost::mpi::communicator&, const T1*, int, T1*, int>>。管理起来要容易得多。

如果必须使用函数元组，请参阅下文。

C ++标准库非常需要编译时iota。

如果你需要的是使用相同的参数调用所有函数，这是另一种方法。首先，我们构造可变整数列表integers<0, 1, 2, ..., n-1>（从https://github.com/kennytm/utils/blob/master/vtmp.hpp复制）：

template <size_t... ns> struct integers { template <size_t n> using push_back = integers<ns..., n>; }; namespace xx_impl { template <size_t n> struct iota_impl { typedef typename iota_impl<n-1>::type::template push_back<n-1> type; }; template <> struct iota_impl<0> { typedef integers<> type; }; } template <size_t n> using iota = typename xx_impl::iota_impl<n>::type;

然后我们直接使用unpack操作：

template <typename... T, size_t... ns, typename... Y> void call_all_impl(const std::tuple<T...>& funcs, const integers<ns...>&, Y... args) { __attribute__((unused)) auto f = {(std::get<ns>(funcs)(args...), 0)...}; } template <typename T, typename... Y> void call_all(const T& funcs, Y&&... args) { call_all_impl(funcs, iota<std::tuple_size<T>::value>(), std::forward<Y>(args)...); }

例如，

int main() { call_all(std::make_tuple([](int x, double y){ printf("1: %d %g\n", x, y); }, [](double x, int y){ printf("2: %e/%d\n", x, y); }, [](int x, int y){ printf("3: %#x %#x\n", x, y); }), 4, 9); }

打印

1: 4 9 2: 4.000000e+00/9 3: 0x4 0x9

稍作修改可以使它只调用在运行时选择的i - 参数。

template <typename... T, size_t... ns, typename... Y> void call_one_impl(const std::tuple<T...>& funcs, size_t which, const integers<ns...>&, Y... args) { __attribute__((unused)) auto f = {(ns == which && (std::get<ns>(funcs)(args...), 0))...}; } template <typename T, typename... Y> void call_one(const T& funcs, size_t which, Y&&... args) { call_one_impl(funcs, which, iota<std::tuple_size<T>::value>(), std::forward<Y>(args)...); }

例如，

int main() { auto t = std::make_tuple([](int x, double y){ printf("1: %d %g\n", x, y); }, [](double x, int y){ printf("2: %e/%d\n", x, y); }, [](int x, int y){ printf("3: %#x %#x\n", x, y); }); call_one(t, 2, 6.5, 7.5); call_one(t, 0, 4, 9); call_one(t, 1, 5.8, 8); }

打印

3: 0x6 0x7 1: 4 9 2: 5.800000e+00/8

Answer 2

异构容器的首选库是Boost.Fusion。正如您将在该网站上看到的那样，他们使用编译时多态函数来完成这样的任务。

Answer 3

我认为使用元组存储函数是个坏主意对我来说，更简单的是创建函数指针

typedef impl_defined pointer_to_function

并将功能推送到

std::vector<pointer_to_function>

Answer 4

在对这个问题进行一些修补之后，我认为使用类型联合可能是解决它的一种相当好的方法，尽管我担心当前形式中所述的问题有点过于模糊而不值得单一的最佳答案。

无论如何，这就是人们如何使用C ++中的类型联合解决问题的方法：

int main()
{
    auto f1 = [](int x) { std::cout << x << std::endl;};
    auto f2 = [](int x, std::string y) { std::cout << y << std::endl;};
    auto f3 = [](const std::vector<int> &x) { std::copy(x.begin(),x.end(),std::ostream_iterator<int>(std::cout," "));};
    using tFun1 = decltype(f1);
    using tFun2 = decltype(f2);
    using tFun3 = decltype(f3);
    using funUnion = boost::variant<tFun1,tFun2,tFun3>;

    std::vector<funUnion> funs = {f1,f2,f3};
    for(auto &ff : funs) {
        if (tFun1* result = boost::get<tFun1>(&ff)) (*result)(2);
        else
        if (tFun2* result = boost::get<tFun2>(&ff)) (*result)(2,"Hello!");
        else
        if (tFun3* result = boost::get<tFun3>(&ff)) (*result)({1,2,3,4,5});
    }
}

迭代和调用元组内的异构函数

4 个答案: