在使用作为闭包参数传​​递的引用调用可变方法时，无法推断出适当的生命周期

时间：2017-03-25 02:24:34

标签： rust borrowing

我试图在Rust做一个小游戏。我想使用类似于实体 - 组件 - 系统模式的东西来处理所有游戏对象。

我的一般想法是拥有一个GameLoop结构，其中包含更新和绘制游戏所需的所有数据（屏幕，时间戳，......）。

World结构应该包含所有游戏实体并在dispatch函数中更新它们。它调用所有已注册的回调，这些回调也存储在World结构中（那些是＆＃34;系统＆＃34;）。但是，它们在示例代码中是多余的。

我试图尽可能地分解代码并仅包含相关部分。

use std::marker::PhantomData;

struct Something;

///The "somethings" are things like the display, a timestamp, ...
struct GameLoop {
    sth: Something,
    sth2: Something,
}

///C = Context
///The type that is passed to every entity to give it access to things like the delta time
struct World<C> {
    phantom: PhantomData<C>, //This is here so Rust doesn't complain about the type parameter not being used
}

///The data that is passed to the system functions every frame
struct TickData<'a> {
    delta: u64,
    sth: &'a Something,
    sth2: &'a mut Something,
}

impl GameLoop {
    fn new() -> GameLoop {
        GameLoop {
            sth: Something {},
            sth2: Something {},
        }
    }

    ///One game "tick" - Supposed to do things like calculating delta time, swapping buffers, ...
    ///Those are then passed to the callback
    fn update<F: FnMut(u64, &Something, &mut Something)>(&mut self, f: &mut F) {
        f(0, &self.sth, &mut self.sth2);
    }
}

impl<C> World<C> {
    fn new() -> World<C> {
        World { phantom: PhantomData }
    }

    ///Supposed to update all the game entities
    fn dispatch(&mut self, context: &mut C) {
        //...
    }
}

impl<'a> TickData<'a> {
    fn new<'b>(delta: u64, sth: &'b Something, sth2: &'b mut Something) -> TickData<'b> {
        TickData {
            delta: delta,
            sth: sth,
            sth2: sth2,
        }
    }
}

fn main() {
    let mut game_loop = GameLoop::new();
    let mut world = World::<TickData>::new();

    //The game update function, called once per frame
    let mut update_fnc = |delta: u64, sth: &Something, sth2: &mut Something| {
        let mut tick_data = TickData::new(delta, sth, sth2);

        &world.dispatch(&mut tick_data); //If this line is commented out, it compiles fine

        //...
    };

    loop {
        game_loop.update(&mut update_fnc); //Calculate the delta time, call the specified function and swap buffers
    }
}

借用/生命周期似乎存在问题。编译器就是其他一切，但很详细。

问题似乎是游戏更新功能中的&world.dispatch(&mut tick_data)调用，它应该更新所有游戏实体。如果我对它进行评论，程序就会编译而没有任何错误。

这是编译器告诉我的：

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter 'b in function call due to conflicting requirements
  --> src/main.rs:66:29
   |
66 |         let mut tick_data = TickData::new(delta, sth, sth2);
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the body at 65:77...
  --> src/main.rs:65:78
   |
65 |       let mut update_fnc = |delta: u64, sth: &Something, sth2: &mut Something| {
   |  ______________________________________________________________________________^ starting here...
66 | |         let mut tick_data = TickData::new(delta, sth, sth2);
67 | |
68 | |         &world.dispatch(&mut tick_data); //If this line is commented out, it compiles fine
69 | |
70 | |         //...
71 | |     };
   | |_____^ ...ending here
note: ...so that reference does not outlive borrowed content
  --> src/main.rs:66:55
   |
66 |         let mut tick_data = TickData::new(delta, sth, sth2);
   |                                                       ^^^^
note: but, the lifetime must be valid for the expression at 74:25...
  --> src/main.rs:74:26
   |
74 |         game_loop.update(&mut update_fnc); //Calculate the delta time, call the specified function and swap buffers
   |                          ^^^^^^^^^^^^^^^
note: ...so that reference is valid at the time of borrow
  --> src/main.rs:74:26
   |
74 |         game_loop.update(&mut update_fnc); //Calculate the delta time, call the specified function and swap buffers
   |                          ^^^^^^^^^^^^^^^

我根本无法发现错误的原因。函数以一种程序方式被调用，因为我只是借用了大部分数据，所以生命周期应该没有问题。

当我从TickData结构中删除引用以使其仅包含为Copy特征实现的值时，它也可以正常工作。

我通常不是那种发布代码墙并要求人们解决问题的人，但我现在真的很无能为力。

1 个答案:

答案 0 :(得分：1)

您的代码没有一个正确的解决方案。它看起来过于复杂，我不知道为什么你做了一些你的设计决定。如果我说不适用，那么我道歉，你必须等待下一个回答者。

减少问题是正确的想法，但为什么停止？它可以一直减少到

struct Something;

struct World<'a> {
    x: TickData<'a>,
}

impl<'a> World<'a> {
    fn dispatch(&mut self, context: &TickData<'a>) {}
}

struct TickData<'a>(&'a Something);

fn update_fnc(world: &mut World, sth: &Something) {
    let tick_data = TickData(sth);
    world.dispatch(&tick_data);
}

fn main() {}

通过反复试验，我们可以找到一些＆＃34;解决方案＆＃34;：

impl<'a> World<'a> {
    fn dispatch(&self, context: &TickData<'a>) {}
}

或

impl<'a> World<'a> {
    fn dispatch(&mut self, context: &TickData) {}
}

或

impl<'a> World<'a> {
    fn dispatch<'b>(&'b mut self, context: &'b TickData<'b>) {}
}

对于此问题的极其彻底分析，比我能提供的更好，请查看Why does linking lifetimes matter only with mutable references?。

让我们看看另一个方面，回到你的主要方法：

let mut world = World::<TickData>::new();

我们知道TickData有一个生命周期，所以在这种情况下它是什么？我们不能像类型那样指定它，必须从使用中推断出来。那么它在哪里使用？

要看的一个类比是Vec。我们稍后会在其上创建Vec然后push的内容。那些push告诉我们T的具体类型是什么。你的代码做了什么：

let mut world = World::<TickData>::new();
// ...
world.dispatch(&mut tick_data);

您创建的某个类型包含TickData（PhantomData的内容），然后您调用的方法是＆＃34;推送＆＃34; es那个类型（fn dispatch(&mut self, context: &mut C)），因此第二个参数必须属于包含的类型，解析最终类型。

这导致了另一个问题：不知道这些论点的生命周期有多长。

然而，仅仅注释生命周期是不够的：

fn update<'a, F>(&'a mut self, mut f: F)
    where F: FnMut(u64, &'a Something, &'a mut Something)
{
    f(0, &self.sth, &mut self.sth2);
}

这种进一步的复杂化是因为我们将 mutable 引用sth2传递给dispatch。 dispatch的定义允许存储本身内部的可变引用 - 生命周期和类型匹配，它是&mut self。

这可能导致多个可变别名，这是不允许的。

我不知道为什么您已将World参数化，但您可以将C移至{{1} }}方法，完全删除dispatch。这会删除PhantomData存储World的功能。

相关问题
最新问题