Rust非泛型结构体如何封装外部函数指针实现自定义行为？

问题本质 #

你尝试用函数指针封装行为时遭遇编译失败，核心原因是：捕获了外部变量的闭包无法强制转换为无状态的fn(...)函数指针——这类闭包带有捕获的环境（比如你代码里的num_gen或泛型类型T的信息），而函数指针只能指向无状态的纯函数。同时你的核心需求是非泛型结构体，要能把不同行为的实例存入同一个Vec，泛型结构体无法满足（不同泛型参数对应完全不同的类型，不能共存于同一集合）。

解决方案：用Trait对象实现动态分发 #

我们可以定义一个描述行为的trait，然后在结构体中存储该trait的动态对象（Box<dyn Trait>），既能隐藏内部具体类型，又能让不同行为的实例共存于同一集合。

针对第一个示例的修正 #

// 定义描述行为的trait
trait Behaviour {
    fn call(&self, num: u8);
}

// 封装闭包的适配器结构体，实现Behaviour trait
struct BehaviourAdapter<F>(F)
where
    F: Fn(u8);

impl<F> Behaviour for BehaviourAdapter<F>
where
    F: Fn(u8),
{
    fn call(&self, num: u8) {
        (self.0)(num);
    }
}

struct A {
    // 存储动态trait对象，替代原有的函数指针
    behaviour: Box<dyn Behaviour>,
}

impl A {
    pub fn new(num_gen: fn(u8) -> u8) -> A {
        // 创建捕获num_gen的闭包，用适配器封装后转为trait对象
        let behaviour = move |num: u8| {
            let num = num_gen(num);
            println!("number: {num}");
        };
        A {
            behaviour: Box::new(BehaviourAdapter(behaviour)),
        }
    }

    pub fn call(&self, num: u8) {
        self.behaviour.call(num);
    }
}

fn main() {
    let a = A::new(|x: u8| x + 1);
    a.call(1); // 输出: number: 2

    // 可以创建不同行为的实例并存入同一个Vec
    let b = A::new(|x: u8| x * 2);
    let mut vec = Vec::new();
    vec.push(a);
    vec.push(b);

    for item in vec {
        item.call(3);
    }
    // 输出:
    // number: 4
    // number: 6
}

针对第二个示例的修正（支持泛型类型处理） #

这个示例需要捕获泛型类型T的信息，同样可以用trait对象解决：

trait Behaviour {
    fn call(&self, num: u8);
}

struct BehaviourAdapter<F>(F)
where
    F: Fn(u8);

impl<F> Behaviour for BehaviourAdapter<F>
where
    F: Fn(u8),
{
    fn call(&self, num: u8) {
        (self.0)(num);
    }
}

struct A {
    behaviour: Box<dyn Behaviour>,
}

impl A {
    pub fn new<T>(obj_gen: fn(u8) -> T) -> A
    where
        T: core::fmt::Display + 'static,
    {
        let behaviour = move |num: u8| {
            let obj = obj_gen(num);
            println!("size: {}, obj: {obj}", std::mem::size_of::<T>());
        };
        A {
            behaviour: Box::new(BehaviourAdapter(behaviour)),
        }
    }

    pub fn call(&self, num: u8) {
        self.behaviour.call(num);
    }
}

fn main() {
    let a = A::new(|x: u8| x + 1);
    a.call(1); // 输出: size: 1, obj: 2

    let c = A::new(|x: u8| x.to_string());
    let mut vec = Vec::new();
    vec.push(a);
    vec.push(c);

    for item in vec {
        item.call(5);
    }
    // 输出:
    // size: 1, obj: 6
    // size: 24, obj: 5
}

关键细节说明 #

1. Trait对象的核心作用：Box<dyn Behaviour>是动态大小类型，允许我们存储任何实现了Behaviour trait的类型，不管其具体类型是什么，完美解决了非泛型结构体存储不同行为实例的需求。
2. 闭包捕获环境的处理：通过BehaviourAdapter封装闭包，把带状态的闭包转为实现了trait的类型，再装箱为trait对象，避开了函数指针无法携带状态的限制。
3. 'static生命周期约束：这里使用'static是因为我们的实例通常会存活到程序结束；如果需要更灵活的生命周期，可以调整为带生命周期参数的trait，但会增加代码复杂度。

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