Rust 如何通过'Option<&；mut…>；`在不导致移动错误的情况下执行多个函数调用？

既然可以将可变引用传递给周围的向量（而不引起移动），那么如何将

选项

多次传递给函数而不引起借用检查错误

这个简单的示例仅显示了将

选项

多次传递给函数时发生的情况：

fn maybe_push(mut v_option: Option<&mut Vec<usize>>) -> usize {
    let mut c = 0;
    if let Some(ref mut v) = v_option.as_mut() {
        for i in 0..10 {
            v.push(i);
            c += i;
        }
    }

    return c;
}

fn maybe_push_multi(v_option: Option<&mut Vec<usize>>) -> usize {
    let mut c = 0;
    c += maybe_push(v_option);
    c += maybe_push(v_option);
    c += maybe_push(None);
    return c;
}

fn main() {
    let mut v: Vec<usize> = vec![];
    let v_option = Some(&mut v);
    println!("{}", maybe_push_multi(v_option));
}

fn可能推送（mut v_选项：选项）->usize{
设mutc=0；
如果让一些（ref mut v）=v_选项.as_mut（）{
因为我在0..10{
v、 推（i）；
c+=i；
}
}
返回c；
}
fn可能推动多个（v\u选项：选项）->使用{
设mutc=0；
c+=可能推送（v_选项）；
c+=可能推送（v_选项）；
c+=可能推送（无）；
返回c；
}
fn main（）{
让mut v:Vec=Vec！[]；
设v_option=Some（&mut v）；
println！（“{}”，可能是推多（v_选项））；
}

（）

给出了错误：

错误[E0382]：使用移动值：`v_选项`
--> :17:21
|
16 | c+=可能的推送（v|U选项）；
|-----此处移动的值
17 | c+=可能的推送（v|U选项）；
|^^^^^^^^^移动后此处使用的值
|
=注意：发生移动是因为'v_option'的类型为'std:：option:：option'，而该类型不实现'Copy'特性

如果不想将

选项移动到函数中，也可以通过引用传递该选项

fn maybe_push(mut v_option: &mut Option<&mut Vec<usize>>) -> usize

// ...

maybe_push_twice(&mut v_option);

与：

如果不希望将
选项移动到函数中，也可以通过引用传递该选项

fn maybe_push(mut v_option: &mut Option<&mut Vec<usize>>) -> usize

// ...

maybe_push_twice(&mut v_option);

与：

您可以使用
match
表达式分解
选项
，然后为函数的每次调用创建一个新的
选项
值

fn可能推两次（v\u选项：选项）->usize{
设mutc=0；
匹配v_选项{
一些（v）=>{
c+=可能推动（一些（v））；
c+=可能推动（一些（v））；
}
无=>{
c+=可能推送（无）；
c+=可能推送（无）；
}
};
返回c；
}


这里有一个更方便的方法：

fn maybe_push_twice(mut v_option: Option<&mut Vec<usize>>) -> usize {
    let mut c = 0;
    c += maybe_push(v_option.as_mut().map(|x| &mut **x));
    c += maybe_push(v_option);
    return c;
}

fn可能推两次（mut v_选项：选项）->usize{
设mutc=0；
c+=可能的推送（v_option.as_mut（）.map（|x |&mut**x））；
c+=可能推送（v_选项）；
返回c；
}


您可以使用特征而不是宏：

trait RefMut<T> {
    fn ref_mut(&mut self) -> Option<&mut T>;
}

impl<'t, T> RefMut<T> for Option<&'t mut T>{
    #[inline]
    fn ref_mut(&mut self) -> Option<&mut T>{
        self.as_mut().map(|x| &mut**x)
    }
}

fn maybe_push_twice(mut v_option: Option<&mut Vec<usize>>) -> usize {
    let mut c = 0;
    c += maybe_push(v_option.ref_mut());
    c += maybe_push(v_option);
    return c;
}

trait RefMut{
fn ref_mut（&mut self）->选项；
}
恳求{
#[内联]
fn ref_mut（&mut self）->选项{
self.as_mut（）.map（|x |&mut**x）
}
}
fn可能推两次（多个选项：选项）->使用{
设mutc=0；
c+=可能的推送（v_option.ref_mut（））；
c+=可能推送（v_选项）；
返回c；
}
您可以使用
匹配表达式来分解
选项
，然后为函数的每次调用创建一个新的
选项
值
maybe\u push（）
：

fn可能推两次（v\u选项：选项）->usize{
设mutc=0；
匹配v_选项{
一些（v）=>{
c+=可能推动（一些（v））；
c+=可能推动（一些（v））；
}
无=>{
c+=可能推送（无）；
c+=可能推送（无）；
}
};
返回c；
}


这里有一个更方便的方法：

fn maybe_push_twice(mut v_option: Option<&mut Vec<usize>>) -> usize {
    let mut c = 0;
    c += maybe_push(v_option.as_mut().map(|x| &mut **x));
    c += maybe_push(v_option);
    return c;
}

fn可能推两次（mut v_选项：选项）->usize{
设mutc=0；
c+=可能的推送（v_option.as_mut（）.map（|x |&mut**x））；
c+=可能推送（v_选项）；
返回c；
}


您可以使用特征而不是宏：

trait RefMut<T> {
    fn ref_mut(&mut self) -> Option<&mut T>;
}

impl<'t, T> RefMut<T> for Option<&'t mut T>{
    #[inline]
    fn ref_mut(&mut self) -> Option<&mut T>{
        self.as_mut().map(|x| &mut**x)
    }
}

fn maybe_push_twice(mut v_option: Option<&mut Vec<usize>>) -> usize {
    let mut c = 0;
    c += maybe_push(v_option.ref_mut());
    c += maybe_push(v_option);
    return c;
}

trait RefMut{
fn ref_mut（&mut self）->选项；
}
恳求{
#[内联]
fn ref_mut（&mut self）->选项{
self.as_mut（）.map（|x |&mut**x）
}
}
fn可能推两次（多个选项：选项）->使用{
设mutc=0；
c+=可能的推送（v_option.ref_mut（））；
c+=可能推送（v_选项）；
返回c；
}
作为现有答案的替代方案，这很好。虽然参数是有效的，但在多次将参数传递给函数时使用它会很烦人。我很想把
opt.as_mut（）.map（|x |&mut**x）
放入宏中。很高兴知道这是现有答案的替代方案。虽然参数是有效的，但在多次将参数传递给函数时使用它会很烦人。我很想把
opt.as_mut（）.map（|x |&mut**x）
放入宏中。