Rust中如何标记结构体不可变字段以解决借用检查器冲突？

Rust的借用检查器目前无法识别结构体内部独立字段的借用边界——只要你借用了self的任意部分（哪怕是构造后永不修改的字段），整个self都会被标记为不可变借用，此时再尝试获取&mut self就会触发冲突。针对你的场景，有几种安全且实用的解决方法：

方案1：拆分结构体（推荐，完全安全） #

将不可变字段与可变字段拆分为两个独立的结构体，让可变操作仅针对可变结构体实例，这样不可变字段的引用不会与&mut self产生冲突：

use std::collections::HashMap;

// 存放构造后永不修改的不可变数据
struct ProcessConstData {
    data: HashMap<String, i32>,
}

// 存放可修改的数据
struct Process {
    const_data: ProcessConstData,
    mut_data: i32,
}

impl Process {
    fn do_more(&mut self, num: &i32) {
        self.mut_data += num;
    }

    fn do_something(&mut self, name: &str) {
        let num = self.const_data.data.get(name).unwrap();
        self.do_more(num);
    }
}

fn main() {
    let mut p = Process {
        const_data: ProcessConstData {
            data: HashMap::from([
                ("foo".to_string(), 1),
                ("bar".to_string(), 2),
                ("buzz".to_string(), 3),
            ]),
        },
        mut_data: 0,
    };

    p.do_something("foo");
}

拆分后，&mut self仅借用Process的可变部分，而const_data属于独立结构体，两者指向不同内存区域，借用检查器会认可这种无冲突的操作。

方案2：用Arc共享不可变数据 #

如果需要在多个上下文共享这份不可变数据，可以用Arc包裹不可变字段。Arc::clone是轻量操作（仅增加引用计数，不复制底层数据），克隆后得到的独立引用不会与&mut self冲突：

use std::collections::HashMap;
use std::sync::Arc;

struct Process {
    const_data: Arc<HashMap<String, i32>>,
    mut_data: i32,
}

impl Process {
    fn do_more(&mut self, num: &i32) {
        self.mut_data += num;
    }

    fn do_something(&mut self, name: &str) {
        let const_data = Arc::clone(&self.const_data);
        let num = const_data.get(name).unwrap();
        self.do_more(num);
    }
}

fn main() {
    let mut p = Process {
        const_data: Arc::new(HashMap::from([
            ("foo".to_string(), 1),
            ("bar".to_string(), 2),
            ("buzz".to_string(), 3),
        ])),
        mut_data: 0,
    };

    p.do_something("foo");
}

方案3：使用unsafe（不推荐） #

如果能绝对保证const_data在生命周期内永不修改，可以通过unsafe绕过借用检查器，但这会丢弃Rust的内存安全保障，仅在极端场景下考虑：

use std::collections::HashMap;

struct Process {
    const_data: HashMap<String, i32>,
    mut_data: i32,
}

impl Process {
    fn do_more(&mut self, num: &i32) {
        self.mut_data += num;
    }

    fn do_something(&mut self, name: &str) {
        // 获取不可变字段的原始指针
        let const_data_ptr: *const HashMap<String, i32> = &self.const_data;
        // unsafe操作：将指针转为不可变引用
        let num = unsafe { (*const_data_ptr).get(name).unwrap() };
        self.do_more(num);
    }
}

fn main() {
    let mut p = Process {
        const_data: HashMap::from([
            ("foo".to_string(), 1),
            ("bar".to_string(), 2),
            ("buzz".to_string(), 3),
        ]),
        mut_data: 0,
    };

    p.do_something("foo");
}

⚠️ 警告：一旦const_data被意外修改，此代码会触发未定义行为，务必谨慎使用。

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