Question

我想创建一个由给定范围的相邻值转换的范围。有没有办法实现这个目标？因此，我想创建一个在下面的代码中描述的adjacent_transformed。

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}
}

另一个快速问题：将Func()的rvalue传递到范围适配器boost::adaptors::transformed中是否安全？据我测试，它按预期工作。如果它是安全的，Func（）是否被复制到transformed？那么，如果Func()复制成本高昂，该怎么办？

很抱歉，如果这不是一个相关的问题，但我不够熟练，无法理解增强范围的内部。

Answer 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>();

example

增强范围适配器类似于转换，可以访问相邻的元素

1 个答案: