Question

假设我有一些基于数组的代码可以被表达式模板使用。例如，我已经operator[]重载了这些数组，并且还重载了算术运算符+等。

现在我想让STL算法any_of在这样的数组上运行。简单的方法是做

ExprArray<double, N> b, c; // init etc. 
auto a = b + c;            // for (auto i = 0; i < N; ++i) { a[i] = b[i] + c[i]; }
auto res = std::any_of(begin(a), end(a), SomePred{});

当然，我希望能够使计算短路并具有修改的（基于范围的）lib::any_of

// only compute b[i] + c[i] until SomePred is satisified
auto res = lib::any_of(b + c, SomePred{}); // write as explicit loop over b[i] + c[i]

根据lib::any_of在其输入上写operator[]将完成该工作，与重载的operator+相同。但是，这需要对所有STL算法进行类似的重新实现，我可能会在这样的阵列上运行。

问题：假设我想通过仅修改ExprArray iterators 重新使用现有的基于范围的算法（Boost.Range，range-v3） 。是否可以修改ExprArray迭代器operator*和operator++，使其对基于范围的算法透明？

// only compute b[i] + c[i] until SomePred is satisified // needs to eventually dispatch to // for (auto i = 0; i < N; ++i) // if (SomePred(b[i] + c[i])) return true; // return false; auto res = ranges::any_of(b + c, SomePred{});

因此，如果算法版本实际上是根据迭代器实现的，那么循环for (auto it = first; it != last; ++it)需要*it知道它需要计算b[i] + c[i]和{{1必须知道它需要做++it。

Answer 1

这个问题似乎减少为＆＃34;我可以为表达式模板实现迭代器吗？＆＃34;我觉得这很简单。假设＆＃34;表达模板＆＃34;知道他们的size并且重载operator[]迭代器只需要保存对表达式对象的引用以及它所代表的范围内的偏移量：

template <class Expr>
class iterator {
public:
  using iterator_category = ranges::random_access_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using value_type = typename Expr::value_type;

  iterator() = default;
  constexpr iterator(Expr& e, difference_type i) :
    expr_{&e}, i_{i} {}

  constexpr bool operator==(const iterator& that) const {
    return assert(expr_ == that.expr_), i_ == that.i_;
  }
  constexpr bool operator!=(const iterator& that) const {
    return !(*this == that);
  }
  // Similarly for operators <, >, <=, >=

  value_type operator*() const {
    return (*expr_)[i_];
  }
  value_type operator[](difference_type n) const {
    return (*expr_)[i_ + n];

  iterator& operator++() & { ++i_; }
  iterator operator++(int) & { auto tmp = *this; ++*this; return tmp; }
  // Similarly for operator--

  iterator operator+(difference_type n) const {
    return iterator{expr_, i_ + n};
  }
  // Similarly for operators -, +=, and -=

  friend iterator operator+(difference_type n, const iterator& i) {
    return i + n;
  }

private:
    Expr* expr_;
    difference_type i_;
};

现在你只需要安排＆＃34; Expression模板＆＃34;让begin和end成员返回iterator{*this, 0}和iterator{*this, size()}。

Answer 2

这里的问题是b+c返回的内容。如果它返回真实ExprArray，则您无法进行懒惰评估。需要填充数组。您无法存储对b和c的引用，因为您不知道它们的生命周期。

但是，如果它将转换的LazyAddition返回到ExprArray执行添加，那么LazyAddition::iterator可以实现这一点很简单懒惰的补充也是如此。这里的风险是auto a = b+c - 这将创建一个带有待定引用的LazyAddition对象，而不是ExprArray对象。

如果您尝试将ExprArray实现为幕后智能指针，那么事情会变得非常糟糕。当然，您可以实现Copy-On-Write，以便b+c是一个ExprArray，它保持指向两个原始数组的指针。但是只要你调用T& ExprArray<T>::operator[]，COW就会启动，并将整个数组复制到单个元素 read 上！（const上的C ++运算符重载规则对operator[]不起作用，当参数本身为const时，const版本被选中，而不是用于读访问时

算法可以与表达模板兼容吗？

2 个答案: