Question

我有一个向量容器，我想使用当前迭代器对前一个迭代器对其内容的值进行减法运算，非常感谢任何帮助

Answer 1

vector<MyClass>::iterator itPrevious = my_vec.begin();
vector<MyClass>::iterator itCurrent = itPrevious;
if (itCurrent != my_vec.end())
{
    for (++itCurrent;  itCurrent != my_vec.end();  ++itCurrent)
    {
        // do something with itPrevious and itCurrent
        itPrevious = itCurrent;
    }
}

Answer 2

if(v.size() < 2)
   return;
auto curr = v.begin();
auto next = curr;
++next;
do
{
  whatever(*next - *curr );
  curr = next++;
} while( next != v.end() )

Answer 3

鉴于你要求一个向量，你可以使用迭代算术：

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v{ 1, 2, 3, 4 };
    for ( auto i = v.begin(); i != v.end(); ++i ) {
        if ( i != v.begin() )
            *i = *i - *(i-1);
    }
    for ( auto i : v )
        std::cout << i << std::endl;
}

Answer 4

std::vector的迭代器是RandomAccessIterator，因此您可以对其执行整数运算。因此，只要从begin() + 1开始迭代，就不需要单独的“当前”和“上一个”指针：

vector<Foo> myVec = ...;
if(myVec.size() > 1) { 
    for(vector<Foo>::iterator iter = myVec.begin()+1; iter != myVec.end(); iter++) {
        Foo current = *iter;
        Foo previous = *(iter - 1);
        Foo subtraction = current - previous;
        ...
    }
}

当然，如果向量中的元素少于两个，则无法减去当前元素和上一个元素。如果你知道你的输入向量总是至少有两个元素，那么大小检查可能是多余的，但为了安全起见，我把它包括在内。

Answer 5

替代方案：

for (auto previous = v.begin(), current = previous + 1, end = v.end();
    previous != end && current != end;
    ++previous, ++current)
{
    std::cout << *current << " - " << *previous << " = " << *current - *previous << std::endl;
}

Answer 6

有三种或多或少的优雅方法可以解决您的问题。

定义新的仿函数

并在for_each次迭代

中使用它

template<class T>
struct substractor {
    substractor() : last(nullptr) {}
    void operator()(T& item) const
    {
        if(last != nullptr)
            *last -= item;
        last = &item;
    }
    mutable T* last;
};
...
vector<int> v = {3, 2, 1};
for_each(v.begin(), v.end(), substractor<int>());

定义新算法

这里的某种对就地变换

template<typename It, typename Op>
void pair_transform(It begin, It end, Op op){
    while(begin != end)
    {
        It next = std::next(begin);
        if(next == end) break;
        *begin = op(*begin, *next);
        ++begin;
    }
}
...
vector<int> w = {3, 2, 1};
pair_transform(w.begin(), w.end(), std::minus<int>());

保持标准，使用转换

恕我直言最好的一个:)简洁，标准，无处可寻，以了解此代码。

vector<int> z = {3, 2, 1};
std::transform(z.begin(), z.end() - 1, z.begin() + 1, z.begin(), 
    std::minus<int>());

如何在c ++向量上跟踪当前和以前的迭代器？

6 个答案:

定义新的仿函数

定义新算法

保持标准，使用转换