标签: iterator

我在Java中有一个LinkedList,一个浏览列表的迭代器,我想克隆迭代器,根据原始迭代器的位置对列表进行一些临时的"向前看"处理.

我知道在任何情况下都不可能克隆迭代器,但有没有办法将迭代器克隆到LinkedList(或保存并恢复其状态)？

我似乎无法找到任何关于此的信息,所以我转向stackoverflow.在C++中std :: tr1 :: unordered_map的迭代器效率如何？特别是与列表迭代器进行比较.创建一个包含类的包装类是否有意义,它还包含列表中的所有键以允许有效的迭代(我的代码在unordered_map中使用了大量的迭代).对于那些会推荐提升的人,我不能使用它(无论出于何种原因).

对于非常模糊的标题我很抱歉,我真的不知道如何标题这个问题.

假设我有这个:

std::list<std::string> msgs;

for (std::list<std::string>::iterator it = msgs.begin(); it < msgs.end(); it++) {
    // ...
}

对我来说,这很难读.这std::list<std::string>::iterator几乎看起来像一个神奇的数字,特别是如果声明msgs很远,就像在头文件中一样.IMO它会更容易阅读,如果它是这样的话更加语义:

std::list<std::string> msgs;

for (msgs.iterator it = msgs.begin(); it < msgs.end(); it++) {
    // ...
}

现在,这显然是非法的C++.但我的问题是,是否有一种方法可以实现支持编写像这样的迭代器声明的东西？

我有一个Boost多阵列,其维度根据用户的输入在运行时设置.

我现在想通过x,y,z组件迭代该数组.

如果这是一个std :: vector,我会使用:

for(int i=0;i<v.size();i++){

或许是某种迭代器.

如何获取多阵列尺寸的数值？

如何迭代多重阵列？

谢谢!

我有一个std :: unordered_map

std::unordered_map<std::string, std::string> myMap;

我想使用find获取一个const迭代器.在c ++ 03中我会这样做

std::unordered_map<std::string, std::string>::const_iterator = myMap.find("SomeValue");

在c ++ 11中,我希望使用auto来减少模板

auto = myMap.find("SomeValue");

这是const_iterator还是迭代器？编译器如何决定使用哪个？有没有办法可以强迫它选择const？

只是想知道为什么Enumerable.Range实施IDisposable.

我理解为什么IEnumerator<T>,但IEnumerable<T>不要求它.

(我在玩我的.Memoise()实现时发现了这个,它的声明就像

if (enumerable is IDisposable)
    ((IDisposable)enumerable).Dispose();

在它的"源完成"方法中,我因为好奇而放置了一个断点,并且是通过测试触发的.)

总目标

我管理(对象的集合Collection的Real简单例子).然后我在我的集​​合上定义了迭代器.这意味着:iterator,const_iterator,reverse_iterator和const_reverse_iterator.在这个例子中,我只会注意iterator和const_iterator,其他两个非常相似.

之后,我想在我的集合中定义一个过滤器,它根据特定条件保留或不保留元素.例如,仅保留Real具有正值的实例.我也想在我保留的元素上迭代我的集合.

我是如何实现该集合的

对于此示例,集合中的对象非常简单.目标只是拥有一个对象而不是一个本机类型:

struct Real
{
    public:
      double r;
};

然后我定义我的集合而不必知道里面的真实容器:

class Collection
{
  public:
    typedef std::vector<Real>::iterator iterator;
    typedef std::vector<Real>::const_iterator const_iterator;
  private:
    std::vector<Real> data;
  public:
    Collection() : data() {}
    Collection(unsigned long int n) : data(n) {}
    Collection(unsigned long int n, const Real& x) : data(n,x) {}
    Collection::iterator       begin()       { return this->data.begin(); }
    Collection::iterator       end()         { return this->data.end(); }
    Collection::const_iterator begin() …

是否有标准的pythonic方法从提供的迭代器列表中选择一个值而不推进那些未选择的迭代器？

对于两个迭代器来说,有一些东西(不要过于严厉地判断:为了说明这个想法,它很快被抛到一起):

def iselect(i1, i2, f):
    e1_read = False
    e2_read = False

    while True:
        try:
            if not e1_read:
                e1 = next(i1)
                e1_read = True

            if not e2_read:
                e2 = next(i2)
                e2_read = True

            if f(e1, e2):
                yield e1
                e1_read = False
            else:
                yield e2
                e2_read = False
        except StopIteration:
            return

请注意,如果使用这样的东西:

[e1 if f(e1, e2) else e2 for (e1, e2) in zip(i1, i2)]

那么非选择的迭代器每次都会前进,这不是我想要的.

我有一个属于某个类的大项目向量.

struct item {
    int class_id;
    //some other data...
};

相同的class_id可以在向量中出现多次,并且向量构造一次然后按class_id排序.因此,同一类中的所有元素在向量中彼此相邻.

我后来必须处理每个类的项目,即.我更新同一类的所有项目,但我不修改不同类的任何项目.由于我必须为所有项目执行此操作,并且代码可以简单地并行化,因此我希望将Microsoft PPL与Concurrency :: parallel_for_each()一起使用.因此,我需要一个迭代器,并提出了一个前向迭代器,它返回所有项目的范围,并以某个class_id作为代理对象.代理只是一个std :: pair,代理是迭代器的值类型.

using item_iterator = std::vector<item>::iterator;
using class_range = std::pair<item_iterator, item_iterator>;

//iterator definition
class per_class_iterator : public std::iterator<std::forward_iterator_tag, class_range> { /* ... */ };

到现在为止,我能够循环遍历所有类并更新这样的项目.

std::vector<item> items;
//per_class_* returns a per_class_iterator
std::for_each(items.per_class_begin(), items.per_class_end(),
[](class_range r) 
{ 
    //do something for all items in r 
    std::for_each(r.first, r.second, /* some work */);
});

当用Concurrency :: parallel_for_each替换std :: for_each时,代码崩溃了.调试后,我发现问题是ppl.h中第2772行的_Parallel_for_each_helper中的以下代码.

// Add a batch of work items to this functor's …

假设我有一个函数f,它可以将坐标作为参数并返回一个整数(在这种情况下为f(x)).坐标可以是多维的,并且是列表的形式.我的目标是用两个坐标之间的所有值填充numpy数组.我试图列出所有可能的索引并将其用作矢量化函数的输入.

这是我的2维坐标代码:

import itertools
import numpy


def index_array(lower_corner, upper_corner):
     x_range = range(lower_corner[0], upper_corner[0])
     y_range = range(lower_corner[1], upper_corner[1])
     return numpy.array(list(itertools.product(x_range, y_range)))


print(index_array([2, -2], [5, 3]))

这将返回索引列表,如预期:

[[ 2 -2]
 [ 2 -1]
 [ 2  0]
 [ 2  1]
 [ 2  2]
 [ 3 -2]
 [ 3 -1]
 [ 3  0]
 [ 3  1]
 [ 3  2]
 [ 4 -2]
 [ 4 -1]
 [ 4  0]
 [ 4  1]
 [ 4  2]]

这是我对n维度的尝试:

import itertools
import numpy


def f(x):
    # dummy function …