标签: iterator

我使用 CGAL 的 Kd 树实现以及模糊球体作为查询对象来获取以某个点为中心的半径球体中包含的点r_max。这是这个最小的工作示例：

    #include <CGAL/Simple_cartesian.h>
    #include <CGAL/Kd_tree.h>
    #include <CGAL/Search_traits_2.h>
    #include <CGAL/Fuzzy_sphere.h>
    #include <iostream>
    #include <fstream>

    typedef CGAL::Simple_cartesian<double>  K;
    typedef K::Point_2                      Point;
    typedef CGAL::Search_traits_2<K>        TreeTraits;
    typedef CGAL::Kd_tree<TreeTraits>       Kd_tree;
    typedef Kd_tree::Tree                   Tree;
    typedef CGAL::Fuzzy_sphere<TreeTraits>  Sphere;

    int main(int argc, char* argv[])
    {
        double r_max;
        Tree tree;

        /* ... fill the tree with points, set the value of r_max ...*/

        // Report indices for the neighbors within a sphere
        unsigned int   idc_query = tree.size()/2;           // test index
        Tree::iterator kti       = …

我有一个类，类似于下面的代码。它实现了Iterable<T>iterface，用于在其包含的数组上提供迭代功能。

我一直习惯于使用自己的简单迭代器来迭代数组。然而，我刚刚意识到，至少对于spliterators来说，您可以通过调用 来获得可接受的默认实现Arrays.spliterator(array)。普通Iterator<T>数组上是否有类似的默认实现T？

public class MyClass implements Iterable<ContainedClass>
{
    ...
    private final ContainedClass[] array;
    ...

    //
    // INTERFACE: Iterable<ContainedClass>
    //

    @Override
    public Iterator<ContainedClass> iterator() {
        return ??? // I want to return a default implementation, not my own!
    }

    @Override
    public Spliterator<ContainedClass> spliterator() {
        return Arrays.spliterator(array);
    }
}

我已经使用了相当数量的 C++，但没有那么多std::list.. 在我当前的项目中，我需要一个std::list<..>数据成员，以及跟踪列表中带有std::list<..>::iterator. 该对象也必须是可移动的，但在我的情况下，默认的移动构造函数是不可能的。这里std::list做了一些让我感到惊讶的事情。

考虑

#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

template<typename T>
void test() {
    T l { 1, 2, 3, 4, 5 };
    cout << "l = "; for(const auto& e: l) cout << e << " "; cout << endl;
    auto pos = find(l.begin(), l.end(), 6);
    if (pos == l.end()) cout << "l end\n";

    cout << "---- moving l > lmv ----" << endl; …

我想在列表理解中将两个或多个不同的迭代器链接在一起。

假设我想将大写和小写字母组合成一个列表。我原来的方式是这样的，

lst1 = [chr(i) for i in range(97,123)]
lst2 = [chr(i) for i in range(65,91)]
lst = lst1+lst2

但是我认为必须有其他一些方法可以在一行中很好地做到这一点，然后我将它与 itertools 模块一起使用，

lst = [chr(i) for i in itertools.chain(range(97,123), range(65,91))]

最后我也想到了元组拆包，

lst = [chr(i) for i in (*range(97,123), *range(65,91))]

与其他两种方法相比，Itertools 速度较慢（元组解包是最快的一种）

例如，第一个范围和第二个范围中的字符构成

>>> lst1
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

>>> lst2
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', …

我有一个随机访问迭代器，我需要把它变成一个指针（外部 API 需要它！）。我可以做T* ptr = &(*iter);，但我觉得它很丑。有没有更好的办法？所有随机访问迭代器通常都实现->运算符，但我不知道获取指向数据的指针的通用方法。

如何从向量中删除重复元素但从前面开始？

所以

2 3 4 5 2 5 会成为 3 4 2 5

1 5 3 1 会成为 5 3 1

我希望该解决方案易于阅读，如果它也具有良好的性能，那就太好了。

出于某种原因，Java Stream 会生成更多的值（调用迭代器的 hasNext() 和 next() 方法。

这是合成示例。

我有一个迭代器形式的生成器：

@RequiredArgsConstructor
static class TestIterator implements Iterator<Integer> {
    private final int bound;
    private final Random rnd = new Random();

    private int current = 0;

    @Override public boolean hasNext() {
        return current < bound;
    }

    @Override public Integer next() {
        current = rnd.nextInt(20);
        System.out.println("Generated: " + current);
        return current;
    }
}

现在，我正在尝试创建一个由几个迭代器组成的扁平流

public static void main(String... args) {

    List<Iterator<Integer>> iterators = asList(
        new TestIterator(18),
        new TestIterator(18),
        new TestIterator(18));
    Stream<Integer> streams = iterators.stream()
        .map(iter …

这是一个包含向量的玩具结构

struct SizedVec {
    items: Vec<u32>,
    cap: usize,
}

我想拥有迭代函数，SizedVec这样它们就可以像我直接迭代项目一样工作。

但是，我不知道我应该实现哪些性状：是Iterator和IntoIterator就够了吗？文档中有很多特征 ，它们看起来有点复杂和乏味。

然后我看到我可以使用 deref coercion 免费实现Deref和DerefMut获取所有这些功能：

果然，做完之后：

impl Deref for SizedVec {
    type Target = Vec<u32>;

    fn deref(&self) -> &Self::Target {
        &self.items
    }
}

impl DerefMut for SizedVec {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.items
    }
}

我可以使用我想要的所有迭代器。但是我想实现一个自定义的推送逻辑，但是DeRef已经给了我一个推送。但是根据文档我应该没问题，因为显然查找是按顺序为每种类型完成的

impl SizedVec {
    fn from_size(size: usize) -> Self {
        Self {
            items: vec![],
            cap: size, …

这是列表迭代器的预期行为吗？评论是我所期望的

我有一个std::list我正在插入项目的std::unordered_map地方，我有一个地方我想将迭代器存储到插入到的元素中std::list（我正在实现一个 LRU 缓存）。下面的代码没有给我我期望的输出：

#include <list>
#include <unordered_map>
#include <iostream>


int main()
{
    std::list<int> l;
    std::unordered_map<int, std::list<int>::iterator> listItems;
    
    for (int i = 0; i < 5; i++)
    {
        l.push_back(i);
        listItems[i] = std::end(l);
    }
        

    for (int i = 0; i < 5; i++)
        std::cout << *(listItems[i]) << " ";
    std::cout << std::endl;

}

这里的输出是5 5 5 5 5- 我想要/期望的输出是0 1 2 3 4. 我会猜到这段代码会std::end返回一个迭代器到列表的最后一个元素，它被复制到 listItems[i] 中，但这显然不是正在发生的事情。我很困惑为什么将项目添加到列表会影响先前调用的结果std::end

但是，如果我将第一个循环更改为

for (int …