我试图在循环中访问先前迭代的元素,遍历列表的所有元素.
更具体地说,我的循环看起来像这样:
for (iter=list_object.begin(); iter!= list_object_.end(); iter++)
{
function_1(*iter);
function_2(*PREVIOUS_VALUE_IN_THE_LIST);
}
如何在列表中访问此前一个值？
据我所知,迭代器类别的层次结构如下:
Random access -> Bi-directional -> Forward -> Input
-> Output
正确？
我一直认为有一个规则,如果算法需要特定类型的迭代器,你可以在链上提供类别的迭代器,但不能向下.所以我正在阅读这个答案,其中ildjarn 建议使用std::ifstreamwith std::istream_iterator并std::search在文件中查找数据.我即将评论你不能这样做,因为search期望正向迭代器,并且istream_iterator是一个输入迭代器.但只是为了确保,我试过这个:
std::istringstream iss("Elephant hats for sale.");
std::istream_iterator<char> begin(iss), end;
std::string sub("hat");
auto i = std::search(begin, end, sub.begin(), sub.end());
我没想到它会编译,但确实如此.但是,结果似乎没用,因为如果我遵循它:
while(i != end)
{
std::cout << *i;
++i;
}
没有输出.所以,我的问题是:我的编译器错误地允许我的调用search使用istream_iterator？或者没有规则阻止这种事情？
我不时感觉需要某种迭代器(除了前面这个问题的标题之外,我不能说出一个好名字).
假设我们有一个函数(或函数对象)将整数映射到类型T.也就是说,我们有一个数学序列的定义,但我们实际上并没有将它存储在内存中.我想用它做一个迭代器.迭代器类看起来像这样:
template <class F, class T>
class sequence_iterator : public std::iterator<...>
{
int i;
F f;
public:
sequence_iterator (F f, int i = 0):f(f), i(i){}
//operators ==, ++, +, -, etc. will compare, increment, etc. the value of i.
T operator*() const
{
return f(i);
}
};
template <class T, class F>
sequence_iterator<F, T> make_sequence_iterator(F f, int i)
{
return sequence_iterator<F, T>(f, i);
}
也许我天真,但我个人觉得这个迭代器会非常有用.例如,假设我有一个函数来检查数字是否为素数.我想计算区间[a,b]中素数的数量.我会这样做;
int identity(int i)
{
return i;
}
count_if(make_sequence_iterator<int>(identity, a), make_sequence_iterator<int>(identity, b), isPrime); …这是我想在Mustache.js中做的,但没有看到文档的方式.
var view = {items:['Mercury','Venus','Earth','Mars']};
var template = "<ul> {{#items}}<li>{{i}} - {{.}}</li>{{/items}} </ul>";
var html = Mustache.to_html(template,view);
期望的输出:
<ul>
<li>0 - Mercury</li>
<li>1 - Venus</li>
<li>2 - Earth</li>
<li>3 - Mars</li>
</ul>
以下是将可迭代项目拆分为子列表的两个函数.我相信这种类型的任务是多次编程的.我使用它们来解析由repr('result','case',123,4.56)和('dump',..)等行组成的日志文件.
我想改变这些,以便它们将产生迭代器而不是列表.因为列表可能会变得非常大,但我可以根据前几个项目决定接受或跳过它.此外,如果iter版本可用,我想嵌套它们,但这些列表版本会通过复制部分浪费一些内存.
但是从可迭代源中获取多个生成器对我来说并不容易,所以我请求帮助.如果可能的话,我希望避免引入新课程.
另外,如果您对这个问题有更好的标题,请告诉我.
谢谢!
def cleave_by_mark (stream, key_fn, end_with_mark=False):
'''[f f t][t][f f] (true) [f f][t][t f f](false)'''
buf = []
for item in stream:
if key_fn(item):
if end_with_mark: buf.append(item)
if buf: yield buf
buf = []
if end_with_mark: continue
buf.append(item)
if buf: yield buf
def cleave_by_change (stream, key_fn):
'''[1 1 1][2 2][3][2 2 2 2]'''
prev = None
buf = []
for item in stream:
iden = key_fn(item)
if prev is None: prev = iden
if …我有一个自定义容器,我已经使用多年没有问题.最近我发现如果我为容器定义迭代器,我可以有效地使用中定义的所有算法<algorithm>.不仅如此,似乎推力库 (基本上认为Nvidia GPU的STL的CUDA版本)大量使用迭代器,我希望通过使用它们我也能够使用该库.
无论如何,因为这是我第一次尝试编写自己的迭代器,我想我发布了我在这里要求进一步帮助的内容,并确保我所做的是对的.所以,我写了一个支持一个小数组类iterator和const_iterator类.我用一堆不同的STL算法运行我的课程,所有似乎工作正常,但这并不一定意味着我已经把一切都搞定了!特别是,我的迭代器中是否有任何操作符？我是否定义了额外的不必要的？此外,由于大多数iterator和const_iterator看起来相似,有没有办法防止重复？
我愿意接受建议和改进:)
#include <cstddef>
#include <iostream>
#include <iterator>
#include <algorithm>
template<typename T>
class my_array{
T* data_;
std::size_t size_;
public:
// ---------------------------------
// Forward declaration
// ---------------------------------
class const_iterator;
// ---------------------------------
// iterator class
// ---------------------------------
class iterator: public std::iterator<std::random_access_iterator_tag, T>
{
public:
iterator(): p_(NULL) {}
iterator(T* p): p_(p) {}
iterator(const iterator& other): p_(other.p_) {}
const iterator& operator=(const iterator& other) {p_ = other.p_; …有很多替代方法来处理向量的元素.
我可以像这样使用指针:
vector<int> v = {10, 11, 12};
int *p = &v[0];
cout << *p; //Outputs "10"
我也可以这样使用指针:
vector<int> v = {10, 11, 12};
vector<int>::pointer p = v.data();
cout << *p; //Outputs "10"
我也可以使用迭代器类型:
vector<int> v = {10, 11, 12};
vector<int>::iterator i = v.begin();
cout << *i; //Outputs "10"
我在这里缺少哪些重大差异？
作为初学者Groovy研讨会的一部分,我们一直在迭代以下列表(fromJson.secrets):
[[floors:10, street:emaseS, url:http://plywoodpeople.com/wp-content/uploads/2012/03/kermit_the_frog.jpg], [floors:2, street:emaseS, url:http://36.media.tumblr.com/tumblr_lp9bg9Lh2x1r0h9bqo1_500.jpg], [floors:2, street:yawdaorB, url:https://montclairdispatch.com/wp-content/uploads/2013/07/broadway1.jpg], [floors:5, street:emaseS, url:AAA], [floors:2, street:yawdaorB, url:AAA], [floors:6, street:albmaR aL, url:AAA], [floors:1, street:teertS llaW, url:AAA], [floors:6, street:daoR yebbA, url:AAA], [floors:3, street:teertS llaW, url:AAA], [floors:4, street:dlican someone help me to understand the difference between the 2 methods in rehstoR, url:AAA]]
最初的计划是使用.collect,但它看起来像使用.each产生了相同的结果(迭代在列表上......).
问题是,有人可以帮助我理解有关我的用例和一般方法之间的区别
每:
reversed_streets = fromJson.secrets.each {
it.street = it.street.reverse()
it
}
搜集:
reversed_streets = fromJson.secrets.collect {
it.street = it.street.reverse()
it
}
是否准确地说明一个向量(以及其他集合类型)是一个Iterator？
例如,我可以通过以下方式循环遍历向量,因为它实现了Iterator特征(据我所知):
let v = vec![1, 2, 3, 4, 5];
for x in &v {
println!("{}", x);
}
但是,如果我想使用属于Iterator特征的函数(例如fold,map或filter),为什么我必须首先调用iter()该向量？
我的另一个想法是,可能会将矢量转换为a Iterator,在这种情况下,上面的语法更有意义.
我有以下两个级别的XML结构.一个框列表,每个框都包含一个抽屉列表.
<Boxes>
<Box id="0">
<Drawers>
<Drawer id="0"/>
<Drawer id="1"/>
...
</Drawers>
</Box>
<Box id="1">
...
</Box>
</Boxes>
我正在解析它StAX并通过两个暴露结构Iterators:
BoxIterator implements Iterator<Box>, Iterable<Box>Box implements Iterable<Drawer>DrawerIterator implements Iterator<Drawer>然后我可以做以下事情:
BoxIterator boxList;
for (Box box : boxList) {
for (Drawer drawer : box) {
drawer.getId()
}
}
在Iterators我正在使用的那些人的引擎盖下StAX,他们两个都访问相同的底层XMLStreamReader.如果我调用BoxIterator.next()它将影响将在后续调用时返回的结果,DrawerIterator.next()因为光标将移动到下一个框.
这会违反合同Iterator吗？是否有更好的方法来迭代使用两级结构StAX？