标签: iterator

假设我有一些Python代码,如下所示:

input = open("input.txt")
x = (process_line(line) for line in input)
y = (process_item(item) for item in x)
z = (generate_output_line(item) + "\n" for item in y)
output = open("output.txt", "w")
output.writelines(z)

此代码从输入文件中读取每一行,通过多个函数运行它,并将输出写入输出文件.现在我知道函数process_line,process_item并且generate_output_line永远不会相互干扰,让我们假设输入和输出文件位于不同的磁盘上,这样读写就不会相互干扰.

但Python可能不知道这些.我的理解是Python将读取一行,依次应用每个函数,并将结果写入输出,然后只有在将第一行发送到输出后才会读取第二行,这样第二行就不会进入管道直到第一个退出.我是否正确理解该程序将如何流动？如果这是它的工作方式,是否有任何简单的方法可以使多个行同时在管道中,以便程序并行读取,写入和处理每个步骤？

我承认我很难找到合理的描述.我想不出一个能够准确描述我正在寻找什么的好词.也许这可以称为切片迭代器.

假设我有这样的事情:

struct S
{
    int i;
    char *s;
    float f;
};

std::vector<S> v(10);

我正在寻找的是一种构造迭代器的方法,它将指向一个成员S.我希望能够将它传递给类似于std::min_element在每种情况下都不创建谓词的东西.可能看起来像这样的东西:

std::min_element(slicing_iterator(v.begin(), S::f), slicing_iterator(v.end(), S::f));

有没有我可以用来实现这个的模板技巧？或许它已经在Boost或其他一些图书馆的某个地方完成了？

我有一个包含一些数据的类,我想添加begin()和end()提供迭代器的数据ID.

我正在使用Boost counting_iterator:

#include <iostream>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/iterator/counting_iterator.hpp>

template<class T>   
class ContainerTpl {
 public:
  typedef std::size_t Id;
  typedef boost::counting_iterator<Id> const_iterator;
  ContainerTpl() {}
  const_iterator begin() {
    return boost::counting_iterator<Id>(0);
  }
  const_iterator end() {
    return boost::counting_iterator<Id>(container_.size());
  }
 private:
  std::vector<T> container_;
};

int main () {
  typedef ContainerTpl<double> Container;
  Container c;
  BOOST_FOREACH (Container::Id cid, c) {
    std::cerr << cid << std::endl;
  }
  return 0;
}

请注意,这是最小的示例代码; 现实中的类包含更多的功能,因此,例如,typedef到vector是不够的.我真的需要那个类,带有ID的迭代器.

不幸的是,上面的代码给了我非常讨厌的编译器错误:

In file included from …

请你好 - 这是我的第一个问题.= P

基本上作为夏季项目,我一直在浏览维基百科页面上的数据结构列表并尝试实现它们.我上学期参加了C++课程并发现它非常有趣,作为我实施二项式堆的最终项目 - 这也非常有趣.也许我很讨厌,但我喜欢数据结构.

无论如何,足够的背景故事.项目进展顺利,我从二叉树开始.为了更进一步,我需要创建迭代器来遍历树.我已经决定为每个遍历方法(常规迭代器和常量迭代器)创建两种类型的迭代器,我只是不知道如何做到这一点.我听说过从stl的迭代器继承,甚至使用boosts iterator_facade(这似乎是个不错的选择)

我还没有尝试编写迭代器代码,因为我不知道从哪里开始,但我确实在github上有我当前的代码.你可以在这里查看.

如果你反对github,我会粘贴相关的类定义.这些功能的实现实际上没有任何帮助,但如果您出于某种原因需要它们,请告诉我.此外,节点类具有用于迭代目的的父指针.

#ifndef __TREES_HXX
#define __TREES_HXX
#include <cstdlib>  // For NULL
#include <algorithm> // for std::max

