如何在Rust结构体中存储可修改其内部状态的回调函数？

你遇到的核心问题是：do_stuff是带&mut self的实例方法，其实际签名为fn(&mut MainStruct, i32) -> i32，而你定义的fn(i32) -> i32是无环境的普通函数指针，无法容纳self的引用。同时，Rust的借用检查器会阻止结构体存储指向自身的可变引用（自引用结构体），这也是你尝试直接存储方法指针失败的原因。

针对你的场景（回调由主结构体持有，需修改主结构体状态），以下两种安全实现方式最常用：

方案一：闭包+内部可变性（推荐，更符合Rust风格） #

通过Rc<RefCell<MainStruct>>将主结构体包装为可共享、内部可变的类型，让闭包捕获这个包装实例，从而安全地修改主结构体状态：

use std::cell::RefCell;
use std::rc::Rc;

struct CallbackStruct {
    callback: Box<dyn FnMut(i32) -> i32>,
}

struct MainStruct {
    pub callback_struct: Vec<CallbackStruct>,
    pub intern_state: i32,
}

impl MainStruct {
    pub fn new() -> Rc<RefCell<Self>> {
        // 创建自引用的Rc，确保闭包能捕获到自身实例
        let self_rc = Rc::new_cyclic(|_| {
            RefCell::new(MainStruct {
                callback_struct: Vec::new(),
                intern_state: 0,
            })
        });

        // 克隆Rc供闭包捕获
        let callback_self = self_rc.clone();
        let callback = Box::new(move |i: i32| -> i32 {
            let mut self_ref = callback_self.borrow_mut();
            self_ref.intern_state = i * 2 + 1;
            self_ref.intern_state
        });

        self_rc.borrow_mut().callback_struct.push(CallbackStruct { callback });
        self_rc
    }

    pub fn do_stuff(&mut self, i: i32) -> i32 {
        self.intern_state = i * 2 + 1;
        self.intern_state
    }
}

fn main() {
    let my_struct = MainStruct::new();
    // 测试回调功能
    if let Some(callback) = my_struct.borrow_mut().callback_struct.first_mut() {
        let res = (callback.callback)(5);
        assert_eq!(res, 11);
        assert_eq!(my_struct.borrow().intern_state, 11);
    }
}

这个方案完全安全：Rc保证实例的生命周期足够长，RefCell通过运行时检查确保可变引用的唯一性，闭包捕获的Rc克隆也不会导致生命周期问题。

方案二：显式传递self的函数指针（接近C/C++风格） #

如果你更习惯C/C++的函数指针模式，可以调整回调签名，将&mut self作为显式参数传递：

struct CallbackStruct {
    // 回调签名包含MainStruct的可变引用
    callback: fn(&mut MainStruct, i32) -> i32,
}

struct MainStruct {
    pub callback_struct: Vec<CallbackStruct>,
    pub intern_state: i32,
}

impl MainStruct {
    pub fn new() -> MainStruct {
        let mut result = MainStruct {
            callback_struct: Vec::new(),
            intern_state: 0,
        };
        // 实例方法可直接转换为对应函数指针
        result.callback_struct.push(CallbackStruct {
            callback: MainStruct::do_stuff,
        });
        result
    }

    pub fn do_stuff(&mut self, i: i32) -> i32 {
        self.intern_state = i * 2 + 1;
        self.intern_state
    }
}

fn main() {
    let mut my_struct = MainStruct::new();
    // 调用时显式传递self的可变引用
    if let Some(callback) = my_struct.callback_struct.first() {
        let res = (callback.callback)(&mut my_struct, 5);
        assert_eq!(res, 11);
        assert_eq!(my_struct.intern_state, 11);
    }
}

这种方式无需闭包，完全依赖Rust的编译期借用检查，调用回调时必须显式传递&mut self，确保借用安全。

你担心的"&mut self回调导致借用冲突"确实存在，但上述方案都做了针对性处理：

• 方案一通过RefCell将编译期借用检查转移到运行时，允许逻辑上的多个可变引用，同时保证运行时的唯一性。
• 方案二通过显式传递&mut self，让借用检查器在编译期确保每次调用回调时没有其他可变引用存在。

由于你的回调完全由主结构体持有，只要遵循上述方案的规则，就不会出现生命周期问题——回调的生命周期永远不会超过主结构体的生命周期。

内容的提问来源于stack exchange，提问作者LucioleMaléfique