标签: iterator

我创建了一个自定义通用队列,它实现了一个通用的IQueue接口,该接口使用System.Collections.Generic命名空间中的通用Qu​​eue作为私有内部队列.示例已清除不相关的代码.

public interface IQueue<TQueueItem>
{
    void Enqueue(TQueueItem queueItem);
    TQueueItem Dequeue();
}

public class CustomQueue<TQueueItem> : IQueue<TQueueItem>
{
    private readonly Queue<TQueueItem> queue = new Queue<TQueueItem>();
    ...
    public void Enqueue(TQueueItem queueItem)
    {
        ...
        queue.Enqueue( queueItem );
        ...
    }

    public TQueueItem Dequeue()
    {
        ...
        return queue.Dequeue();
        ...
    }
}

我希望保持与核心实现的一致性,并注意到核心Queue实现了IEnumerable,所以我将通过在类上显式实现IEnumerable或使用IQueue接口继承它来做同样的事情.

我想知道的是,当列举队列时,每个移动接下来要将下一个项目出列？我已经使用反射器来了解微软是如何做到的,他们所做的只是逐步通过队列私有阵列,但微软远非绝对不可靠,所以我想得到一般意见.

public class CustomQueue<TQueueItem> : IQueue<TQueueItem>, IEnumerable<TQueueItem>
{
    ...

    public IEnumerator<TQueueItem> GetEnumerator()
    {
        while (queue.Count > 0)
        {
            yield return Dequeue();
        }
    }

    //Or

    public IEnumerator<TQueueItem> GetEnumerator()
    {
        return queue.GetEnumerator();
    }

    ...
} …

我有一个实现Enumeration<T>接口的类,但Java的foreach循环需要Iterator<T>接口.是否有一个Enumeration到IteratorJava的标准库适配器？

我不明白为什么vector在重新分配时应该使迭代器失效.

难道只是通过在迭代器中存储偏移量而不是指针来阻止这种情况吗？

为什么vector没有这样设计？

在IteratorSun中添加了remove方法来删除集合中最后访问的元素.为什么没有添加方法来向集合中添加新元素？它可能对集合或迭代器有什么样的副作用？

我有一系列汽车.

car = {
    make: "nissan",
    model: "sunny",
    colour: "red"
};

我如何使用underscore.js按颜色对数组进行分组？

我已经尝试了几个组合,但我不确定如何指定我的迭代器条件:

var carsGroupedByColor = _.groupBy(cars, false, colour);
var carsGroupedByColor = _.groupBy(vars, false, function(cars){ return cars[colour]; };

它们每次都返回数组中的所有内容.

vector::insert(dst_iterator, src_begin, src_end)(插入范围)可以针对随机访问迭代器进行优化,以首先保留所需的容量src_end - src_begin,然后执行复制.

我的主要问题是:标准是否也允许vector::insert避免对每个复制元素进行容量检查？(即不在push_back每个要插入的元素上使用或类似)

我将把这个容量检查称为"优化insert".

可能出现的问题:我可以想象一个在解除引用时带有副作用的迭代器:

注意:标准保证传递给它的迭代器insert将被解除引用一次(参见问题结尾).

#include <vector>
#include <iterator>
#include <iostream>

template < typename T >
struct evil_iterator : std::iterator < std::random_access_iterator_tag, T >
{
    using base = std::iterator < std::random_access_iterator_tag, T >;

    std::vector<T>* evil_feedback;
    typename std::vector<T>::iterator innocent_iterator;

    evil_iterator( std::vector<T>* c,
                   typename std::vector<T>::iterator i )
        : evil_feedback{c}
        , innocent_iterator{i}
    {}

    void do_evil()
    {
        std::cout << "trying to do evil; …

std::vector是一个不稳定的容器,即通过调整向量的大小,迭代器可能会失效.相反,std::list或者boost::container::stable_vector是稳定的容器,它们保持迭代器有效,直到删除相应的元素.

有没有办法检查给定的容器是否稳定？例如,如果我有类似的东西

template<template <typename A, typename B=std::allocator<A> > class T=std::list>
class Foo
{
}

是否可以只允许稳定的容器并禁止不稳定的容器？

我在C++向量中寻找一个元素,当我找到它时,我希望以数字形式(整数,浮点数)获得找到的元素索引.

我天真的尝试是这样的:

int x;
int index;
vector<int> myvector;
vector<int>::iterator it;
it = find(myvector.begin(), myvector.end(), x);  
index = (int) * it;

这段代码给出了错误.你能告诉我如何将迭代器转换为int(如果可能的话),或者你能告诉我如何以其他方式获得找到的元素索引吗？谢谢.

我正在使用python 2.7和ipython2.7.在ipython中我尝试过:

class Fib(object):
    def __init__(self, max):
        super(Fib, self).__init__()
        self.max = max

    def __iter__(self):
        self.a = 0
        self.b = 1
        return self

    def __next__(self):
        fib = self.a
        if fib > self.max:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        return fib

def main():
    fib = Fib(100)
    for i in fib:
        print i

if __name__ == '__main__':
    main()

那么它报告错误:

类型错误回溯(最近通话最后一个)在()22 23如果名称 == ' 主要 ':---> 24主()25

<ipython-input-21-f10bd2d06666> in main()
    18 def main():
    19     fib = Fib(100)
---> 20     for …

一次迭代多个变量,重叠(slice::windows)或不重复()可能很有用slice::chunks.

这仅适用于切片; 是否可以为迭代器执行此操作,为方便起见使用元组？

可以写下以下内容:

for (prev, next) in some_iter.windows(2) {
    ...
}

如果没有,它是否可以作为现有迭代器的特征实现？