Question

我拥有一个3号数组的所有权，我想迭代它，随时移动元素。基本上，我希望为固定大小的数组实现def +(String)。

由于数组不在标准库中实现这个特性（我理解为什么），是否有解决方法来获得所需的效果？我的对象不是IntoIterator也不是Copy。我可以从数组中创建Clone，然后迭代到Vec，但我甚至不确定如何做到这一点。

（有关信息，我想要完成Complete）

的数组

以下是一个简单的情况示例（天真Vec尝试）：

iter()

playground

给出

// No-copy, No-clone struct
#[derive(Debug)]
struct Foo;

// A method that needs an owned Foo
fn bar(foo: Foo) {
    println!("{:?}", foo);
}

fn main() {
    let v: [Foo; 3] = [Foo, Foo, Foo];

    for a in v.iter() {
        bar(*a);
    }
}

Answer 1

您需要的核心功能是在不移动数据的情况下从数组中获取值。两个这样的解决方案是：

使用mem::replace和mem::uninitialized将数组中的每个值替换为垃圾，获取原始数据：
```
let one = unsafe { mem::replace(&mut v[0], mem::uninitialized()) };
bar(one);
```
使用ptr::read将值保留在数组中但返回拥有的值：
```
let two = unsafe { ptr::read(&v[0]) };
bar(two);
```

这只是在循环中做了几次这样的事情，你很高兴。

只有一个小问题：你看到那些unsafe？你猜到了;在更广泛的案例中，这完全可怕地被打破了：

我们将该数组中的任意位保留为Foo。在 this 的情况下，当该数组超出范围时没有什么特别的事情，因为类型Drop没有特殊的Foo实现，但如果有，则会访问无效记忆。坏消息！
你可以使用mem::forget忽略数组并防止它被删除，但是......
如果在移出值的过程中发生恐慌（例如bar函数内的某处），则阵列将处于部分未初始化状态。这是可以调用Drop实现的另一个（微妙的）路径，所以现在我们必须知道数组仍然拥有哪些值以及哪些值已被移出。我们有责任释放我们仍然拥有的价值而不是其他价值观。
没有什么可以阻止我们自己意外地访问数组中新失效的值。

正确的解决方案是跟踪数组中有多少值有效/无效。删除数组后，您可以删除剩余的有效项并忽略无效项。您还必须避免自动析构函数运行。如果我们能够为不同大小的数组做这项工作，那也真的很好......

这是arrayvec的用武之地。它没有完全相同的实现（因为它更聪明），但它确实具有相同的语义：

extern crate arrayvec;

use arrayvec::ArrayVec;

#[derive(Debug)]
struct Foo;

fn bar(foo: Foo) {
    println!("{:?}", foo)
}

fn main() {
    let v = ArrayVec::from([Foo, Foo, Foo]);

    for f in v {
        bar(f);
    }
}

Answer 2

您可以使用Option<Foo>数组代替Foo数组。当然它有一些记忆惩罚。函数take()用None替换数组中的值。

#[derive(Debug)]
struct Foo;

// A method that needs an owned Foo
fn bar(foo: Foo) { println!("{:?}", foo); }

fn main() {
    let mut v  = [Some(Foo),Some(Foo),Some(Foo)];

    for a in &mut v {
        a.take().map(|x| bar(x));
    }
}

Answer 3

使用非词汇生存期功能（仅在每晚中）和定长切片模式，您可以移出数组：

#![feature(nll)]

#[derive(Debug)]
struct Foo;

fn bar(foo: Foo) {
    println!("{:?}", foo);
}

fn main() {
    let v: [Foo; 3] = [Foo, Foo, Foo];
    let [a, b, c] = v;

    bar(a);
    bar(b);
    bar(c);
}

但是，如果数组很大，此解决方案将无法很好地扩展。

如果您不介意额外分配，则可以选择将框装箱并将其转换为Vec：

fn main() {
    let v: [Foo; 3] = [Foo, Foo, Foo];
    let v = Vec::from(Box::new(v) as Box<[_]>);

    for a in v {
        bar(a);
    }
}

如果数组很大，则可能是一个问题。但是，如果数组很大，则您不应该首先在堆栈中创建它！

如何从数组中移出值？

3 个答案: