标签: iterator

实际上,有很多方法可以将文件读入字符串.两个常见的是使用ifstream :: read直接读取字符串并使用steambuf_iterators和std :: copy_n:

使用ifstream :: read:

std::ifstream in {"./filename.txt"};
std::string contents;
in.seekg(0, in.end);
contents.resize(in.tellg());
in.seekg(0, in.beg);
in.read(&contents[0], contents.size());

使用std :: copy_n:

std::ifstream in {"./filename.txt"};
std::string contents;
in.seekg(0, in.end);
contents.resize(in.tellg());
in.seekg(0, in.beg);
std::copy_n(std::streambuf_iterator<char>(in), 
            contents.size(), 
            contents.begin();

许多基准测试显示第一种方法比第二种方法快得多(在我的机器中使用g ++ - 4.9它使用-O2和-O3标志的速度大约快10倍)我想知道造成这种差异的原因可能是什么.性能.

我们如何使用std::transform,如果我们不希望每个元素转变成一个变换元素,但2？

以下伪代码说明了我想要实现的目标

std::transform(a.cbegin(), a.cend(), std::back_inserter(b), [](T const& x) {
    return f(x) and g(x);
});

当然,我可以调用std::transform两次,但那会很烦人.也许我们需要提供一个自定义插件.还有其他选择吗？

编者注:此代码示例来自1.0之前的Rust版本,并且在语法上不是有效的Rust 1.0代码.此代码的更新版本会产生不同的错误,但答案仍包含有价值的信息.

我想创建一个生成素数流的迭代器.我的一般思维过程是用连续的过滤器包装一个迭代器,例如你开始

let mut n = (2..N)

然后对于每个素数,你改变迭代器并添加一个过滤器

let p1 = n.next()
n = n.filter(|&x| x%p1 !=0) 
let p2 = n.next()
n = n.filter(|&x| x%p2 !=0) 

我试图使用以下代码,但我似乎无法让它工作

struct Primes {
    base: Iterator<Item = u64>,
}

impl<'a> Iterator for Primes<'a> {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        let p = self.base.next();
        match p {
            Some(n) => {
                let prime = n.clone();
                let step = self.base.filter(move |&: &x| {x%prime!=0});
                self.base = &step as &Iterator<Item = u64>;
                Some(n) …

我必须使用hasNext()和next()方法实现Iterator接口(由Java API定义),该接口应返回源自异步处理的HTTP响应(使用Akka actor处理)的结果元素.

必须满足以下要求:

• 不要阻塞并等待异步操作完成,因为生成大型结果集可能需要一段时间(迭代器应该在结果元素可用时立即返回)
• Iterator.next()应该阻塞,直到下一个元素可用(如果没有更多元素可以抛出异常)
• Iterator.hasNext()应该返回true,只要有更多的元素要来(即使下一个元素还没有)
• 结果总数事先未知.生成actor的结果将在完成时发送特定的"结束消息".
• 尽量避免使用InterruptedException,例如当迭代器在空队列上等待但不会生成更多元素时.

我还没有研究过Java 8流或Akka流.但由于我基本上必须遍历队列(有限流),我怀疑还有任何合适的解决方案.

目前,我的Scala实现存根使用java.util.concurrent.BlockingQueue,如下所示:

class ResultStreamIterator extends Iterator[Result] {
    val resultQueue = new ArrayBlockingQueue[Option[Result]](100)

    def hasNext(): Boolean = ???  // return true if not done yet
    def next(): Result = ???      // take() next element if not done yet

    case class Result(value: Any) // sent by result producing actor
    case object Done              // sent by result producing actor when finished

    class ResultCollector extends Actor {
        def receive = {
           case Result(value) => …

我非常喜欢使用数组映射从另一个对象数组创建对象数组的函数式编程风格.

$newObjects = array_map(
  function($oldObject) {
    return new NewObject($oldObject);
  },
  $oldObjects
);

这一切都运行正常,但我真的希望能够设置数组的索引,使它们是原始对象的id,以便于从数组中搜索和检索,但我想不出如何做其他的那么不是优雅.

$newObjects = array();
foreach ($oldObjects as $oldObject) {
  $newObjects[$oldObject->getId()] = new NewObject($oldObject);
}

有没有办法可以做到这一点？

我有一个Board(aka &mut Vec<Vec<Cell>>)我想迭代它时更新.我想要更新的新值来自一个函数,它需要一个&Vec<Vec<Cell>>我正在更新的集合.

我尝试了几件事:

1. 使用board.iter_mut().enumerate(),row.iter_mut().enumerate()以便我可以cell在最里面的循环中更新.Rust不允许调用该next_gen函数,因为它需要a,&Vec<Vec<Cell>>并且当您已经有一个可变引用时,您不能拥有不可变引用.

2. 更改next_gen功能签名以接受a &mut Vec<Vec<Cell>>.Rust不允许对对象进行多次可变引用.

我目前正在将所有更新推迟到a HashMap,然后在我执行迭代后应用它们:

fn step(board: &mut Board) {
    let mut cells_to_update: HashMap<(usize, usize), Cell> = HashMap::new();
    for (row_index, row) in board.iter().enumerate() {
        for (column_index, cell) in row.iter().enumerate() {
            let cell_next = next_gen((row_index, column_index), &board);
            if *cell != cell_next {
                cells_to_update.insert((row_index, column_index), cell_next);
            }
        }
    }

    println!("To Update: {:?}", cells_to_update);
    for ((row_index, column_index), cell) in …

我不确定我正在尝试编写的代码的相应数学术语.我想生成唯一整数的组合,其中每个组合的"有序子集"用于排除某些后来的组合.

希望一个例子可以说明这一点:

from itertools import chain, combinations
?
mylist = range(4)
max_depth = 3

rev = chain.from_iterable(combinations(mylist, i) for i in xrange(max_depth, 0, -1))
for el in list(rev):
    print el

该代码导致输出包含我想要的所有子集,但也包含一些我不需要的额外子集.我手动插入注释以指示我不想要的元素.

(0, 1, 2)
(0, 1, 3)
(0, 2, 3)
(1, 2, 3)
(0, 1)  # Exclude: (0, 1, _) occurs as part of (0, 1, 2) above
(0, 2)  # Exclude: (0, 2, _) occurs above
(0, 3)  # Keep
(1, 2)  # Exclude: (1, 2, _) occurs above …

我正在遍历带有auto(附加代码)的向量.在遍历时,我还在后面添加了一些元素.我没想到我得到的输出.

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

vector <int> dynamic_vector;

void access( )
{
    for ( auto i : dynamic_vector ) {
        if ( i == 3 ) {
            dynamic_vector.push_back( 4 );
            dynamic_vector.push_back( 5 );
        }
        cout << i << endl;
    }
}

int main() {
    dynamic_vector.push_back( 1 );
    dynamic_vector.push_back( 2 );
    dynamic_vector.push_back( 3 );
    access( );
    return 0;
}

输出:

1
2
3

我期待从1到5的所有数字都会被打印出来.我无法理解如何遍历汽车工作？

我正在研究std::upper_bound从http://www.cplusplus.com/reference/algorithm/upper_bound/ 和我遇到的事实，这可能在上线时间来运行非随机访问迭代器。

我需要将此用于已排序的向量。现在，我不知道什么是非随机访问迭代器，以及它是否将在排序后的向量上以对数时间运行。

谁能为我清除此问题。

我可能没有看到森林的树木,但我想知道我如何设计我的方法,以对抗硬集合类型,而不是反对迭代器.考虑这种方法.

pub fn print_strings(strings: Vec<String>) {
    for val in strings.iter() {
        println!("{}", val);
    }
}

显然,如果我想用一个HashSet或那个来使用它,这就不足了HashMap.

所以,我试过这个:

use std::collections::*;

fn main () {
    let strings = vec!("Foo", "Bar");

    let mut more_strings = HashMap::new();
    more_strings.insert("foo", "bar");
    more_strings.insert("bar", "foo");

    print_strings(&strings.iter());
    print_strings(&more_strings.values())
}

fn print_strings(strings: &Iterator<Item=&str>) {
    for val in strings {
        println!("{}", val);
    }
}

游戏围栏(也用于查看冗长的编译器错误)

http://is.gd/EYIK11

不幸的是,这似乎也没有做到这一点.我错过了什么？