标签: iterator

以下代码是否合法？

class A
{
    std::map<int, A>::iterator x;
};

Visual Studio 2015接受了它,但clang说

.../ndk/sources/cxx-stl/llvm-libc++/libcxx/include/utility:254:9:  
error: field has incomplete type 'A'
    _T2 second;
    ^
....
a.cpp:52:21:
note: definition of 'A' is not complete until the closing '}'
    struct A
           ^

编辑:
问题似乎与标准库有关,http: //rextester.com/QNNEG57036失败

我的问题是代码是否合法,而不是如何解决它(例如通过更改编译器标志).

我编写了一个RandIt类(下面的代码),它的作用类似于迭代器,但只要取消引用就会返回随机整数.主要用例是使用随机数据初始化向量,如

std::vector<int> v(RandIt<0,99>{}, RandIt<0,99>{50});

生成0到99之间的50个数字.

typedef RandIt::iterator_category是std::random_access_iterator_tag因为

• 它至少需要一个ForwardIterator,用于向量构造函数分配适当数量的空间来构建,用std::distance.否则emplace_back使用,重新分配和复制.
• 它需要是RandomAccessIterator std::distance才能保持恒定时间,而不是在循环中递增和测试.

但是,这是一个谎言,因为取消引用RandIt会返回一个intby值,并且ForwardIterators和better都需要返回对内存中对象的引用.

(由于Forw​​ardIterator的"多通道保证"失败,这也可能是一个谎言:再次检查序列会产生不同的结果.但是cppreference给出了"正式"版本

表达式(void)++It(a), *a等同于表达式*a

这似乎是真的,对于某些"等价"的值.)

因此,我绝对违反了规则,声称自己不是.尽管如此,它似乎有效.

这会咬我吗？说谎的潜在影响是什么？

#include <random>
#include <iterator>

template <int min, int max>
struct RandIt {
    typedef int difference_type;
    typedef int value_type;
    typedef const int* pointer;
    typedef const int& reference;
    typedef std::random_access_iterator_tag iterator_category; // this is a lie

    static std::knuth_b rng;
    static std::uniform_int_distribution<int> idist;
    int i;

    explicit RandIt(int i = 0) : …

我们有一个双端结构列表,例如LinkedList.

我需要向前和向后迭代元素(例如,向前4次然后向后2次然后向前5次).

在C++中它将是:

iter++; iter++; ... iter--; ...

在Rust中,我只看到.next()并且.rev()哪个不方便(因为经过几次迭代后我已经不知道我在哪个方向上反转了迭代).

我想将一个左值传递给一个需要一对迭代器的函数,并且它就像我将一对迭代器传递给只包含这个值的范围一样.

我的方法如下:

#include <iostream>
#include <vector>

template<typename Iter>
void iterate_over(Iter begin, Iter end){
    for(auto i = begin; i != end; ++i){
        std::cout << *i << std::endl;
    }
}

int main(){
    std::vector<int> a{1,2,3,4};
    iterate_over(a.cbegin(), a.cend());

    int b = 5;
    iterate_over(&b, std::next(&b));
}

这似乎在g ++ 5.2中正常工作,但我想知道这是否是实际定义的行为以及是否存在任何潜在问题？

迭代参数(例如),这是跳过前N个元素最直接的方法吗？

例如:

use std::env;

fn main() {
    for arg in env::args() {
        println!("Argument: {}", arg);
    }
}

我试过env::args()[1..]但不支持切片.

什么是跳过迭代器的第一个参数的最简单方法？

我有一个投资组合类,也有投资类的链表(例如 - 谷歌是投资的一个实例),每个投资都有一个交易历史(另一个链表),每个交易的数据.

当用户想要进行交易(以5K购买谷歌股票)时,我需要找出投资(在谷歌中)是否已经存在于投资列表中.如果没有 - 添加新的投资(并为其交易历史添加交易),如果确实如此 - 只需添加另一个链接到谷歌的tradeHistory链表.

问题 - 我需要findInvestment方法从投资列表返回对谷歌(投资实例)的引用,以便我可以更新其交易历史.该方法返回一个listIterator而不是对investmentList中的位置的引用(应该是投资类).我该如何纠正findInvestment？(发现= iter错了)

public class Portfolio {


private LinkedList<Investment> investmentsList;

public Portfolio() {
    investmentsList = new LinkedList<Investment>();
}

public void addInvestment(String symbol, double money){

    Investment invest = findInvestment(symbol);
    if (invest == null) {
        System.out.println("symbol does not exist");
        getInvestmentsList().add(new Investment(symbol,money));
        System.out.println("New invetment has been added to your portfolio - " +symbol);
    } else {
        invest.addTrade(symbol,money);
        System.out.println("A new trade has been added to the current investment - " + symbol);

    }
}

public …

我想创建一个迭代器类,它允许我遍历具有泛型类型(例如lst1 integer,lst2 string)的列表.为此,我必须考虑以下给定的情况.

该接口是通用迭代器.这部分代码无法修改.

interface Iterator<E> {
E next ();
boolean hasNext();
}

列表类也定义如下.最重要的是,列表对象可以使用方法getIterator()返回迭代器对象.这部分代码无法修改.

class List<T> {
class ListNode {
    T val;
    ListNode next;

