标签: iterator

通常认为提供Iterator"无限"的实现是不好的做法; 即对hasNext()always(*)的调用返回true的位置？

通常我会说"是",因为调用代码可能表现不正常,但在下面的实现hasNext()中将返回true,除非调用者从List中删除迭代器初始化的所有元素; 即存在终止条件.你认为这是合法用途Iterator吗？它似乎没有违反合同,虽然我认为有人可能认为这是不直观的.

public class CyclicIterator<T> implements Iterator<T> {
  private final List<T> l;
  private Iterator<T> it;

  public CyclicIterator<T>(List<T> l) {
    this.l = l;
    this.it = l.iterator();
  }

  public boolean hasNext() {
    return !l.isEmpty();
  }

  public T next() {
    T ret;

    if (!hasNext()) {
      throw new NoSuchElementException();
    } else if (it.hasNext()) {
      ret = it.next();
    } else {
      it = l.iterator();
      ret = it.next();
    }

    return ret;
  }

  public void …

我在接受采访时被问到使用for循环使用迭代器的优点是什么？使用for循环迭代器的优点是什么？

任何人都可以回答这个问题,以便将来如果我面临类似的问题那么我可以回答这个问题

假设我们有一个Map : let m = new Map();, using m.values()返回一个map迭代器.

但是我不能使用forEach()或者map()在那个迭代器上并且在迭代器上实现while循环看起来像反模式,因为ES6提供了类似的功能map().

那么有没有办法map()在迭代器上使用？

谁能告诉我如何将迭代器增加2？

iter++可用 - 我必须这样做iter+2吗？我怎样才能做到这一点？

有没有办法检查迭代器(无论是来自向量,列表,双端队列......)是否(仍)可解除引用,即未被无效？

我一直在使用try- catch,但是有更直接的方法吗？

示例:(不起作用)

list<int> l;
for (i = 1; i<10; i++) {
    l.push_back(i * 10);
}

itd = l.begin();
itd++;
if (something) {
    l.erase(itd);
}

/* now, in other place.. check if itd points to somewhere meaningful */
if (itd != l.end())
{
    //  blablabla
}

如果我将迭代器指向向量的最后一个元素时,它会增加2怎么办？在这个询问如何通过2个元素调整到STL容器的迭代器的问题中,提供了两种不同的方法:

• 使用算术运算符的形式 - + = 2或++两次
• 或者使用std :: advance()

当迭代器指向STL容器的最后一个元素或更远时,我用VC++ 7测试了它们的边缘情况:

vector<int> vec;
vec.push_back( 1 );
vec.push_back( 2 );

vector<int>::iterator it = vec.begin();
advance( it, 2 );
bool isAtEnd = it == vec.end(); // true
it++; // or advance( it, 1 ); - doesn't matter
isAtEnd = it == vec.end(); //false
it = vec.begin();
advance( it, 3 );
isAtEnd = it == vec.end(); // false

我已经看过有时可以建议在遍历vector和其他容器时与vector :: end()进行比较:

for( vector<int>::iterator it = vec.begin(); it != vec.end(); …

我有以下问题涉及迭代使用定义的字符串的关联数组std::map.

-- snip --
class something 
{
//...
   private:
      std::map<std::string, std::string> table;
//...
}

在构造函数中,我使用与字符串数据相关联的字符串键对填充表.在其他地方我有一个方法toString返回一个字符串对象,该对象包含表对象中包含的所有键和相关数据(如key =数据格式).

std::string something::toString() 
{
        std::map<std::string, std::string>::iterator iter;
        std::string* strToReturn = new std::string("");

        for (iter = table.begin(); iter != table.end(); iter++) {
           strToReturn->append(iter->first());
           strToReturn->append('=');
           strToRetunr->append(iter->second());
           //....
        }
       //...
}

当我尝试编译时,我收到以下错误:

error: "error: no match for call to ‘(std::basic_string<char,
    std::char_traits<char>, std::allocator<char> >) ()’".

有人可以向我解释失踪的是什么,我做错了什么？hash_map在用户必须定义​​散列函数以便能够hash_map与std::string对象一起使用的情况下,我才发现有关类似问题的一些讨论.在我的情况下也可能是类似的东西？

我有一个std :: vector m_vPaths; 我会迭代这个向量并调用:: DeleteFile(strPath).如果我成功删除了该文件,我将从矢量中删除它.我的问题是,我可以使用两个向量吗？是否有不同的数据结构可能更适合我需要做的事情？

示例:使用迭代器几乎可以实现我想要的,但问题是一旦使用迭代器擦除,所有迭代器都将变为无效.

 std::vector<std::string> iter = m_vPaths.begin();
    for( ; iter != m_vPaths.end(); iter++) {
        std::string strPath = *iter;
        if(::DeleteFile(strPath.c_str())) {
            m_vPaths.erase(iter);   
                //Now my interators are invalid because I used erase,
                //but I want to continue deleteing the files remaining in my vector.    
        }
    }

我可以使用两个向量,我将不再有问题,但是有没有更好,更有效的方法来做我想做的事情？

顺便说一句,如果不清楚,m_vPaths就是这样声明的(在我的课上):

std::vector<std::string> m_vPaths;

我在互联网上找不到任何有效的例子,我可以看到它们之间的区别以及为什么选择一个而不是另一个.

在遍历ArrayList,HashMap和其他集合时,是否有任何性能测试结果可用于比较传统的for循环与Iterator？

或者我为什么要使用Iterator for循环,反之亦然？