C++ 如何将迭代器增加2？

有人能告诉我如何将迭代器增加2吗

---

iter++

可用-我必须执行

iter+2

？如何实现这一点？

您可以使用“加法赋值”操作符

iter += 2;

此方法适用于不是随机访问迭代器的迭代器，但在与随机访问迭代器一起使用时，它仍然可以通过实现专门化，使其效率不低于

iter+=2

。

在你的例子中，n是2

这个函数的美妙之处在于，如果“it”是一个随机访问迭代器，那么

it += n

使用操作（即向量：：迭代器）。否则，它将被渲染为

for(int i = 0; i < n; i++)
    ++it;

for（int i=0；i

---

（即列表：：迭代器）

非常简单的答案：

++++iter

答案很长：

你真的应该习惯于写

++iter

，而不是

iter++

。后者必须返回与新值不同的旧值（副本）；这需要时间和空间

---

请注意，前缀increment（

++iter

）取左值并返回左值，而后缀increment（

iter++

）取左值并返回右值。

如果不知道容器中是否有足够的下一个元素，则需要在每个增量之间检查容器的末尾。无论是++还是std:：advance都无法为您完成此任务

if( ++iter == collection.end())
  ... // stop

if( ++iter == collection.end())
  ... // stop

您甚至可以使用自己的绑定安全高级功能

---

如果您确信不会超过末尾，那么std:：advance（iter，2）是最好的解决方案。

如果您没有可修改的迭代器左值，或者希望获得给定迭代器的副本（保留原始迭代器不变），那么C++11将提供新的帮助函数-/：

我们也可以两者兼用，但两者之间有区别

advance

修改其参数并不返回任何内容。因此，它可以用作：

vector<int> v;
v.push_back(1);
v.push_back(2);
auto itr = v.begin();
advance(itr, 1);          //modifies the itr
cout << *itr<<endl        //prints 2

---

假设列表大小可能不是步骤的偶数倍，则必须防止溢出：

static constexpr auto step = 2;

// Guard against invalid initial iterator.
if (!list.empty())
{
    for (auto it = list.begin(); /*nothing here*/; std::advance(it, step))
    {
        // do stuff...

        // Guard against advance past end of iterator.
        if (std::distance(it, list.end()) > step)
            break;
    }
}

根据采集实现，距离计算可能非常缓慢。下面是最佳的，更具可读性。可以将闭包更改为实用程序模板，并通过常量引用传递列表结束值：

const auto advance = [&](list_type::iterator& it, size_t step)
{
    for (size_t i = 0; it != list.end() && i < step; std::next(it), ++i);
};

static constexpr auto step = 2;

for (auto it = list.begin(); it != list.end(); advance(it, step))
{
    // do stuff...
}

const auto advance=[&]（列表类型：：迭代器&it，大小步骤）
{
对于（size_t i=0；it！=list.end（）&&i

如果没有循环：

static constexpr auto step = 2;
auto it = list.begin();

if (step <= list.size())
{
    std::advance(it, step);
}

static constexpr auto step=2；
auto it=list.begin（）；
if（步骤）我想知道++iter++是否可以工作，但我认为这会让人困惑。如果迭代器当前指向最后一个元素，会发生什么？在增量之后它会指向哪里？@Xetius：你不应该这样做。这是未定义的行为。++iter++绑定为++（iter++），iter++不是可修改的左值，因此你不能“做”++（iter++）。如果允许，它可能不会达到预期效果。这不适用于所有迭代器类型。只需要RandomAccessIterator来支持加法。根据答案范围判断，您可能需要澄清您的问题。是的。它是什么类型的迭代器？显示一些代码。如果迭代器当前指向o最后一个元素？在增量之后它会指向哪里？我用VC++尝试过-它只是前进并与vector:：end（）进行比较然后返回错误。我想这是不确定行为的直接方式。是的，如果你要做STD：：用“2”前进，或者+= 2，或者两个“++”，而不检查中间的“结束”，那么你需要一些外部保证，你不会超过一个结束。（例如，您可能知道您正在迭代一个集合中的偶数（从零开始）项，该集合保证有偶数个项。）如果
iter
是原始指针（某些迭代器类型可以是），则next（iter，2）和next（iter，2）未定义行为之间的区别是什么如果我有这样一个迭代器：
map:：iterator iter；for（iter=variations.begin（）；iter！=variations.end（）；iter++）{map:：iterator it_tmp=std:：next（iter，1）；//增加1 it_tmp=std:：next（iter，2）；//增加2}
国际热核聚变实验堆会增加2吗？还是国际热核聚变实验堆只会影响它？@HaniGoc Only it\u tmp什么是“std:：advance（it，step）；”的时间复杂度。
static constexpr auto step = 2;

// Guard against invalid initial iterator.
if (!list.empty())
{
    for (auto it = list.begin(); /*nothing here*/; std::advance(it, step))
    {
        // do stuff...

        // Guard against advance past end of iterator.
        if (std::distance(it, list.end()) > step)
            break;
    }
}

const auto advance = [&](list_type::iterator& it, size_t step)
{
    for (size_t i = 0; it != list.end() && i < step; std::next(it), ++i);
};

static constexpr auto step = 2;

for (auto it = list.begin(); it != list.end(); advance(it, step))
{
    // do stuff...
}

static constexpr auto step = 2;
auto it = list.begin();

if (step <= list.size())
{
    std::advance(it, step);
}