引用生命周期与相同的生命周期范围冲突

Question

引用生命周期与相同的生命周期范围冲突

3

我正在尝试在Rust中存储和使用可选的回调句柄，它类似于我正在存储的结构体的方法。只要我不将自身的引用传递给回调，它就可以工作。但是这样做会导致使用对象引用的生命周期错误（E0312）。生命周期似乎是一样的，我无法想出如何更改才能使其工作。

type Callback<'a> = Fn(&'a mut Func, i32) -> i32;

struct Func<'a> {
    val: i32,
    func: Option<Box<Callback<'a>>>,
}

impl<'a, 'b> Func<'b> {
    fn exec(&'a mut self, val: i32) -> i32 {
        if let Some(ref f) = self.func {
            return f(self, val);
        };
        0i32
    }
}

fn main() {
    let mut a32 = Func{
        val: 10i32,
        func: Some(Box::new(|ref mut s, val: i32| -> i32 {
            let v = s.val;
            s.val += 1;
            val * 32 + v
        }))
    };
    println!("a32(4) = {}", a32.exec(4i32));
    println!("a32(4) = {}", a32.exec(4i32));
}

有没有办法解决这个问题，还是我遇到了编译器的bug？

使用rustc 1.15.0（10893a9a3 2017-01-19）。

也可以在Rust playground上查看playground。

我也尝试了不使用显式生命周期，但是我遇到了一个问题，即我不能在Rust中创建引用别名（E0502）。

我知道Rust试图防止数据竞争，但这是否意味着在这些情况下我总是需要创建对象的副本？
以下内容也不起作用，会给我一个错误，即借用的内容无法移动出去（E0507）。

impl Func {
    fn exec(&mut self, val: i32) -> i32 {
        if self.func.is_some() {
            return self.func.unwrap()(self, val);
        };
        0i32
    }
}

但是我找不到克隆封装函数的方法...

- user2525536

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Matthieu M. · Accepted Answer

这里存在一个借用问题：

1.您在不可变地借用self.func 2.您同时尝试可变地借用self

这是不允许的，因为它可能会在使用func时更改它，从而引发麻烦。

您可以尝试更改Callback以仅传递&mut i32，但是然后您将遇到生命周期统一问题：

1. 如果您指定exec采用&'a mut self，则锚定该对象并借用其余寿命， 2. 另一方面，如果您指定新的生命周期，则根据定义，它小于'a，并且您需要在Callback的签名中要求a。

两种情况都不起作用。

因此，解决方案是首先避免寿命。

（对于借用）只需传递对self.val的引用而不是self实例即可更容易地实现。

type Callback = Fn(&mut i32, i32) -> i32;

struct Func {
    val: i32,
    func: Option<Box<Callback>>,
}

impl Func {
    fn exec(&mut self, val: i32) -> i32 {
        if let Some(ref f) = self.func {
            return f(&mut self.val, val);
        };
        0i32
    }
}

fn main() {
    let mut a32 = Func{
        val: 10i32,
        func: Some(Box::new(|s: &mut i32, val: i32| -> i32 {
            let v = *s;
            *s += 1;
            val * 32 + v
        }))
    };
    println!("a32(4) = {}", a32.exec(4i32));
    println!("a32(4) = {}", a32.exec(4i32));
}

如果你想真正掌握Func，你需要进行"选项之舞"：

impl Func {
    fn exec(&mut self, val: i32) -> i32 {
        let func = self.func.take();
        let res = if let Some(ref f) = func {
            f(self, val)
        } else {
            0i32
        };
        self.func = func;
        res
    }
}

请注意，在回调函数中 self.func 是空的。