标签: iterator

一般来说,为了效率和速度目的,缓存一个结束迭代器(特别是STL容器)是个好主意吗？比如在下面的代码中:

std::vector<int> vint;
const std::vector<int>::const_iterator end = vint.end();
std::vector<int>::iterator it = vint.begin();

while (it != end)
{
   ....
   ++it;
}

在什么条件下最终价值会失效？从容器中擦除会导致所有 STL容器中的结尾无效还是只有一些？

// erasing from map
#include <iostream>
#include <map>
using namespace std;

int main ()
{
  map<char,int> mymap;
  map<char,int>::iterator it(mymap.begin());

  // insert some values:
  mymap['a']=10;
  mymap['b']=20;
  mymap['c']=30;
  mymap['d']=40;
  mymap['e']=50;
  mymap['f']=60;

  it=mymap.find('a');
  mymap.erase (it);                   // erasing by iterator

  // show content:
  for (; it != mymap.end(); it++ )
    cout << (*it).first << " => " << (*it).second << endl;
  return 0;
}

为什么这会产生类似的输出

a => 10
b => 20
c => 30
d => 40
e => 50
f => 60

不 …

我收到一个迭代器作为参数,我想迭代两次值.

public void reduce(Pair<String,String> key, Iterator<IntWritable> values,
                   Context context)

可能吗 ？怎么样 ？签名是由我正在使用的框架(即Hadoop)强加的.

- 编辑 -
最后方法的真实签名reduce是iterable.我被这个wiki页面误导了(这实际上是我发现的wordcount的唯一非弃用(但错误的)示例).

我正在实现本质上是一个容器对象(尽管它确实有一些自己的逻辑).我希望能够遍历此类中的字段中的项目(这只是一个简单的列表).我应该重新实现__iter__和next我的课还是可以接受的返回列表的迭代器,像这样:

class X:

    def __init__(self):
       self.list = []

    def __iter__(self):
        return self.list.__iter__()

我不确定这是否会导致任何不良行为.

有没有办法让python中的迭代器指向该项而不增加迭代器本身？例如,如何使用迭代器实现以下内容:

looking_for = iter(when_to_change_the_mode)
for l in listA:
    do_something(looking_for.current())
    if l == looking_for.current():
        next(looking_for)

根据C++标准(3.7.3.2/4)使用(不仅是解除引用,还有复制,转换,其他任何),无效指针是未定义的行为(如果有疑问也会看到这个问题).现在,遍历STL容器的典型代码如下所示:

std::vector<int> toTraverse;
//populate the vector
for( std::vector<int>::iterator it = toTraverse.begin(); it != toTraverse.end(); ++it ) {
    //process( *it );
}

std::vector::end()是超出容器最后一个元素的假设元素的迭代器.那里没有元素,因此使用指针通过迭代器是未定义的行为.

那么!= end()工作怎么样呢？我的意思是为了进行比较,需要构造迭代器包装无效地址,然后必须在比较中使用该无效地址,这也是未定义的行为.这样的比较合法吗？为什么？

我的班级可以有孩子,所以我需要暴露迭代器.render类需要反向迭代它们,这就是我有反向迭代器的原因.但有没有办法减少这些因为它似乎很多:

std::vector<AguiWidget*>::iterator          getChildBeginIterator();
std::vector<AguiWidget*>::reverse_iterator  getChildRBeginIterator();
std::vector<AguiWidget*>::iterator          getChildEndIterator();
std::vector<AguiWidget*>::reverse_iterator  getChildREndIterator();

std::vector<AguiWidget*>::const_iterator            getChildBeginIterator() const;
std::vector<AguiWidget*>::const_reverse_iterator    getChildRBeginIterator() const;
std::vector<AguiWidget*>::const_iterator            getChildEndIterator() const;
std::vector<AguiWidget*>::const_reverse_iterator    getChildREndIterator() const;

std::vector<AguiWidget*>::iterator          getPrivateChildBeginIterator();
std::vector<AguiWidget*>::reverse_iterator  getPrivateChildRBeginIterator();
std::vector<AguiWidget*>::iterator          getPrivateChildEndIterator();
std::vector<AguiWidget*>::reverse_iterator  getPrivateChildREndIterator();

std::vector<AguiWidget*>::const_iterator            getPrivateChildBeginIterator() const;
std::vector<AguiWidget*>::const_reverse_iterator    getPrvateChildRBeginIterator() const;
std::vector<AguiWidget*>::const_iterator            getPrivateChildEndIterator() const;
std::vector<AguiWidget*>::const_reverse_iterator    getPrivateChildREndIterator() const;

谢谢

以下函数的最通用语法是什么:

template<IteratorType> void myFunction(const IteratorType& myIterator)
{
    _ptr = &myIterator[0];
}

它需要一个迭代器myIterator(它可以是一个原始指针),目标是将指向的对象的地址分配myIterator给一个原始指针_ptr.目前我使用&myIterator[0]但我意识到只有随机访问迭代器才有operator [].

那么有一种语法适用于所有类型的标准迭代器和指针吗？

在python中我尝试使用赋值创建我的迭代器的副本,但是它创建了一个迭代器的副本,它引用了原始迭代器本身.例如:

my_list = [5, 4, 3,2]
first_it = iter(my_list)
second_it = first_it 
print next(first_it )        #it will print 5
print next(second_it)        #it will print 4
print next(first_it )        #it will print 3

正如您在示例中看到的,first_it和second_it都引用相同的迭代器对象.是否可以创建一个不引用原始对象的迭代器对象的副本？

注意 此问题是关于如何按值创建迭代器对象的副本.所以不要提及for item in my_list:类似的解决方案.
提前致谢

#include <vector>
#include <iostream>

using namespace std;

int main()
{
    vector<int> coll;

    decltype(std::begin(std::declval<vector<int>>()))
        pos_1 = coll.begin();
    auto pos_2 = coll.begin();

    cout << typeid(decltype(pos_1)).name() << endl;
    cout << typeid(decltype(pos_2)).name() << endl;
}

我的编译器是clang 4.0.输出是:

class std::_Vector_const_iterator<class std::_Vector_val<struct std::_Simple_types<int> > >
class std::_Vector_iterator<class std::_Vector_val<struct std::_Simple_types<int> > >

Run Code Online (Sandbox Code Playgroud)

这意味着:pos_1 = pos_2;没关系,虽然pos_2 = pos_1;不行.

为什么std::begin()总是返回const_iterator而不是iterator在这种情况下？