Rust泛型T能否永久堆分配？泛型Test<T:Deref>实现问询

能否让Rust中的泛型类型T始终在堆上分配？

以下是针对String类型实现的Test结构体代码：

use std::ops::Deref;

struct Test {
    last: &'static str,
    list: Vec<String>,
}

// This is safe because we own the value and will not modify it.
// When dropping, `last` will be dropped without freeing the memory.
impl Test {
    pub fn new(value: String) -> Self {
        Self {
            last: unsafe { std::mem::transmute(value.deref()) },
            list: vec![value],
        }
    }
    pub fn insert(&mut self, value: String) {
        self.last = unsafe { std::mem::transmute(value.deref()) };
        self.list.push(value);
    }
    pub fn last(&self) -> &str {
        self.last
    }
}

能否将其改写为类似Test<T:Deref>的泛型构造？我不确定deref()在我的实现语境下是否能保证“永久”堆地址，或者说它是否具备这样的特性？

上述代码看似安全，因为对String调用deref()会得到指向堆的宽指针，该地址除非字符串本身被修改或所有权返回给调用者，否则不会改变。

注意：我的使用场景需要存储&str，而非使用通过ManuallyDrop::new(unsafe { ptr::read(&value) })创建的ManuallyDrop<String>。

一、让泛型T始终在堆上分配的方法 #

要确保泛型类型T始终在堆上分配，可通过以下方式实现：

• 最直接的方式是让Test内部存储Vec<Box<T>>，无论T是什么类型，Box<T>都会将其装箱到堆上，从根源保证堆分配特性。
• 若只针对实现Deref的类型（如字符串类），可约束T为堆分配的具体类型（如String、Cow<'_, str>的Owned变体），但这种方式灵活性较低，不如Box<T>通用。

二、泛型改写的可行性与风险 #

1. 泛型版本的初步实现 #

可以改写为泛型结构，但需注意deref()返回指针的稳定性问题，初步实现如下：

use std::ops::Deref;

struct Test<T>
where
    T: Deref<Target = str>,
{
    last: &'static str,
    list: Vec<T>,
}

impl<T> Test<T>
where
    T: Deref<Target = str>,
{
    pub fn new(value: T) -> Self {
        let ptr = value.deref() as *const str;
        let last = unsafe { std::mem::transmute(ptr) };
        Self {
            last,
            list: vec![value],
        }
    }

    pub fn insert(&mut self, value: T) {
        let ptr = value.deref() as *const str;
        self.last = unsafe { std::mem::transmute(ptr) };
        self.list.push(value);
    }

    pub fn last(&self) -> &str {
        self.last
    }
}

2. 核心问题：deref()地址的“永久性”无法泛型保证 #

原代码中String的deref()地址稳定，是因为String的堆内存分配后，只要不执行修改长度的操作（如push、reserve），地址就不会变化，且存入Vec后不会被修改。但泛型场景下，T可能是其他实现Deref<Target=str>的类型：

• 如果T是&str，其指向的内存可能是静态字符串或临时栈内存，存入Vec后原内存可能被释放，导致last成为悬垂指针。
• 如果T是Cow<'_, str>的Borrowed变体，同样存在悬垂风险；即使是Owned变体，也可能因后续修改切换变体导致地址变化。
• 自定义类型的deref()若返回栈内数据指针，直接transmute为&'static str会触发未定义行为。

Rust的类型系统无法直接约束T满足“deref返回地址永久有效”，只能靠开发者自行保证，这会带来极高的安全风险。

3. 更安全的替代方案 #

若必须存储&str且要泛型化，建议放弃&'static str，改用*const str存储指针，在last()方法中转换为绑定到self生命周期的&str：

use std::ops::Deref;

struct Test<T>
where
    T: Deref<Target = str>,
{
    last: *const str,
    list: Vec<T>,
}

impl<T> Test<T>
where
    T: Deref<Target = str>,
{
    pub fn new(value: T) -> Self {
        let last = value.deref() as *const str;
        Self {
            last,
            list: vec![value],
        }
    }

    pub fn insert(&mut self, value: T) {
        self.last = value.deref() as *const str;
        self.list.push(value);
    }

    pub fn last(&self) -> &str {
        // 安全：list中的T在self存活期间始终有效，且T的deref目标内存稳定
        unsafe { &*self.last }
    }
}

这个版本避免了transmute到&'static str的风险，last()返回的&str生命周期与&self绑定，只要T的deref()返回的指针在T存活期间有效，就能保证安全。

总结 #

• 强制泛型T堆分配：优先使用Vec<Box<T>>，通用且能保证所有T都在堆上分配；也可针对特定场景约束T为堆分配类型。
• 泛型改写可行，但原代码的&'static str转换存在极高风险，泛型场景下无法保证所有T的deref()地址稳定，建议改用*const str结合生命周期绑定的方案实现更安全的版本。

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