Rust中需使用可变引用时，如何避免不可变引用冲突？

问题代码 #

struct Deck<'a> {
    cards: Vec<&'a str>
}
impl Deck<'_> {
    fn top_in_deck(&self) -> &str {
        self.cards[0]
    }
    fn remove_top_in_deck_if_is_card(&mut self, card: &str) {
        if self.cards[0] == card {
            self.cards.remove(0);
        }
    }
}

fn main() {
    let mut deck = Deck { cards: vec!["9-H", "K-D"] };
    let top_card = deck.top_in_deck();
    deck.remove_top_in_deck_if_is_card(top_card);
}

编译错误 #

error[E0502]: cannot borrow deck as mutable because it is also borrowed as immutable
--> src/main.rs:18:5
|
17 | let top_card = deck.top_in_deck();
| ------------------ immutable borrow occurs here
18 | deck.remove_top_in_deck_if_is_card(top_card);
| ^^^^^{-----------------------------}^^^^^^^^^
| | |
| | immutable borrow later used by call
| mutable borrow occurs here

For more information about this error, try rustc --explain E0502.

解决方案 #

1. 合并逻辑（推荐）

将“获取顶牌”和“匹配删除”的逻辑合并到同一个方法中，避免跨方法的引用生命周期冲突：

struct Deck<'a> {
    cards: Vec<&'a str>
}
impl Deck<'_> {
    // 直接实现“检查并删除顶牌”的逻辑
    fn remove_top_if_matches(&mut self) {
        if !self.cards.is_empty() {
            self.cards.remove(0);
        }
    }

    // 保留匹配指定牌的版本
    fn remove_top_if_is_card(&mut self, target: &str) {
        if self.cards.first() == Some(&target) {
            self.cards.remove(0);
        }
    }
}

fn main() {
    let mut deck = Deck { cards: vec!["9-H", "K-D"] };
    // 直接调用合并后的方法
    deck.remove_top_if_matches();
    // 或者匹配指定牌
    deck.remove_top_if_is_card("K-D");
}

2. 转换为拥有所有权的字符串

将&str转换为String，断开与原Deck的引用关联，这样不可变引用的生命周期不会覆盖到可变借用的时机：

struct Deck<'a> {
    cards: Vec<&'a str>
}
impl Deck<'_> {
    fn top_in_deck(&self) -> &str {
        self.cards[0]
    }
    fn remove_top_in_deck_if_is_card(&mut self, card: &str) {
        if self.cards[0] == card {
            self.cards.remove(0);
        }
    }
}

fn main() {
    let mut deck = Deck { cards: vec!["9-H", "K-D"] };
    // 将引用转为拥有所有权的String，原Deck的不可变引用立即失效
    let top_card = deck.top_in_deck().to_string();
    deck.remove_top_in_deck_if_is_card(&top_card);
}

3. 使用内部可变性（仅复杂场景）

如果无法合并逻辑或转换所有权，可以用RefCell实现内部可变性，将借用检查推迟到运行时：

use std::cell::RefCell;

struct Deck<'a> {
    cards: RefCell<Vec<&'a str>>
}
impl Deck<'_> {
    fn top_in_deck(&self) -> &str {
        self.cards.borrow()[0]
    }
    fn remove_top_in_deck_if_is_card(&self, card: &str) {
        let mut cards = self.cards.borrow_mut();
        if cards[0] == card {
            cards.remove(0);
        }
    }
}

fn main() {
    let deck = Deck { cards: RefCell::new(vec!["9-H", "K-D"]) };
    let top_card = deck.top_in_deck();
    deck.remove_top_in_deck_if_is_card(top_card);
}

方案选择 #

• 优先选合并逻辑：最符合Rust的设计理念，无额外开销，代码更简洁。
• 转换为String：适合必须分离逻辑的场景，明确断开引用关联，编译期安全。
• 内部可变性：仅作为最后选择，会引入运行时开销和panic风险，只用于无法通过前两种方式解决的复杂场景。

内容的提问来源于stack exchange，提问作者Marc Garcia