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

Question

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

我的总体想法是拥有一个 GameLoop 结构，它包含更新和绘制游戏所需的所有数据(屏幕、时间戳...)。

World 结构应该包含所有游戏实体并在 dispatch 函数中更新它们。它还调用存储在 World 结构中的所有已注册回调(这些是“系统”)。不过，它们在示例代码中是多余的。

我尽量分解代码，只包含相关部分。

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 特性实现的值，它也能正常工作。

我通常不是那种张贴代码墙并要求人们修复它的人，但我现在真的一无所知。

Answer 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() {}

通过反复试验，可以找到一些“解决方案”:

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? .

---

让我们看另一个方面，回到您的 main 方法:

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

我们知道 TickData 里面有一个生命周期，那么在这个例子中它是什么呢？我们不能像类型一样指定它，它必须从用法中推断出来。那么它用在什么地方呢？

一个类比是 Vec。我们创建一个 Vec ，然后 push 东西到它上面。那些 pushes 告诉我们 T 的具体类型是什么。你的代码做什么:

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

您创建了一个您所说的包含 TickData 的类型(这就是 PhantomData 所做的)，然后调用一个“推送”该类型的方法 (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);
}

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

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

我不知道为什么你已经参数化了你的World，但你可以将C移动到dispatch 方法，完全移除 PhantomData。这消除了 World 存储 C 的能力。