Rust中持有可变函数的Vector实现问题问询

看起来你在Rust里搞函数存储的时候遇到了两个典型问题：一是没法执行Vector里的函数，二是重复加同一个函数时触发可变引用冲突。我来给你拆解一下解决方案，都是实践里常用的路子。

首先说最简单的场景——如果你的函数是普通的全局函数（没有捕获外部变量），那直接存函数指针就完事了，完全没冲突：

// 一个修改外部状态的普通函数
fn update_counter(state: &mut u32) {
    *state += 5;
}

fn main() {
    // 定义存储函数指针的Vector，类型是fn(&mut u32)
    let mut func_list: Vec<fn(&mut u32)> = Vec::new();
    
    // 同一个函数可以随便加多少次，因为fn类型是Copy的
    func_list.push(update_counter);
    func_list.push(update_counter);
    func_list.push(update_counter);

    let mut counter = 0;
    // 遍历执行每个函数，直接调用就行，不用额外解引用
    for func in &func_list {
        func(&mut counter);
    }

    println!("最终计数: {}", counter); // 输出15，正确
}

这种情况下根本不会有引用冲突，因为函数指针是值类型，复制多少次都没问题。

但如果你的函数是捕获外部状态的闭包，那麻烦就来了——Rust的借用规则会阻止你把捕获了&mut T的闭包多次加入Vector，因为可变引用是独占的，复制闭包等于复制可变引用，这直接违反规则。

这时候就得用内部可变性来绕开编译期的借用检查，单线程下用RefCell，多线程用Mutex。核心思路是把可变状态包装成可以通过共享引用修改的类型，让闭包捕获共享引用而非可变引用，这样闭包就能实现Copy，随便加多少次都没问题：

use std::cell::RefCell;

fn main() {
    // 用RefCell包装需要修改的状态，实现内部可变性
    let counter = RefCell::new(0);

    // 定义闭包，捕获counter的共享引用(&RefCell<u32>)
    let increment = || {
        // 运行期获取可变引用，这里如果有并发冲突会panic（单线程下不会）
        let mut cnt = counter.borrow_mut();
        *cnt += 1;
    };

    // 存储闭包的Vector，要求闭包实现Fn()和Copy
    let mut func_list: Vec<impl Fn() + Copy> = Vec::new();
    
    // 现在可以随便加同一个闭包了
    func_list.push(increment);
    func_list.push(increment);
    func_list.push(increment);

    // 遍历执行每个闭包，直接调用即可
    for func in &func_list {
        func();
    }

    println!("最终计数: {}", counter.borrow()); // 输出3，正确
}

这里解释下为什么能行：闭包捕获的是&RefCell<u32>，这是共享引用，满足Copy trait，所以可以多次添加到Vector里。而RefCell会在运行期检查可变借用的规则，确保同一时间只有一个可变引用存在，单线程下完全安全。

关于你提到的“无法解引用执行Vector中的函数”：其实Rust会自动处理函数指针和闭包的解引用，不管你存的是fn类型还是闭包，直接调用func(args)就行，不需要手动写(*func)(args)（当然写了也没问题，Rust会接受）。

最后再给个混合场景的例子，既有普通函数又有闭包：

use std::cell::RefCell;

fn multiply_by_two(state: &mut u32) {
    *state *= 2;
}

fn main() {
    let counter = RefCell::new(1);

    let add_three = || {
        let mut cnt = counter.borrow_mut();
        *cnt += 3;
    };

    let mut func_list: Vec<Box<dyn Fn()>> = Vec::new();
    // 添加闭包多次
    func_list.push(Box::new(add_three));
    func_list.push(Box::new(add_three));
    // 添加普通函数，包装成闭包
    func_list.push(Box::new(|| multiply_by_two(&mut counter.borrow_mut())));

    for func in &func_list {
        func();
    }

    println!("最终计数: {}", counter.borrow()); // 计算过程：1+3=4 → 4+3=7 →7*2=14，输出14
}

核心就是根据你的函数类型选择合适的存储方式：普通函数用fn指针，捕获状态的闭包用内部可变性+共享引用，这样就能同时满足“遍历执行”和“重复添加同一个函数”的需求了。

内容的提问来源于stack exchange，提问作者Jakub M.