如何让Rust库用户配置内部静态数组（堆）的大小？

我正在开发一个使用embedded-alloc的Rust库，希望库的使用者能够根据其平台配置作为堆的静态数组的大小。

尝试的代码如下：

库代码 #

#![no_std]
#![no_main]
extern crate alloc;

use cortex_m_rt::entry;
use embedded_alloc::LlffHeap as Heap;

#[global_allocator]
static HEAP: Heap = Heap::empty();

fn init<const N: usize>() {
     use core::mem::MaybeUninit;
     const HEAP_SIZE: usize = N;
     static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
     unsafe { HEAP.init(HEAP_MEM.as_ptr() as usize, HEAP_SIZE) }
}

用户代码 #

// 用户代码
fn main() {
    init::<1024>();
}

报错信息 #

error[E0401]: 无法使用外部项的泛型参数
 --> src/main.rs:2:31
  |
1 | fn init<const N: usize>() {
  |               - 来自外部项的const参数
2 |     const HEAP_SIZE: usize = N;
  |                               ^ 使用了外部项的泛型参数

如需了解该错误的更多信息，请尝试 `rustc --explain E0401`。
error: 无法编译 `rust_const_generic`（二进制文件 "rust_const_generic"），原因是之前的错误

请问是否有办法让我的crate用户配置内部静态数组的大小？

解决方案 #

方法1：让用户提供静态数组并传入初始化函数 #

把堆内存的定义交给用户，库仅负责初始化全局分配器，用户可自由指定数组大小：

库代码

#![no_std]
extern crate alloc;

use embedded_alloc::LlffHeap as Heap;
use core::mem::MaybeUninit;

#[global_allocator]
pub static HEAP: Heap = Heap::empty();

/// 初始化堆，需要用户传入预定义的静态内存区域
pub unsafe fn init_heap(heap_mem: &'static mut [MaybeUninit<u8>]) {
    HEAP.init(heap_mem.as_ptr() as usize, heap_mem.len());
}

用户代码

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use your_crate_name::{HEAP, init_heap};
use core::mem::MaybeUninit;

// 用户自定义堆大小
const HEAP_SIZE: usize = 1024;
static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];

#[entry]
fn main() -> ! {
    unsafe {
        init_heap(&mut HEAP_MEM);
    }

    // 后续使用alloc功能
    let _vec = alloc::vec![1, 2, 3];
    
    loop {}
}

方法2：使用特征（Trait）和关联常量 #

通过定义特征让用户实现并指定堆大小，库利用关联常量初始化堆：

库代码

#![no_std]
extern crate alloc;

use embedded_alloc::LlffHeap as Heap;
use core::mem::MaybeUninit;

#[global_allocator]
static HEAP: Heap = Heap::empty();

pub trait HeapConfig {
    const SIZE: usize;
}

pub fn init_heap<C: HeapConfig>() {
    static mut HEAP_MEM: [MaybeUninit<u8>; C::SIZE] = [MaybeUninit::uninit(); C::SIZE];
    unsafe {
        HEAP.init(HEAP_MEM.as_ptr() as usize, C::SIZE);
    }
}

用户代码

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use your_crate_name::{HeapConfig, init_heap};

// 用户实现特征指定堆大小
struct MyHeapConfig;
impl HeapConfig for MyHeapConfig {
    const SIZE: usize = 1024;
}

#[entry]
fn main() -> ! {
    init_heap::<MyHeapConfig>();

    // 使用alloc
    let _vec = alloc::vec![4, 5, 6];
    
    loop {}
}

方法3：使用编译时环境变量 #

通过编译参数让用户指定堆大小，适合需要构建脚本或批量配置的场景：

库代码

#![no_std]
extern crate alloc;

use embedded_alloc::LlffHeap as Heap;
use core::mem::MaybeUninit;

#[global_allocator]
static HEAP: Heap = Heap::empty();

// 从编译环境变量获取堆大小，默认1024
const HEAP_SIZE: usize = env!("HEAP_SIZE").parse().unwrap_or(1024);
static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];

pub fn init_heap() {
    unsafe {
        HEAP.init(HEAP_MEM.as_ptr() as usize, HEAP_SIZE);
    }
}

用户编译命令

HEAP_SIZE=2048 cargo build

用户代码

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use your_crate_name::init_heap;

#[entry]
fn main() -> ! {
    init_heap();

    // 使用alloc
    let _vec = alloc::vec![7, 8, 9];
    
    loop {}
}

错误原因说明 #

原代码报错是因为静态变量的大小必须是编译期确定的全局常量，而函数的const泛型参数N属于函数作用域的参数，无法用于初始化静态数组——静态变量的生命周期覆盖整个程序，不能依赖函数调用时传入的参数。

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