// Node class definition. These nodes are to be used for any
// tree where the structure is
//    node
//     /\
// left  right
//  /\    /\
//
// etc., basically two children.
template <typename T>
class Node
{
  public:
    T data_;
    Node<T>* left_;
    Node<T>* right_;
    Node<T>* parent_; // Needed …

我有一个std::multimap,我想创建一个boost::iterator_range从equal_range.我在文档中找不到简单的方法,所以我尝试了以下方法:

typedef std::multimap<int, std::string> Map;
Map map;
...
boost::iterator_range<Map::iterator> r(map.equal_range(2));

令人惊讶的是,它的工作原理(使用GCC 4.1.2).我很好奇它是如何工作的.我发现iterator_range构造函数没有重载会发生这种情况,multimap::iterator_range显然没有返回Boost范围的重载.

我在Python中检查str对象,并且我意识到Python 2.7中的str对象既__iter__()没有next()方法也没有方法,而在Python 3.0中str对象有__iter__()方法,因此它们是可迭代的.但是,我仍然可以使用str对象,就好像它们在Python 2.7中是可迭代的一样.例如,我可以在for循环中使用它们.这是如何运作的？

我希望迭代一个集合,但集合的内容将在迭代期间修改.我希望在创建迭代器时迭代原始集合,而不是迭代添加到集合中的任何新元素.这怎么可能？这是set的默认行为还是我该如何实现？

我能想到的一种方法是从原始集合中获取一个不会被修改的新集合,但这看起来不够优雅并且必须有更好的解决方案.

我有如下地图

string word;
int occurance;
std::map< std::string, std::map<string, int> > map;
map[word]["count"] = occurance;

使用迭代器映射输出.

for(auto outer_iter=map.begin(); outer_iter!=map.end(); ++outer_iter) {
        for(auto inner_iter=outer_iter->second.begin(); inner_iter!=outer_iter->second.end(); ++inner_iter) {
            std::cout << outer_iter->first << '\t'  << inner_iter->second << std::endl;
        }
    }

我想通过订购inner_iter-> second值来显示地图.

我该怎么做？

我正在寻找将给定集合划分为不相交子集的代码.例如,一组足球运动员,我们根据他们所属的球队对他们进行分区.我最终想要一份代表名单,即每队的一名球员.

所有足球运动员都了解球队中的所有其他球员 - 这与复杂性非常相关.所以,我目前关于如何做到这一点的想法如下(set目前在哪里LinkedHashSet<T>):

while (!set.isEmpty()) {
    E e = set.iterator().next();
    makeRepresentative(e);
    set.remove(AllPlayersOnSameTeamAs(e));
}

但是,在while循环的每个步骤中构建一个新的迭代器感觉很奇怪.LinkedHashSet应该在firstElement()内部具有某种功能(对于其LinkedList行为),但由于某种原因我无法找到如何执行此操作.我也试过了一个foreach循环,但结果是一个java.util.ConcurrentModificationException.

我该如何正确地做到这一点？

假设我想反过来迭代泛型迭代器,而不知道迭代器的内部结构,并且基本上不通过无类型魔法作弊,并假设这可以是任何类型的迭代,它为迭代器提供服务; 我们可以在运行时甚至通过宏优化迭代器的反转吗？

前锋

var a = [1, 2, 3, 4].iterator();
// Actual iteration bellow
for(i in a) {
   trace(i);
}

向后

var a = [1, 2, 3, 4].iterator();
// Actual reverse iteration bellow
var s = [];
for(i in a) {
    s.push(i);    
}
s.reverse();
for(i in s) {
    trace(i);    
}

我认为必须有一种更简单的方法,或者至少是快速的方法.我们无法知道一个大小,因为Iterator类没有携带一个,所以我们不能将推送反转到临时数组.但我们可以删除反向,因为我们知道临时数组的大小.

var a = [1,2,3,4].iterator();
// Actual reverse iteration bellow
var s = [];
for(i in a) {
    s.push(i);    
}
var total = s.length;
var totalMinusOne = total - 1; …