如何将闭包移至Rust结构体字段？编译生命周期错误求解

问题代码 #

use std::cmp::Ordering;

struct Sortable<T> {
    buffer: Vec<T>,
    compare: Box<dyn Fn(&T, &T) -> Ordering>,
}

impl<T> Sortable<T> {
    fn new(compare_func: impl Fn(&T, &T) -> Ordering) -> Sortable<T> {
        Sortable {
            buffer: Vec::new(),
            compare: Box::new(compare_func),
        }
    }

    fn sort(&mut self) {
        self.buffer.sort_by(&self.compare);
    }
}

编译器错误 #

the parameter type `impl Fn(&T, &T) -> Ordering` may not live long enough

疑问 #

原以为参数compare_func会从调用者移动到new函数，再存入结构体字段（函数声明中没有引用&），但却出现了生命周期相关的错误，请问哪里出错了？有什么解决办法吗？

错误原因 #

问题出在闭包的生命周期约束上：

• 你声明的Box<dyn Fn(&T, &T) -> Ordering>默认等价于Box<dyn Fn(&T, &T) -> Ordering + 'static>，也就是要求闭包必须能存活到整个程序运行周期。
• 而impl Fn(&T, &T) -> Ordering并没有标注生命周期，编译器无法确定传入的闭包是否满足'static要求——如果闭包捕获了外部的非'static变量（比如局部变量的引用），它的生命周期就会被限制在变量的作用域内，无法满足结构体默认的'static约束。
• 即使参数是移动语义，闭包本身可能携带了捕获变量的生命周期依赖，编译器必须确保这些依赖的有效性，所以会抛出生命周期不足的错误。

解决办法 #

根据你的使用场景，可以选择以下几种方案：

1. 要求闭包为'static #

如果你的闭包不需要捕获外部非'static变量（或者捕获的变量本身是'static，比如全局变量），可以显式给闭包加上'static约束：

use std::cmp::Ordering;

struct Sortable<T> {
    buffer: Vec<T>,
    // 显式标注闭包的'static生命周期
    compare: Box<dyn Fn(&T, &T) -> Ordering + 'static>,
}

impl<T> Sortable<T> {
    // 要求传入的闭包满足'static约束
    fn new(compare_func: impl Fn(&T, &T) -> Ordering + 'static) -> Sortable<T> {
        Sortable {
            buffer: Vec::new(),
            compare: Box::new(compare_func),
        }
    }

    fn sort(&mut self) {
        self.buffer.sort_by(&self.compare);
    }
}

2. 给结构体添加生命周期参数绑定闭包 #

如果闭包需要捕获外部有生命周期限制的变量（比如局部变量），可以给结构体添加生命周期参数，将结构体的生命周期与闭包的生命周期绑定，确保结构体不会比闭包捕获的变量活得更久：

use std::cmp::Ordering;

// 添加生命周期'a，绑定闭包的生命周期
struct Sortable<'a, T> {
    buffer: Vec<T>,
    compare: Box<dyn Fn(&T, &T) -> Ordering + 'a>,
}

impl<'a, T> Sortable<'a, T> {
    // 要求传入的闭包生命周期与结构体一致
    fn new(compare_func: impl Fn(&T, &T) -> Ordering + 'a) -> Sortable<'a, T> {
        Sortable {
            buffer: Vec::new(),
            compare: Box::new(compare_func),
        }
    }

    fn sort(&mut self) {
        self.buffer.sort_by(&self.compare);
    }
}

3. 使用函数指针替代闭包 #

如果你的比较逻辑不需要捕获外部变量（只是普通的函数），可以直接使用函数指针类型，这样既没有生命周期问题，性能也更高：

use std::cmp::Ordering;

struct Sortable<T> {
    buffer: Vec<T>,
    compare: fn(&T, &T) -> Ordering,
}

impl<T> Sortable<T> {
    fn new(compare_func: fn(&T, &T) -> Ordering) -> Sortable<T> {
        Sortable {
            buffer: Vec::new(),
            compare: compare_func,
        }
    }

    fn sort(&mut self) {
        // 函数指针可以直接传给sort_by
        self.buffer.sort_by(self.compare);
    }
}

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