Question

一些示例代码：（playpen）

let data = [0, 1, 2, 3, 4];
let mut iter = data.iter();
println!("{}", iter.next().unwrap());
println!("{}", iter.skip(3).next().unwrap());

按预期打印0和4。

我很好奇skip操作是否为切片迭代器的常量时间？在源代码中我只找到了this implementation for skip，它导致了Skip结构的Iterator implementation。

这似乎是一个通用的O（n）跳过，我看不到任何可以做指针运算的基于指针的迭代器的专门化。

我是否遗漏了skip的实施内容？或者还有其他方法可以做到这一点吗？

Answer 1

std还没有快进内置。

正如克里斯所说，它可以用skip来实现，这有时会优化为O（1）。不幸的是，优化并不总是发生，我的实验发现了像

这样的函数

pub fn foo(xs: &[u32], x: usize) -> u32 {
    *xs.iter().skip(x).next().unwrap()
}

优化（选择级别3）至

.LBB6_2:
    pushq   %rax
.Ltmp10:
    .cfi_def_cfa_offset 16
    movq    (%rdi), %rdx
    movq    8(%rdi), %rdi
    xorl    %eax, %eax
    testq   %rdi, %rdi
    movq    %rdx, %rcx
    je  .LBB6_4
    leaq    4(%rdx), %rcx
    movq    %rdx, %rax
.LBB6_4:
    testq   %rsi, %rsi
    je  .LBB6_9
    leaq    (%rdx,%rdi,4), %rdx
    .align  16, 0x90
.LBB6_6:
    testq   %rax, %rax
    je  .LBB6_12
    decq    %rsi
    cmpq    %rdx, %rcx
    movq    %rdx, %rdi
    movl    $0, %eax
    je  .LBB6_8
    leaq    4(%rcx), %rdi
    movq    %rcx, %rax
.LBB6_8:
    testq   %rsi, %rsi
    movq    %rdi, %rcx
    jne .LBB6_6
.LBB6_9:
    testq   %rax, %rax
    je  .LBB6_12
    movl    (%rax), %eax
    popq    %rdx
    retq
.LBB6_12:
    movq    _ZN6option15Option$LT$T$GT$6unwrap14_MSG_FILE_LINE20ha41302a4e895de223qFE@GOTPCREL(%rip), %rdi
    callq   _ZN9panicking5panic20h90c2ad20c9dac62bKRCE@PLT

特别值得注意的是.LBB6_6: ... jne .LBB6_6序列：它是一个循环。

幸运的是，至少有一种方法，它有一个额外的有用属性：它不需要更改类型，因此可以直接使用。

可以将切片迭代器转换回它使用as_slice表示的切片：Iter<T>和&[T]实际上是同构的，它们的不同主要是因为出于优化原因。一旦我们得到切片，我们就可以对它进行切片和切块以获得更短的内存区域，然后仅在这些元素上创建一个迭代器。所有的生命周期都在发挥作用，而且我们只有完全相同的类型而没有一些元素。

use std::slice::Iter;
use std::cmp;

pub fn skip(iter: &mut Iter<u32>, x: usize) {
    let s = iter.as_slice();
    *iter = s[cmp::min(x, s.len())..].iter();
}

像skip(&mut some_iter, 10)一样使用。

min调用是复制Iterator::skip的行为并避免恐慌（跳过比迭代器包含的更多元素只会导致返回＆＃39;值为空）

要在实践中查看，请考虑将foo转换为使用新的skip：

pub fn foo(xs: &[u32], x: usize) -> u32 {
    let mut iter = xs.iter();
    skip(&mut iter, x);
    *iter.next().unwrap()
}

优化为：

.LBB7_2:
    pushq   %rax
.Ltmp12:
    .cfi_def_cfa_offset 16
    movq    8(%rdi), %rax
    cmpq    %rsi, %rax
    cmovbq  %rax, %rsi
    cmpq    %rax, %rsi
    je  .LBB7_4
    movq    (%rdi), %rax
    movl    (%rax,%rsi,4), %eax
    popq    %rdx
    retq
.LBB7_4:
    movq    _ZN6option15Option$LT$T$GT$6unwrap14_MSG_FILE_LINE20ha41302a4e895de223qFE@GOTPCREL(%rip), %rdi
    callq   _ZN9panicking5panic20h90c2ad20c9dac62bKRCE@PLT

值得注意的是，没有循环。它不是完全与xs[x]实现一样短（下面的asm，供参考），但它非常接近（2条额外的说明）。

.LBB5_2:
    pushq   %rax
.Ltmp8:
    .cfi_def_cfa_offset 16
    movq    8(%rdi), %rdx
    cmpq    %rsi, %rdx
    jbe .LBB5_4
    movq    (%rdi), %rax
    movl    (%rax,%rsi,4), %eax
    popq    %rdx
    retq
.LBB5_4:
    leaq    panic_bounds_check_loc1464(%rip), %rdi
    callq   _ZN9panicking18panic_bounds_check20h5ef74c98f9f69401jSCE@PLT

（事实上，我几乎认为LLVM存在差异：看起来它可以用两个cmp和一个cmovbq做得更好。）

很好，它很好地优化，但是，正如Iterator::skip方法的问题所示，这是不可靠的。但是，无论优化级别如何，as_slice方法都是O（1）。

我怀疑slice::Iter可以覆盖skip方法来执行快进，然后返回Skip { iter: self, n: 0 }，从而保证skip上的Iter是实际上有效。但是（如上所述）感觉有点像黑客，和，仍会导致类型改变，因此无法就地使用。

Answer 2

在库中没有任何东西可以实现这一点，但有时候不稳定的RandomAccessIterator.idx特征方法可能会做你想要的。

检查生成的汇编代码表明编译器可以优化至少一些从O（n）到O（1）的跳过。作为一个简单的例子，给定x: &[u32]，*x.iter().skip(5).next().unwrap()和x[5]生成相同的汇编代码。我不确定优化跳过会有多彻底，但绝对不会破旧。这是优化编译器的一个很好的想法：你所寻求的这种专业化可以在编译器而不是代码中实现，这通常可以帮助你避免错过可以完成的优化，但是（因为它们不是完美的）偶尔会导致错过的优化，你期望发生。

切片迭代器可以在恒定时间内推进多个元素吗？

2 个答案: