使用Option <＆mut> 2次

Question

以下程序可以正常编译：

fn write_u16(bytes: &mut Vec<u8>, value: u16) {
    bytes.push((value >> 8) as u8);
    bytes.push(value as u8);
}

fn write_u32(bytes: &mut Vec<u8>, value: u32) {
    write_u16(bytes, (value >> 16) as u16);
    write_u16(bytes, value as u16);
}

现在，我将字节类型更改为Option <＆mut Vec>：

fn write_u16(bytes_opt: Option<&mut Vec<u8>>, value: u16) {
    if let Some(bytes) = bytes_opt {
        bytes.push((value >> 8) as u8);
        bytes.push(value as u8);
    }
}

fn write_u32(bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    write_u16(bytes_opt, (value >> 16) as u16);
    write_u16(bytes_opt, value as u16);
}

该程序现在无法编译：

main.rs:10:15: 10:24 error: use of moved value: `bytes_opt`
main.rs:10     write_u16(bytes_opt, value as u16);
                         ^~~~~~~~~
main.rs:9:15: 9:24 note: `bytes_opt` moved here because it has type `core::option::Option<&mut collections::vec::Vec<u8>>`, which is non-copyable
main.rs:9     write_u16(bytes_opt, (value >> 16) as u16);
                        ^~~~~~~~~
error: aborting due to previous error

我不太了解，为什么不能两次使用Option，如何解决此问题？

我可以想象解决该问题的唯一方法是：

fn write_u32(bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    if let Some(bytes) = bytes_opt {
        write_u16(Some(bytes), (value >> 16) as u16);
        write_u16(Some(bytes), value as u16);
    } else {
        write_u16(None, (value >> 16) as u16);
        write_u16(None, value as u16);
    }
}

但这不是很好的代码。

Answer 1

尽管我怀疑在这种情况下您不应该这样做（正如已经评论过的那样），但是在这种情况下，可以在安全的情况下重新借用可变引用：

fn write_u32(mut bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    write_u16(bytes_opt.as_mut().map(|x| &mut **x), (value >> 16) as u16);
    write_u16(bytes_opt, value as u16);
}

bytes_opt.as_mut().map(|x| &mut **x)也可以match bytes_opt { Some(&mut ref mut x) => Some(x), None => None, }写入。 一个漂亮的弯弯曲曲的模式（从左到右读取： &mut mut-取消引用所包含的值， ref mut mut-然后对其进行新的可变引用），但是它有效并且避免了所有权问题。

Answer 2

错误消息告诉您他们的关键事项：

bytes_opt移至此处，因为其类型为core::option::Option<&mut collections::vec::Vec<u8>> ，该类型不可复制

您的函数签名指出它将使用该参数：

fn write_u16(bytes_opt: Option<&mut Vec<u8>>, value: u16)
//                      ^~~~~~~~~~~~~~~~~~~~

然而，消费它，它也消耗了可变引用。 如果您具有Option<u8>或Option<&Vec<u8>>类的其他类型，则编译器可以为您插入变量的隐式副本。 但是，您不允许制作可变引用的副本，因为那样的话您将拥有可变别名 ，出于内存安全的原因，编译器不允许使用这些别名 。

当仅传递&mut Vec<u8> ，编译器便能够跟踪引用，并且一次只能看到一个条目具有引用，因此它允许它。 但是，当可变引用嵌入另一种类型时，它无法跟踪。

要使其真正发挥作用，它有点难看，并且有更多的mut修饰符比我想要的多：

fn write_u16(bytes_opt: &mut Option<&mut Vec<u8>>, value: u16) {
    if let Some(ref mut bytes) = *bytes_opt {
        bytes.push((value >> 8) as u8);
        bytes.push(value as u8);
    }
}

fn write_u32(mut bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    write_u16(&mut bytes_opt, (value >> 16) as u16);
    write_u16(&mut bytes_opt, value as u16);
}

在@ChrisMorgan的提示下，我得到了一些适合您原始API的内容：

fn write_u16(bytes_opt: Option<&mut Vec<u8>>, value: u16) {
    if let Some(bytes) = bytes_opt {
        bytes.push((value >> 8) as u8);
        bytes.push(value as u8);
    }
}

fn write_u32(bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    if let Some(bytes) = bytes_opt {
        write_u16(Some(bytes), (value >> 16) as u16);
        write_u16(Some(bytes), value as u16);
    }
}