标签: iterator

我很难理解这个错误来自哪里:

error: ‘value_type’ in ‘struct std::iterator_traits<sha::Vector<int>::h_iterator>’ does not name a type

我正在尝试创建一个std::vector包装器并继承迭代器.我不明白为什么编译器无法推断'value_type'或'difference_type'.

这是我的班级定义:

  template <typename T>
  class Vector
  {
    public:
    explicit Vector(std::initializer_list<T> init) : data(init) {}
    ~Vector() {}

  class h_iterator : std::iterator<std::random_access_iterator_tag, T>
  {
    public:
      h_iterator(typename std::vector<T>::iterator it,
                 Vector<T>* owner) :
        it(it), owner(owner) {}

      T operator *() const { return *it; }
      const h_iterator &operator ++() { ++it; return *this; }
      h_iterator operator ++(int) { h_iterator copy(*this); ++it; return copy; }
      const h_iterator &operator --() { --it; return …

我不太了解vector::begin()实际返回的内容.

Cplusplus.com告诉我vector::begin()返回向量的迭代器,这意味着,vector<int> v;它将给出0.

但是,当我在Visual Studio上调试时,监视表显示了第一个元素的值v.此外,"类型"列表示它是a std::_Vector_iterator.

结果,究竟是什么输出vector::begin()？

我有一个具有可枚举值集的类型:

struct MyType(u32);

我可以在一组值上定义一个迭代器:

struct MyTypeIter {
    m: MyType,
}
impl Iterator for MyTypeIter {
    type Item = MyType;
    fn next(&mut self) -> Option<Self::Item> {
        if (self.m).0 < 0xffffffff {
            (self.m).0 += 1;
            Some(MyType((self.m).0 - 1))
        } else {
            None
        }
    }
}
impl MyTypeIter {
    fn new() -> MyTypeIter {
        MyTypeIter { m: MyType(0) }
    }
}

这真的是规范的做法吗？如果我们有几个自然顺序(比如在lex/colex顺序中迭代排列或组合)会怎样？

我想得到::iterator最后一个元素list.

我的理解是你可以把迭代器带到.front()列表中.begin(),但是.back()呢？由于列表边界不包含最终元素,.end()因此迭代器将超过back()列表元素.

我尝试使用.rbegin(),逻辑上似乎正是我想要的,但它似乎返回一个reverse_iterator类型,这导致我的代码不匹配的类型.

假设我有一个对象的std :: array并创建一个指向其中一个对象的指针.

std::array<Object, 100> my_array;

Object* ptr_object = &my_array[50]; 

所以假设我不知道ptr_object引用的索引,我将如何在C++ 11中查找和索引这个索引？

我发现一些读数表明std :: distance可能会有所帮助,但是,我的尝试

std::distance(my_array, ptr_object);

抛出错误,指出"找不到匹配的重载函数".

C++新秀在这里.我编写了一个函数,它从向量中返回一个迭代器,我想使用这个迭代器从头到尾迭代向量.但是,矢量迭代器就像这样使用

for (auto iterator = vec.begin(); iterator != vec.end(); iterator ++) {
// do something here
}

这意味着我还需要一个vec.end()来实现这一点.无论如何我只能使用vec.begin()迭代一个向量,就像我在python中常见的那样

for value in some_iterator:
# do something

编辑:一些不相关的更新:

我看到一些关于我的python iterator和iterable的评论.迭代器确实可以这种方式使用(至少在Python 3中).例如:

some_list = [1,2,3,4]
some_iterator = iter(some_list)
for value in some_iterator:
    print(value)

我正在尝试迭代看起来像这样的字典:

    d = {
    "list_one": [
        "hello",
        "two",
        "three"
    ],
    "list_two": [
        "morning",
        "rain"
    ]
}

我正在使用这个功能:

def combine_words(d):
    for k, v in d.items():
        a = {k: ("|".join(v))}
    return a

当我用print运行它时,我的输出只是一个键,值对.我不确定这里发生了什么.我的理想出局是:

{
'list_one': 'hello|two|three',
'list_two': 'morning|rain'
}

我正在写一个Rust函数,它接受一个数字列表和一个最大值,并将给定数字的所有倍数加到最大值(重复数只计算一次).我写的函数的第一个版本是

use std::collections::HashSet;

pub fn sum_of_multiples(limit: u32, factors: &[u32]) -> u32 {
    let set: HashSet<u32> = factors
        .iter()
        .map(|factor| {
            let top: u32 = (limit - 1) / factor;

            (1..=top).map(move |num| num * factor)
        }).flatten()
        .collect();

    set.iter().fold(0, |acc, num| acc + num)
}

(我知道合并HashSets这样可能不是最好的解决方案).这给出了预期的结果:

println!("{}", sum_of_multiples(100, &[3, 5])) // 2318

当我把呼叫collect从中间取出并连接到最后一个时fold,我得到了一个不同的答案:

pub fn sum_of_multiples(limit: u32, factors: &[u32]) -> u32 {
    let val: u32 = factors
        .iter()
        .map(|factor| {
            let top: u32 = (limit - …

我想知道在std :: multiset的迭代器上调用std :: advance是否在常量时间内完成.

当我尝试反转迭代器时,就像我在下面的例子中所做的那样,我实际上得到了两次打印的结果:

class TestIterator:

  def __init__(self):
    self.list = ['Alice', 'Bob', 'Charlie']

  def __iter__(self):
    self.idx = len(self.list) - 1
    return self

  def __next__(self):
    try:
      res = self.list[self.idx]
    except IndexError:
      raise StopIteration
    self.idx -= 1
    return res

names = TestIterator()

for name in names:
  print(name)

结果:

Charlie
Bob
Alice
Charlie
Bob
Alice

在上面的结果中,名称打印两次.我希望它以这种方式打印:

Charlie
Bob
Alice

然而,奇怪的是,经过一段时间的徘徊,我注意到,如果我有self.idx -= 2,它只打印一次,但序列仍然是错误的.例:

...
  def __next__(self):
    try:
      res = self.list[self.idx]
    except IndexError:
      raise StopIteration
    self.idx -= 2
    return res
...

这打印:

Charlie
Alice
Bob

我不明白为什么我在索引上减去2以使迭代器正常工作.为什么它会这样？