我打算在C++中实现一个Things列表,其中的元素可能会被无序删除.我不希望我需要任何类型的随机访问(我只需要定期扫描列表),项目的顺序也不重要.
所以我想std::list<Thing*> with this->position = insert(lst.end(), thing)应该做的伎俩.我希望Thing类能够记住每个实例的位置,以便以后可以轻松地完成lst.erase(this->position).
但是,我对C++ STL容器仍然有点新意,我不知道将迭代器保持这么长时间是否安全.特别是,考虑到在插入Thing之前和之后将删除其他元素.
我传递了一个迭代器,我必须将它传递给另一个函数 - 但是过滤掉了以便跳过某些元素(它是一系列指针,我想过滤掉NULL指针).
我用google搜索" stl filter iterator "来看看如何做到这一点,并且boost :: filter_iterator出现了.
这看起来不错,我可以使用它,但我可以用好的旧STL吗？当然,不要将元素复制到新容器中.
我想我会创建另一个迭代器类,它提供了必要的begin(),end()等功能,并执行过滤？所以我必须重新实现boost iterator_filter......？
为了支持STL的半开放范围的概念,我们可以指出数组的一个接一个的结束.假设我们有一个三元素的向量.如果std::vector::iterator被实现为一个指针,如通常在释放的情况下建立,那么begin和end指向这些位置:
+---+---+---+....
| | | | .
+---+---+---+....
^ ^
begin end
点表示一个过去的结束伪元素.既然没有一个在开始之前的东西,那究竟会rend指向哪个？让我说明一下:
+---+---+---+....
| | | | .
+---+---+---+....
^ ^
rend rbegin
显然,插图是错误的,因为它rend是一个非法指针.所以我想std::vector::reverse_iterator即使在发布版本中,实现也永远不会成为指针.
我对吗？那么最有效的实施方式是reverse_iterator什么？
我知道增量/减量运算符的后缀版本通常会由内置类型的编译器优化(即不会进行复制),但这是iterators 的情况吗？
他们本质上只是重载运营商,并且可以在任何数量的方式来实现,但由于他们的行为被严格定义,可以自己进行优化,如果是这样,他们是通过任何/很多编译器？
#include <vector>
void foo(std::vector<int>& v){
for (std::vector<int>::iterator i = v.begin();
i!=v.end();
i++){ //will this get optimised by the compiler?
*i += 20;
}
}
是否有更好的方法将一堆已排序的迭代器合并/整理成一个,以便按排序顺序生成项目？我认为下面的代码可以工作,但我觉得有一种更清晰,更简洁的方法,我错过了.
def sortIters(*iterables, **kwargs):
key = kwargs.get('key', lambda x : x)
nextElems = {}
currentKey = None
for g in iterables:
try:
nextElems[g] = g.next()
k = key(nextElems[g])
if currentKey is None or k < currentKey:
currentKey = k
except StopIteration:
pass #iterator was empty
while nextElems:
minKey = None
stoppedIters = set()
for g, item in nextElems.iteritems():
k = key(item)
if k == currentKey:
yield item
try:
nextElems[g] = g.next()
except StopIteration:
stoppedIters.add(g)
minKey = k if minKey is …我如何转换这样的东西：
let mut a = vec![1, 2, 3, 4i32];
for i in a.iter_mut() {
*i += 1;
}
使用map和关闭的单行操作？
我试过：
a.iter_mut().map(|i| *i + 1).collect::<Vec<i32>>();
以上仅在我将其重新分配给a. 为什么是这样？是否map正在获取副本a而不是可变引用？如果是这样，我怎样才能获得可变引用？
是否可以在 Python 的 while 循环中使用生成器或迭代器？例如，类似于：
i = iter(range(10))
while next(i):
# your code
这样做的目的是将迭代构建到 while 循环语句中，使其类似于 for 循环，不同之处在于您现在可以在 while 语句中添加额外的逻辑：
i = iter(range(10))
while next(i) and {some other logic}:
# your code
然后它成为一个很好的 for 循环/while 循环混合。
有谁知道如何做到这一点？
给定一个std::list名为 的迭代器it，it1++相当于it1=it1+1。那么为什么it1++工作正常，但it1=it1+1在下面的代码中却出现错误呢？
代码
#include <iostream>
#include <list>
int main()
{
std::list<int> l1{19, 2, 3, 21, 5, 19, 7, 11};
std::list<int>::iterator it1;
std::cout << "1st\n";
it1 = l1.begin();
it1++;
it1 = it1 + 1; // This giving error
}
输出
Invalid operands to binary expression
('std::list<int>::iterator' (aka '_List_iterator<int>') and 'int')
let output_sorted: Vec<String> = four_digit_ouput
.iter()
.map(|tok| tok.chars().sorted().collect::<String>())
.collect();
let output = 0;
for (idx, digit) in output_sorted.enumerate() {
当我尝试对字符串向量进行枚举 for 循环时，出现此错误：
let output_sorted: Vec<String> = four_digit_ouput
.iter()
.map(|tok| tok.chars().sorted().collect::<String>())
.collect();
let output = 0;
for (idx, digit) in output_sorted.enumerate() {
这是怎么回事？哪些特征边界不允许枚举？
在算法中，我可以value_type通过 直接从迭代器确定iter::value_type。为什么算法会iterator_traits做同样的事情？
#include <iostream>
#include <vector>
#include <iterator>
#include <typeinfo>
using namespace std;
template<typename iter>
void for_each(iter first, iter end)
{
cout << "container value type: "
<< typeid(typename iter::value_type).name()
<< endl;
cout << "container value type: "
<< typeid(typename iterator_traits<iter>::value_type).name()
<< endl;
}
int main()
{
vector<int> v1;
for_each(begin(v1), end(v1));
return 0;
}
输出：
container value type: i
container value type: i