更快的环路范围 (C++11）

我而言，问题在于您没有正确使用范围结构。

让我们退后一步：

void foo(std::vector<int> const& v) {
    for (int i: v) {
    }
}

请注意 range-for 如何遍历向量以提取整数。

出于某些原因，您选择不实现迭代器来从begin桥接到end，而是重用您正在迭代的副本，即使它只是非常轻微的变化，并且您正在做大量额外的工作（在副本和检查中）......

注意：std::iterator<double, ...>表示operator*应返回double&。

如果你想使用新的成语，你必须符合它的期望。

期望是使用迭代器进行迭代，而不是通过一遍又一遍地复制原始对象（略有修改）。这是C++成语。

这意味着您需要将对象切成两半：在迭代对象中拉出所有不可变的内容，以及在迭代器中修改的内容。

据我所知：

• _lower、_upper和_delta是固定
的
• 迭代变量_state

因此，您将拥有：

template <typename> class NumericRangeIterator
template <unsigned N> // makes no sense having a negative here
class NumericRange {
public:
    template <typename> friend class NumericRangeIterator;
    typedef NumericRangeIterator<NumericRange> iterator;
    typedef NumericRangeIterator<NumericRange const> const_iterator;
    static unsigned const Size = N;
    // ... constructors
    iterator begin(); // to be defined after NumericRangeIterator
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
private:
    std::array<double, N> _lower, _upper, _delta;
}; // class NumericRange
template <typename T>
class NumericRangeIterator: public
    std::iterator< std::array<double, T::Size>,
                   std::forward_iterator_tag >
{
public:
    template <unsigned> friend class NumericRange;
    NumericRangeIterator(): _range(0), _state() {}
    NumericRangeIterator& operator++() {
        this->advance();
        return *this;
    }
    NumericRangeIterator operator++(int) {
        NumericRangeIterator tmp(*this);
        ++*this;
        return tmp;
    }
    std::array<double, T::Size> const& operator*() const {
        return _state;
    }
    std::array<double, T::Size> const* operator->() const {
        return _state;
    }
    bool operator==(NumericRangeIterator const& other) const {
        return _state != other._state;
    }
    bool operator!=(NumericRangeIterator const& other) const {
        return !(*this == other);
    }

private:
    NumericRangeIterator(T& t, std::array<double, T::Size> s):
        _range(&t), _state(s) {}
    void advance(unsigned index = T::Size - 1);  // as you did
    void in_range(unsigned index = T::Size - 1); // as you did
    T* _range;
    std::array<double, T::Size> _state;
}; // class NumericRangeIterator

template <unsigned N>
auto NumericRange<N>::begin() -> typename NumericRange<N>::iterator {
    return iterator(*this, _lower);
}
template <unsigned N>
auto NumericRange<N>::end() -> typename NumericRange<N>::iterator {
    return iterator(*this, _upper);
}

通过所有这些设置，您可以编写：

for (auto const& state: nr) {
}

auto将被推导出为std::array<double, nr::Size>.

注意：不确定iterator是否有用，也许只是const_iterator，因为它在某种程度上是一个错误的迭代;你不能通过迭代器进入范围对象来修改它。

编辑：operator==太慢了，如何让它变得更好？

我建议作弊。

1/修改迭代器的构造函数

NumericRangeIterator(): _range(0), _state() {}               // sentinel value
NumericRangeIterator(T& t): _range(&t), _state(t._lower) {}

2/调整迭代以在末尾创建新的"哨兵"值

void advance() {
    // ...
    if (not this->in_range()) {        // getting out of the iteration ?
       *this = NumericRangeIterator(); // then use the sentinel value
    }
}

3/相应地更改begin和end定义

template <unsigned N>
auto NumericRange<N>::begin() -> typename NumericRange<N>::iterator {
    return iterator(*this);
}
template <unsigned N>
auto NumericRange<N>::end() -> typename NumericRange<N>::iterator {
    return iterator();
}

4/使用哨兵使==更加平等

bool operator==(NumericRangeIterator const& other) const {
    return _range == other._range and _state == other._state;
}

现在，在整个迭代过程中，==都短路了，因为其中一个_range为空，另一个不是。只有在最后一次调用时，才会真正比较两个_state属性。