7

被困在 TR1 领域，对于测试程序，我需要对许多特定类型的对象执行某些操作。我有几个元组类型定义，如下所示： 

typedef std::tr1::tuple< bool
                       , signed char
                       , signed short
                       , signed int
                       , signed long long
                       , unsigned char
                       , unsigned short
                       , unsigned int
                       , unsigned long long >  integral_types;

从每个元组类型中创建一个对象。然后我有类似这样的功能模板：

template<typename T>
void invoke_operation_1(T& obj);

这些需要为元组对象中的所有对象调用。

我如何在 C++03 中做到这一点？

4

3 回答 3

8

刚刚在 Bristol 中为 C++14 完成了一项功能来解决这个问题。处理起来并不难。

对于更简单的情况，您可以使用递归模板。尽管没有部分功能专业化等，但它有点混乱。

template<typename Tup, std::size_t N> struct visit_detail {
     template<typename F> static void call(Tup& t, F f) {
         f(std::tr1::get<N>(t));
         return visit_detail<Tup, N+1>::call(t, f);
     }
};
template<typename Tup> struct visit_detail<Tup, std::tr1::tuple_size<Tup>::value> {
    template<typename F> static void call(Tup& t, F f) {}
}

template<typename Tup, typename F> void visit(Tup& t, F f) {
    return visit_detail<Tup, 0>::call(t, f);
}

这里 f 可以是硬编码的，也可以是参数函数对象或任何你想要的。

于 2013-05-03T14:06:02.870 回答
3

如果您需要为元组中的每个对象调用相同的模板化函数，则可以使用boost::fusion 。例如 

template<typename T>
void invoke_operation_1(T& obj)
{
    std::cout << obj << std::endl;
}

struct executor
{
    template<typename T>
    void operator()(T& t) const
    {
        invoke_operation_1(t);
    }
};

typedef boost::tuple< bool
                       , signed char
                       , signed short
                       , signed int
                       , signed long long
                       , unsigned char
                       , unsigned short
                       , unsigned int
                       , unsigned long long >  integral_types;
int main()
{
    integral_types t(true, 0, 1, 2, 3, 4, 5, 6, 7);
    boost::fusion::for_each(t, executor());
    return 0;
}
于 2013-05-03T14:21:01.003 回答
0 
template<typename tup, typename N>
struct visit_detailImpl {
    template<typename f>
    static void call(tup& t, f f) {
        f(std::tr1::get<N::value>(t));
        return visit_detailImpl<tup, std::integral_constant<std::size_t, N::value + 1> >::call(t, f);
    }
};
template<typename tup> // end recursion struct
struct visit_detailImpl<tup, std::integral_constant<std::size_t, std::tr1::tuple_size<tup>::value> > {
    template<typename f>
    static void call(tup& t, f f) {}
};
template<typename tup, typename Fn>
void for_each_tup(tup& t, Fn f) {
    return visit_detailImpl<tup, std::integral_constant<std::size_t, 0> >::call(t, f);
}
于 2016-04-02T16:42:47.357 回答