1

与えられた範囲の隣接する値によって変換される範囲を作りたいです。これを達成する方法はありますか？したがって、以下のコードで説明されている隣接変換を作成したいと思います。

class Func{
public:
    typedef int result_type;

    int operator()(int a, int b, int c) {
        return a+b+c;        
    }

};

int main(){
    vector<int> v{1,1,1,1,1};
    auto rng = make_iterator_range( next(v.begin(), prev(v.end()) ) | adjacent_transformed( Func() );
    // rng shoud be {3, 3, 3}
}

もう1つの簡単な質問：Func()範囲アダプターにある右辺値を渡すのは安全ですboost::adaptors::transformedか？私がテストした限り、それは期待通りに動作します。安全な場合、Func（）は？にコピーされtransformedますか？Func()次に、コピーにコストがかかる場合はどうすればよいですか？

関連する質問ではない場合は申し訳ありませんが、ブースト範囲の内部を理解するのに十分なスキルがありません。

4

1 に答える 1

1

このようなものを使用できます。調整する必要があると思いますが、機能します。

template<typename Iterator, typename Functor>
class iterator : public boost::iterator_adaptor<
                 iterator<Iterator, Functor>,
                 Iterator,
                 typename std::iterator_traits<Iterator>::value_type,
                 boost::forward_traversal_tag,
                 typename std::iterator_traits<Iterator>::value_type,
                 typename std::iterator_traits<Iterator>::difference_type
            >, private Functor
{
   typedef boost::iterator_adaptor<
                 iterator<Iterator, Functor>,
                 Iterator,
                 typename std::iterator_traits<Iterator>::value_type,
                 boost::forward_traversal_tag,
                 typename std::iterator_traits<Iterator>::value_type,
                 typename std::iterator_traits<Iterator>::difference_type
            > base_t;
public:
   friend class boost::iterator_core_access;

   iterator(Iterator current, Functor fnc):
      base_t(current),
      Functor(fnc)
   {
   }

   typename std::iterator_traits<Iterator>::value_type dereference() const
   {
      Iterator i = this->base();
      const Functor& fnc = *this;
      return fnc(*boost::prior(i), *i, *boost::next(i));
   }
};

template<typename Iter, typename Func>
iterator<Iter, Func> make_iterator(Iter i, Func f)
{
   return iterator<Iter, Func>(i, f);
}

template<typename F, typename R>
struct trans_range : public boost::iterator_range<
                     iterator<typename boost::range_iterator<R>::type,
                     F>>
{
   typedef boost::iterator_range<
                     iterator<typename boost::range_iterator<R>::type,
                     F>> base_t;
   trans_range(F f, R& r) :
      base_t(make_iterator(boost::begin(r), f), make_iterator(boost::end(r), f))
   {
   }
};

template< class T >
struct holder
{
   T val;
   holder( T t ) : val(t)
   { }
};

template<typename T>
struct trans_holder : holder<T>
{
   trans_holder(T r) : holder<T>(r) { }
};

template< template<class> class Holder >
struct forwarder
{
   template< class T >
   Holder<T> operator()( T t ) const
   {
       return Holder<T>(t);
   }
};

template<typename R, typename F>
inline trans_range<F, R> operator |(R range, const trans_holder<F>& f)
{
   return trans_range<F, R>(f.val, range);
}

forwarder<trans_holder> transformed = forwarder<trans_holder>();

例

于 2013-02-18T08:04:22.200 に答える