2

std::tuple のすべての要素を設定する関数を再帰的に定義したいと考えています。boost::tuple の場合は、ここを見て、この例をコピーします。

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 を書いています。これは、すべての要素を設定する 1 つだけで、多くのことを行うためです。この種の foo の再帰的な定義を維持したいと考えていましたが、boost::tuples から std::tuples に切り替えました。

4

1 に答える 1

0

再帰はそのように実装できます

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());
于 2014-02-04T06:52:08.543 に答える