我想知道在STL中是否有一个迭代器在返回之前取消引用指向的对象.在操作聚合指针的容器时,这可能非常有用.以下是我希望能够做到的一个例子:

#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

int main()
{
  vector<int*> vec;

  int i = 1;
  int j = 2;
  int k = 3;

  vec.push_back(&i);
  vec.push_back(&j);
  vec.push_back(&k);

  copy(deref_iterator(vec.begin()), 
       deref_iterator(vec.end()), 
       ostream_iterator<int>(cout, " ")); // prints "1 2 3"

  return 0;
}

 public synchronized X getAnotherX(){ 
  if(iterator.hasNext()){
   X b = iterator.next();
   String name = b.getInputFileName();
  ...
   return b;
  }
  else{return null;}
 }

尽管声明头中的synchronized语句,我仍然在我使用iterator.next()的行中得到一个ConcurrentModificationException异常; 什么错了？

演讲中有一篇说"这些方法很懒散!"

Iterable transform(Iterable, Function)*
Iterable filter(Iterable, Predicate)*
T find(Iterable<T>, Predicate)
Iterable concat(Iterable<Iterable>)
Iterable cycle(Iterable)
T getOnlyElement(Iterable<T>)
Iterable<T> reverse(List<T>)

有人可以帮助我理解他们的意思,让我说我有一个集合,Persons我应用过滤器只返回姓氏为DOE的人.

那么这是否意味着"过滤仅在第一次调用doeOnly.next()时发生？"

List<Person> persons= ....
Iterable doeOnly= Iterables.filter(persons,DOE_AS_LAST_NAME_PREDICATE);

勉强的是,这段小代码抛出了上面提到的Exception.另外,查看网络上发布的代码似乎是正确的:

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorTest {

    ArrayList<Integer> arr = new ArrayList<Integer>();

    Iterator i = arr.iterator();

    public void show() {
        arr.add(2);
        arr.add(5);
        arr.add(9);

        while(i.hasNext()){
            System.out.println(i.next());
        }
    }
}

有什么建议？谢谢

就像问题所说,我想知道原因.因为当我试图获得const非const迭代器之间的距离时出现错误.

vector<int> v;
auto it=v.begin();
auto cit=v.cbegin();
distance(it,cit);


no matching function for call to ‘distance(__gnu_cxx::__normal_iterator<int*, std::vector<int> >&, __gnu_cxx::__normal_iterator<const int*, std::vector<int> >&)

从我对迭代器的有限理解,我认为没有理由不应该工作.

我想在PHP迭代器中使用关联数组:

http://php.net/manual/en/class.iterator.php

可能吗？

我定义了这些方法:

  public function rewind(){    
    reset($this->_arr);
    $this->_position = key($this->_arr);
  }

  public function current(){    
    return $this->_arr[$this->_position];
  }

  public function key(){
    return $this->_position;
  }

  public function next(){    
    ++$this->_position;
  }

  public function valid(){    
    return isset($this->_arr[$this->_position]);
  }

问题是它没有正确迭代.我只得到一个元素.

我认为这是因为++$this->_positionnext()方法中的代码没有任何影响,因为_position是一个字符串(关联数组的键).

那我怎么去这个类型的数组的下一个元素？

从表面上看,它看起来像两者drain并into_iter提供类似的迭代器,即集合的值.但是,他们是不同的:

fn main() {
    let mut items1 = vec![0u8, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let items2 = items1.clone();

    println!("{:?}", items1.drain().count());
    println!("{:?}", items2.into_iter().count());

    println!("{:?}", items1);
    // println!("{:?}", items2); Moved
}

drain需要&mut收集和收集可用之后.into_iter消耗该集合.每个迭代器的适当用途是什么？

我有这样的代码:

let things = vec![/* ...*/]; // e.g. Vec<String>
things
    .map(|thing| {
        let a = try!(do_stuff(thing));
        Ok(other_stuff(a))
    })
    .filter(|thing_result| match *thing_result {
        Err(e) => true,
        Ok(a) => check(a),
    })
    .map(|thing_result| {
        let a = try!(thing_result);
        // do stuff
        b
    })
    .collect::<Result<Vec<_>, _>>()

在语义方面,我想在第一个错误后停止处理.

上面的代码有效,但感觉非常麻烦.有没有更好的办法？我查看了类似的文档filter_if_ok,但我没有找到任何东西.

我知道collect::<Result<Vec<_>, _>>,它很有效.我特意试图消除以下样板:

• 在过滤器的关闭,我必须使用match的thing_result.我觉得这应该只是一个单行,例如.filter_if_ok(|thing| check(a)).
• 每次我使用时map,我都要包含一个额外的声明let a = try!(thing_result);,以便处理一个可能性Err.再一次,我觉得这可以被抽象出来.map_if_ok(|thing| ...).

有没有其他方法可以用来获得这种简洁程度,或者我只是需要强硬一点？

我正在努力创造自己的boost::adaptors::transformed.

这是相关的提升代码.

这是它的用法(由LogicStuff的SO答案修改): -

C funcPointer(B& b){ 
    //"funcPointer" is function convert from "B" to "C"
    return instance-of-C
}

MyArray<B> test;  //<-- any type, must already have begin() & end()

for(C c : test | boost::adaptor::transformed(funcPointer)) {
    //... something ....
}

结果将与: -

for(auto b : test) {
    C c = funcPointer(b);
    //... something ...
}

我的尝试

我创造了CollectAdapter这样的目标boost::adaptor::transformed.
它在大多数常见情况下都能正常工作

这是完整的演示和备份.(与下面的代码相同)

有问题的部分是CollectAdapter- 我的图书馆的核心.
我不知道是否应该缓存collection_ …

我有此代码，它适用于GCC：

#include <map>

class Foo;
class Bar;

typedef std::map<Foo,Bar> MyMap;

MyMap::iterator i;

class Foo
{
    MyMap::iterator some_data;
};

当前设计的代码（令人讨厌的是，是的，是我一直坚持使用的代码）要求map<Foo,Bar>::iterator可用于Foo和Bar。

之所以起作用，是因为GCC库实现恰好不需要实例化地图的键类型来实例化迭代器。

这样可以保证吗？在定义映射迭代器类型时，该标准似乎有些过时。该代码的移植性如何？