self 在同一函数中的多次使用 [英] Multiple uses of self in same function

问题描述

我与借阅检查员发生争执.我的问题有点复杂，但对于这种情况，我使用的是类似缓冲区的结构.我的缓冲区有一个函数 safe_write_to_slot，它首先检索第一个空元素(返回 Ok(location) 或 Err(error message) 的结果)，然后将值写入该检索到的位置.然而问题是，当我将检索到的位置分配给一个值时，rust 抱怨说我在几行之后再次重用了 self.如何首先调用返回结果的 (self) 函数，然后继续使用 self 执行某些操作?

I have an argument with the borrow checker. My problem is a little more complex, but for this case I am using a buffer like structure. My buffer has a function safe_write_to_slot that first retrieves the first empty element (returning a result that is either Ok(location) or an Err(error message)) and then writes a value to that retrieved location. The problem however is that when I assign the location that was retrieved to a value rust complains that I am reusing self again a few lines later. How do I first call a (self) function that returns a result, and then move on with self to do some action?

use std::result::Result;

struct Elems {
    pub elems : Vec<int>,
}

impl Elems {
    pub fn new() -> Elems {
        Elems{elems: vec![0,0,0,0,0,0]}
    }

    pub fn safe_write_to_slot(&mut self, elem : uint) -> Result<(), &str> {
        let loc = try!(self.get_slot());

        self.unsafe_write_to_slot(loc);

        Ok(())
    }

    pub fn get_slot(&self) -> Result<uint, &str>{
        let mut loc = -1i;

        for x in range(0, self.elems.len()) {
            if *self.elems.get(x) == 0 {
                loc = x as int;
            }
        }

        if loc != -1 { Ok(loc as uint) } else { Err("No free slots") }
    }

    fn unsafe_write_to_slot(&mut self, elem : uint) {
        self.elems[elem] = 1;
    }
}

我得到的错误是:

   Compiling borrow v0.0.1 (file:///borrow)
main.rs:19:9: 19:13 error: cannot borrow `*self` as mutable because it is also borrowed as immutable
main.rs:19         self.unsafe_write_to_slot(loc);
                   ^~~~
main.rs:17:24: 17:28 note: previous borrow of `*self` occurs here; the immutable borrow prevents subsequent moves or mutable borrows of `*self` until the borrow ends
main.rs:17         let loc = try!(self.get_slot());
                                  ^~~~
/main.rs:17:19: 17:41 note: expansion site
main.rs:22:6: 22:6 note: previous borrow ends here
main.rs:16     pub fn safe_write_to_slot(&mut self, elem : uint) -> Result<(), &str> {
/main.rs:22     }
               ^
main.rs:37:9: 37:29 error: cannot assign to immutable dereference (dereference is implicit, due to indexing)
main.rs:37         self.elems[elem] = 1;
                   ^~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
Could not compile `borrow`.

To learn more, run the command again with --verbose.

推荐答案

Lifetime inference 导致了这里的问题.

Lifetime inference is causing the issue here.

get_slot 方法解释为:

pub fn get_slot<'a>(&'a self) -> Result<uint, &'a str> {

结果绑定到与 self 相同的生命周期，这会导致 self 保持冻结状态，直到结果被删除.但是，您不想将 self 的生命周期链接到 &str，因为您只返回字符串文字.通过在 get_slot 和 safe_write_to_slot 中将 &str 更改为 &'static str，您将无法获得不再出错，因为在调用 unsafe_write_to_slot 时，self 将不再被认为是借用的.

The result is bound to the same lifetime as self, which causes self to remain frozen until the result is dropped. However, you don't want to link the lifetime of self to &str, because you're only returning string literals. By changing &str to &'static str in get_slot and safe_write_to_slot, you won't get the error anymore, because self will not be considered borrowed anymore when calling unsafe_write_to_slot.

这篇关于self 在同一函数中的多次使用的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！