c++ - 我可以从 std::tuple 获得 "cons list"行为吗？

Question

我想递归地定义一个函数来设置 std::tuple 的所有元素。如果它是一个 boost::tuple，我会简单地看一下 here并复制这个例子:

inline void set_to_zero(const null_type&) {};

template <class H, class T>
inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }

到目前为止，我找不到任何关于 std::tuple 的东西。有什么接近的吗？

更新:好的，我需要进一步充实这个问题。

template<typename T>
struct simple_setter
{
    void set(T &target);  // somebody else's stuff, defined elsewhere
};


template<typename Tuple> class foo;

template<>
struct foo<boost::tuple<>>
{
    foo()  {}
    void set(boost::tuple<> &target)  {}
};

template<typename E, typename... Es>
struct foo<boost::tuple<E, Es...>>
{
    explicit foo(const simple_setter<E> &head_setter, const simple_setter<Es> & ... other_setters) :
         _head(head_setter),
         _tail(other_setters)
    {}

    void set(boost::tuple<E, Es...> &target) {
        _head.set(target.get_head()),
        _tail.set(target.get_tail())
    }

    // more methods to do other things

    const simple_setter<E> &_head;
    const foo<boost::tuple<Es ...>> _tail;
};

我正在编写包装元组的 foo 类，以便做很多事情，其中​​之一是设置所有元素。我希望保留 foo 的这种递归定义，但要从 boost::tuples 切换到 std::tuples。

Answer 1

递归可以这样实现

template < typename _Tuple >
inline void set_to_zero(_Tuple& tuple, std::integral_constant<size_t, 0>)
{ 
}

template < typename _Tuple, size_t N >
inline void set_to_zero(_Tuple& tuple, std::integral_constant<size_t, N>)
{
    set_to_zero(tuple, std::integral_constant<size_t, N - 1>());
//  action(std::get<N - 1>(tuple));
}

template < typename _Tuple >
inline void set_to_zero(_Tuple& tuple)
{ 
    set_to_zero(tuple, std::integral_constant<size_t, std::tuple_size<_Tuple>::value>());
}

或更一般的形式

template < typename _Tuple, typename _Func >
inline void for_each(_Tuple& tuple, _Func func_, std::integral_constant<size_t, 0>)
{
}

template < typename _Tuple, typename _Func, size_t N >
inline void for_each(_Tuple& tuple, _Func func_, std::integral_constant<size_t, N>)
{
    for_each(tuple, func_, std::integral_constant<size_t, N - 1>());
    func_(std::get<N - 1>(tuple));
}

template < typename _Tuple, typename _Functor >
inline void for_each(_Tuple& tuple, _Functor func_)
{
    for_each(tuple, func_, std::integral_constant<size_t, std::tuple_size<_Tuple>::value>()); 
}

广义形式的使用示例

    struct DoSomething
    {
        void operator()(int a)  {} // overload for int
        void operator()(double a) {} // overload for double
    };

    std::tuple<int, double> tuple_;

    for_each(tuple_, DoSomething());