    ListNode (T v) {
        val = v; next = null;
    }
}

ListNode head;

List (ListNode hd) { head = hd; }
List () { this(null); }

void prepend (T val) {
    ListNode p = new ListNode(val);
    p.next = head;
    head = p;
}

//some other methods

class ListIterator implements Iterator<T> {
    ListNode pos;

    ListIterator () …

我将如何为生成器实现hasNext（）方法。我尝试了许多选项，例如将生成器添加为return语句并从闭包中屈服。获取第一个值将其打印出来，然后使用while等，但是它们都没有实际起作用。

我知道我可以使用诸如of或while之类的如何循环来自generator的JavaScript迭代器？ 但仍然想知道是否可以添加hasNext（）。

function *range(start,end){

    while(start < end){
        yield start; 
        start++
    }
}

let iterator = range(1,10); 

// so I can do something like this. 
while(iterator.hasNext()){
   console.log(iterator.next().value); 
}

是否允许增加it已经存在的迭代器变量end(),即auto it = v.end()？

• 它一般是允许的吗？
• 如果没有,是不允许的vector？
• 如果是的话,则++it可能幂等如果it==v.end()？

我问,因为我偶然发现了这样的代码:

std::vector<int> v{ 1, 2, 3, 4, 5, 6, 7 };
// delete every other element
for(auto it=v.begin(); it<v.end(); ++it) { // it<end ok? ++it ok on end?
  it = v.erase(it);
}

它适用于g ++ - 6,但这不是证据.

对于一个人it<v.end()可能只能使用vectors,我想它应该it!=v.end()一般阅读.但是在这个示例中,当它已经结束时,将无法识别vif ++it的结尾.

我正在阅读关于生成器和迭代器以及它的作用__next__().

'__next__' in dir(mygen).是真的

'__next__' in dir(mylist),是假的

当我深入研究它时,

'__next__' in dir (mylist.__iter__()) 是真的

1. 为什么__next__只适用于列表中,但只有__iter__()和mygen,但不会mylist.当我们使用list-comprehension踩到列表时,如何__iter__()调用__next__

   我打电话试图手动步进(+1)发电机mygen.__next__().它不存在.它只存在于mygen.__next__被称为method-wrapper的地方.

2. 什么是方法包装器,它做什么？它是如何应用的:inmygen() and __iter__() ?

3. 如果__next__是生成器和迭代器提供的(以及它们的唯一属性)那么生成器和迭代器之间有什么区别？*

   答案3:解决,如mod /编辑所述:

   Python的生成器和迭代器之间的区别

更新:生成器和迭代器都有__next__().我的错.看着日志,某种程度上mygen.__next__()测试给了我停止异常错误.但我无法再次复制该错误.

谢谢大家回答!