标签: iterator

我有如下地图

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; …

我需要能够处理大型JSON文件,从可反序列化的子字符串中实例化对象,因为我们正在迭代/流式传输文件.

例如:

假设我只能反序列化为以下实例:

case class Data(val a: Int, val b: Int, val c: Int)

和预期的JSON格式是:

{   "foo": [ {"a": 0, "b": 0, "c": 0 }, {"a": 0, "b": 0, "c": 1 } ], 
    "bar": [ {"a": 1, "b": 0, "c": 0 }, {"a": 1, "b": 0, "c": 1 } ], 
     .... MANY ITEMS .... , 
    "qux": [ {"a": 0, "b": 0, "c": 0 }  }

我会喜欢做的是:

import com.codahale.jerkson.Json
val dataSeq : Seq[Data] = Json.advanceToValue("foo").stream[Data](fileStream)
// NOTE: this will …

我喜欢使用迭代器原理的for循环,比如

for(String s : collectionWithStrings)
    System.out.println(s + ", ");

问题:如何确定当前元素是否是最后一个元素？

有这样的自己的索引int = 0; i < collection.size(); i++是可能的i == collection.size() - 1,但不是很好.对于上面的例子,是否也可以用迭代器确定最后一个元素？

正如标题所说,当我实例化一个类时,我收到了这条消息:

Fatal error: Class 'Envato\RecursiveIteratorIterator' not found in C:\Users\rgr\Apache\htdocs\Roland Groza [ 3.0 ]\class\envato\envato.php on line 359

你可以在这里查看课程:Class ;

我正在从另一个文件中实例化:

require("envato.php");
$test = new Envato\EnvatoAPIWrapper();
echo "User Vitals : ".$test->get_user_vitals("chaoscod3r")."<br>";

该类包含一个命名空间,因此可能与它有关,但我不确定,因为我已经有几年没有编写PHP了.希望有人知道我做错了什么:)

我必须处理一个 Map <BitSet,List<List<Integer>> MyMap

if (key1 contains all of corresponding true bits of key2)
     Remove from key2 all those values which are common with key1)

在此过程中,如果列表中的元素数量低于THRESHOLD(用户定义的正整数),则将其删除.此外,如果Map包含空列表,则删除相应的键.

我使用以下代码:

List<BitSet> keys = new ArrayList<>(MyMap.keySet());  
ListIterator it1=keys.listIterator();
while(it1.hasNext())  {
     BitSet key1=(BitSet)it1.next();
     ListIterator it2=keys.listIterator(it1.nextIndex());
     while(it2.hasNext()) {
         BitSet key2=(BitSet)it2.next();                 
         BitSet ankey=(BitSet)key1.clone();
         ankey.and(key2);    
         if(ankey.equals(key1)) {//key1 is subset and key2 is superset
               if(removePoints(key1,key2))  {
                     it1.remove();
                     break;
               }
         }
         else if(ankey.equals(key2))  {                           
              if(removePoints(key2,key1))  {
                    it2.remove();                         
              }
         }
     }
}

public static boolean removePoints(BitSet key1,BitSet key2)
 {
     List<List<Integer>> list1=MyMap.get(key1); …

我在循环中有各种场景,我会在迭代项目进行处理时"偷看"或"跳过".

一种情况是我通过文件的行来枚举,并且在行的末尾有一个"延续"字符,表示将下一行与当前行组合.如果我只是循环而不是太难,我可以阅读下一行,然后碰到我的计数器/索引.

使用我的迭代器执行此操作的模式并不明显.我实际上想要在不退出关闭的情况下使用下一行.但我甚至不确定这是否可行.使用闭包这个迭代模式是否有任何好的设计模式,所以我不必诉诸于一个不太常规的循环？它可能是一种迭代器形式,有一些堆栈用于推送/弹出项目进行处理？

可以使用迭代器范围构造一个向量,如下所示:

std::vector<std::string> vec(std::istream_iterator<std::string>{std::cin},
                             std::istream_iterator<std::string>{});

但我也可以使用C++ 11统一初始化语法编译和运行代码(注意括号),如下所示:

std::vector<std::string> vec{std::istream_iterator<std::string>{std::cin},
                             std::istream_iterator<std::string>{}};

这里到底发生了什么？

我知道采用初始化列表的构造函数优先于其他形式的构造.编译器是否应该解析为构造函数采用包含2个元素的初始化列表std::istream_iterator？这应该是一个错误,因为std::istream_iterator无法转换为矢量值类型std::string,对吧？

最近我试图修复一个相当困难的const-correctness编译器错误.它最初表现为Boost.Python内部的多段模板呕吐错误.

但这是无关紧要的:这一切都归结为以下事实:C++ 11 std::begin和std::end迭代器函数不会重载以获取R值.

定义std::begin是:

template< class C >
auto begin( C& c ) -> decltype(c.begin());

template< class C >
auto begin( const C& c ) -> decltype(c.begin());

因此,由于没有R值/通用引用重载,如果您传递一个R值,您将获得一个const迭代器.

那我为什么要关心？好吧,如果您有某种"范围"容器类型,即像"视图","代理"或"切片"或某些容器类型,它们呈现另一个容器的子迭代器范围,通常非常方便使用R值语义并从临时切片/范围对象中获取非const迭代器.但是std::begin,你运气不好因为std::begin总会返回一个R值的常量迭代器.这是一个老问题,C++ 03程序员经常在C++ 11给我们R值的前一天感到沮丧 - 即临时问题始终具有约束力const.

那么,为什么没有std::begin定义为:

template <class C>
auto begin(C&& c) -> decltype(c.begin());

这样,如果c是常数,我们得到a C::const_iterator和a C::iterator否则.

起初,我认为原因是为了安全.如果你传递了一个临时的std::begin,就像这样:

auto it = std::begin(std::string("temporary string")); // never do this

...你得到一个无效的迭代器.但后来我意识到这个问题仍然存在于当前的实现中.上面的代码只会返回一个无效的const -iterator,在解除引用时可能会出现段错误.

那么,为什么std::begin …