标签: iterator

我想在 for 循环中使用 next() 来处理下面的单词，而不推进 for 循环。

words = ["please", "do", "loop", "in", "order"]
for word in words:
    print word
    checknextword = str(next((word for word in words), None))

因此，我想打印：

>>>please
>>>do
>>>loop
>>>in
>>>order

但代码产生：

>>>please
>>>loop
>>>order

以下代码在 VS 2013 中引发两个编译器错误：

1. 模板函数定义抛出

   错误 C2061：语法错误：标识符“ iterator”

2. 该模板函数的特化会抛出异常

   错误 C2912：显式特化“ double getFillIn<double,double>(fillInOptions,double,std::_Tree_iterator<std::_Tree_val<std::_Tree_simple_types<std::pair<const _Kty,_Ty>>>>,inputLoader *,va_list)”不是函数模板的特化

谁能解释一下为什么吗？我相当确定第二个错误只是第一个错误的结果，但我不明白为什么它无法找出该iterator标识符。

#include <map>

template <typename T> class table {
};

template <typename S, typename T>
void f(S s, std::map<S, table<T>*>::iterator it);

我已经检查过像这样的其他问题，但似乎我并不总是创建一个新的迭代器来检查始终相同的对象。

这是代码

        Iterator<Map.Entry<Node, Float>> it = graph.nodeNeighboursIterator(e); 
        System.out.println("extracted node "+ e.getLabel() + " number of neighbours "+ e.sizeNeighbours());
        while(it.hasNext()) {
            System.out.print(i + " " + e.getLabel() + " " + it +"-");
            i++;
        }

该方法graph.nodeNeighboursIterator执行此操作

public Iterator<Map.Entry<Node, Float>> nodeNeighboursIterator(Node n) {
    return this.graph_weighted.get(n).entrySet().iterator();
}

打印System.out.println("extracted node "+ e.getLabel() + " number of neighbours "+ e.sizeNeighbours());出正确数量的邻居，但循环仍然没有结束他的循环，你对此有何看法？

我正在寻找一种在数组中找到给定 int 的方法，我找到了这个解决方案

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int data[] = {23, 45, 56, 12, 34, 56};
  int target = 56;

  int arraySize = sizeof(data) / sizeof(*data);

  bool isPresent = std::find(data, data + arraySize, target) != data + arraySize;

  if (isPresent) {
    cout << "The element is present";
  } else {
    cout << "The element is not present";
  }
  return 0;

现在我测试了并且它有效，但我想知道为什么在 find() 之后有这个 != data + arraySize ？希望得到解释

class Course(object):
    def __init__(self,cnum,name):
        self.name = name
        self.cnum = cnum
    def __str__(self):
        return 'Course:' , self.cnum  , self.name

class AssigendCourse(Course):
    def __init__(self,Course,dept,year,semester):
        self.name = Course.name
        self.cnum = Course.cnum
        if dept == 'SE' or dept == 'CE' or dept == 'CIE' or dept == 'ME':
            self.dept = dept
        else:
            self.dept = None
        if year >= 1 and year <= 4:
            self.year = year
        else:
            self.year = None
        if semester >= 1 and semester <= 3:
            self.semester = semester
        else:
            self.semester = …

我想使用迭代器打印一个向量:

#include <vector>
#include <istream>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <math.h>
using namespace std;

typedef vector<int> board;
typedef vector<int> moves;


int sizeb;
board start;
moves nmoves;
istringstream stin;


board readIn(std :: istream& in ) {
    int val;
    while (in >> val)
    start.push_back(val);

    sizeb = start[0];
    return start;
}


void printboard(board n) {
    int sizem = sizeb*sizeb;
    int i = 1;

    for (vector<int>::iterator it = start.begin() ; it != start.end(); ++it) {
        for (int j = 0; j < …

我正在尝试为ArrayList实现Iterator.我有一个ArrayList的接口,我也希望它实现Iterator,所以我可以在实际的ArrayList类中提供实现.界面如下:

public interface AListInterface<T> extends Iterator<T> {

       add();
       remove();
       ......

}

但是我收到错误说我必须导入java.util.Iterator.所以我很困惑,我想曾经导入过一个类,然后我可以使用已经实现的所有方法,如扫描仪.那么导入Iterator接口的重点是什么呢？同时还需要提供实现？

而且,如果我将AListInterface的标题更改为:

public interface AListInterface<T> extends Iterable<T> { }

它编译得很好,为什么可以扩展Iterable而不是Iterator？

为什么我要执行以下操作在Go中定义迭代器：

func f() func() int {
    i := 1
    return func() int {
        i++
        return i
    }
}

但这会导致变量未使用错误（i未使用）？

func f() func() int {
    i := 1
    return func() (i int) {
        i++
        return
    }
}

主功能：

func main() {
    iter := f()
    fmt.Println(iter())
    fmt.Println(iter())
    fmt.Println(iter())
    fmt.Println(iter())
}

对我而言，这两个版本的功能完全相同：它们f用作迭代器。f利用闭包（更具体地讲i）。第一个版本i通过命名返回类型引用它来显式地返回一个增量，第二个隐式地。

对我来说，这两个版本是相同的，那么为什么会出现错误？

现在的问题是很清楚的,为什么map()(以及zip()和filter(),但不会range()不返回一个迭代)返回一个迭代器？我的意思是我希望它只返回一个可迭代的,为什么这个选择呢？

这是编辑过的代码

vector<vector<int> > vec; 
vector<vector<int> >::iterator vit; 
vector<int>::iterator it;
for ( vit = vec.begin(); vit != vec.end(); ++vit)
{
    it = vit->begin();
    while(it != vit->end()) 
    {
        while(it != vit->end())
        {

            if( condition )
            {
                while( condition )
                {
                    //going back to certain it
                    //erase an element
                    it  = vit->erase(it);
                }
            }
            else
                ++it;
        }
        ++it;
    }
}

Run Code Online (Sandbox Code Playgroud)

内在的同时循环回到某一点.链接丢失.擦除元素而不复制迭代器并且在后循环中没有内存泄漏并再次向前移动？