rust - Vec 中的结构可以相互引用吗？

Question

以下代码创建一个玩家列表，然后添加对其他一些玩家的引用作为 friend 。我没法通过借阅检查员。谁能解释我哪里出错了？

fn main() {
    let mut players =
        vec![Player::new("alice"), Player::new("bob"), Player::new("eve"), Player::new("dave")];

    let mut alice = players.get_mut(0).unwrap();
    alice.friends.push(&players[1]);
    alice.friends.push(&players[2]);
    // The list is borrowed by the existence of Alice, how do I
    // put Bob and Eve into Alice's group?

    let game = Game::new(GameType::Checkers,
                         "Game #23",
                         vec![&players[0], &players[1]][..]);
    // the trait bound `[&'a Player<'_>]: std::marker::Sized` is not satisfied
}

对于奖励，我如何平等地让玩家参与游戏？

其余代码如下:

struct Player<'a> {
    name: String,
    friends: Vec<&'a Player<'a>>,
}
impl<'a> Player<'a> {
    fn new(name: &str) -> Player {
        Player {
            name: name.into(),
            friends: Vec::new(),
        }
    }
}

enum GameType {
    Chess,
    Checkers,
    SnakesAndLadders,
}

struct Game<'a> {
    game: GameType,
    name: String,
    players: Vec<&'a Player<'a>>,
}
impl<'a> Game<'a> {
    fn new(game: GameType, name: &str, players: [&'a Player]) -> Game<'a> {
        Game {
            game: game,
            name: name.into(),
            players: players.to_vec(),
        }
    }
}

Answer 1

我假设您已经搜索了错误消息并通读了 10+ questions and answers about it already 中的一些 ，所以我会返回你，不会浪费你的时间。相反，我将继续讨论有关借用检查的问题:

error[E0502]: cannot borrow `players` as immutable because it is also borrowed as mutable
  --> src/main.rs:40:25
   |
39 |     let mut alice = players.get_mut(0).unwrap();
   |                     ------- mutable borrow occurs here
40 |     alice.friends.push(&players[1]);
   |                         ^^^^^^^ immutable borrow occurs here
...
48 | }
   | - mutable borrow ends here

Rust 只允许你拥有 a single mutable reference or one-or-more immutable references to the same value .这段代码已经创建了一个指向 vector 的可变引用，并试图获得第二个不可变引用。

这必须是不允许的，因为据编译器所知，更改可变引用可能会使不可变引用无效。这会导致内存不安全，这是 Rust 所不允许的。

在这种情况下，一旦您创建了 players 向量，就不会再向它添加任何值。 vector 本身是不可变的，但其中的组件希望是可变的。这非常适合 RefCell:

struct Player<'a> {
    name: String,
    friends: RefCell<Vec<&'a Player<'a>>>,
}

现在 Player 可以在包含元素不知道可变性的情况下修改他们的 friend 。

然后只需删除 vector 的可变借用并借用 friends 作为可变借用即可:

let alice = &players[0];
alice.friends.borrow_mut().push(&players[1]);
alice.friends.borrow_mut().push(&players[2]);

您还必须向 Game::new 添加一个缺失的生命周期，然后它会编译:

use std::cell::RefCell;

struct Player<'a> {
    name: String,
    friends: RefCell<Vec<&'a Player<'a>>>,
}

impl<'a> Player<'a> {
    fn new(name: &str) -> Player {
        Player {
            name: name.into(),
            friends: RefCell::new(Vec::new()),
        }
    }
}

struct Game<'a> {
    players: Vec<&'a Player<'a>>,
}

impl<'a> Game<'a> {
    fn new(players: &[&'a Player<'a>]) -> Game<'a> {
        Game { players: players.to_vec() }
    }
}

fn main() {
    let players = vec![
        Player::new("alice"),
        Player::new("bob"),
        Player::new("eve"), 
        Player::new("dave"),
    ];

    let alice = &players[0];
    alice.friends.borrow_mut().push(&players[1]);
    alice.friends.borrow_mut().push(&players[2]);

    Game::new(&[&players[0], &players[1]]);
}

---

您的问题非常接近Why can't I store a value and a reference to that value in the same struct? , 但略有不同。我们鼓励您阅读该内容以获取高度相关的信息。