Rust如何从函数同时返回所有权实体和借用引用？有哪些可行方案？

你遇到的是Rust安全自引用结构体的规则限制，原代码无法通过编译的原因是：Rust借用检查器默认不允许结构体内部同时存储字段的所有权和指向该字段的引用。一方面你定义的'a生命周期会被判定为指向结构体外部的作用域，而非内部的dst_buffer字段；另一方面你把dst_buffer移动进结构体时，之前基于它生成的dst_buffer_bytes引用会被直接判定为失效。

方案1：延迟生成引用（绝大多数场景最推荐） #

不提前存储引用，只保留dst_buffer的所有权，需要使用字节切片时动态生成即可，方法调用会被编译器自动内联，无实际性能损失。

代码示例 #

use byte_slice_cast::*;

fn main() {
    let context = context_make();
    dbg!(&context);
    // 需要用时调用方法获取切片即可
    dbg!(context.dst_buffer_bytes());
}

fn context_make() -> Context {
    Context::new()
}

#[derive(Debug)]
struct Context {
    pub dst_buffer: Box<[f32]>,
}

impl Context {
    fn new() -> Context {
        let len: usize = 13;
        let dst_buffer: Box<[f32]> = vec![0_f32; len].into_boxed_slice();
        Context {
            dst_buffer,
        }
    }

    // 零成本生成字节切片引用
    pub fn dst_buffer_bytes(&self) -> &[u8] {
        self.dst_buffer.as_byte_slice()
    }
}

优缺点 #

• 优点：零依赖、零unsafe、完全符合Rust借用规则，无额外开销，易用性最高
• 缺点：需要调用方法获取切片，无实质性影响

方案2：使用ouroboros库实现安全自引用 #

ouroboros是工业界广泛使用的自引用结构体专用库，会在编译期生成校验代码，无需手写unsafe即可保证引用有效性。需要先引入依赖ouroboros = "0.18"。

代码示例 #

use byte_slice_cast::*;
use ouroboros::self_referencing;

fn main() {
    let context = context_make();
    dbg!(&context);
    // 通过库生成的方法访问引用
    dbg!(context.borrow_dst_buffer_bytes());
}

fn context_make() -> Context {
    Context::new()
}

#[self_referencing]
#[derive(Debug)]
struct Context {
    pub dst_buffer: Box<[f32]>,
    #[borrows(dst_buffer)]
    #[covariant]
    pub dst_buffer_bytes: &'this [u8],
}

impl Context {
    fn new() -> Context {
        let len: usize = 13;
        let dst_buffer: Box<[f32]> = vec![0_f32; len].into_boxed_slice();
        ContextBuilder {
            dst_buffer,
            dst_buffer_bytes_builder: |buf| buf.as_byte_slice(),
        }.build()
    }
}

优缺点 #

• 优点：无需手写unsafe，引用有效性由库静态保证，适合必须预存引用的场景
• 缺点：需要引入第三方依赖，字段访问需要通过库生成的专用方法

方案3：手动unsafe实现 #

利用Box堆分配地址固定的特性，手动维护引用的有效性，适合极致性能要求的底层场景。

代码示例 #

use byte_slice_cast::*;
use std::slice::from_raw_parts;

fn main() {
    let context = context_make();
    dbg!(&context);
    dbg!(context.dst_buffer_bytes());
}

fn context_make() -> Context {
    Context::new()
}

#[derive(Debug)]
struct Context {
    pub dst_buffer: Box<[f32]>,
    // 安全约定：该切片永远指向dst_buffer的内容，生命周期与Context绑定
    dst_buffer_bytes: &'static [u8],
}

impl Context {
    fn new() -> Context {
        let len: usize = 13;
        let dst_buffer: Box<[f32]> = vec![0_f32; len].into_boxed_slice();
        // 安全保证：dst_buffer是堆分配，移动Context不会改变堆上数据地址，只要Context不被drop、dst_buffer不被替换，该引用就有效
        let dst_buffer_bytes = unsafe { 
            from_raw_parts(
                dst_buffer.as_byte_slice().as_ptr(),
                dst_buffer.as_byte_slice().len()
            )
        };
        Context {
            dst_buffer,
            dst_buffer_bytes,
        }
    }

    // 将'static生命周期降级为和self绑定，避免使用者错误延长引用生命周期
    pub fn dst_buffer_bytes(&self) -> &[u8] {
        self.dst_buffer_bytes
    }
}

优缺点 #

• 优点：零依赖、零运行时开销，性能最高
• 缺点：需要手动维护安全约定，稍有不慎就会产生未定义行为，对开发者的Rust unsafe编码能力要求极高，后期维护成本高

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