Rust 自引用结构（Self-Referential Structure）

概述

自引用结构 是指结构体中的某个字段（通常是指针或引用）指向同一个结构体中的另一个字段。

这种设计常见于需要内部持有自身成员地址的场景，例如异步任务（Future）捕获局部变量的引用，或实现高效的迭代器。

rust 复制代码

struct SelfRef {
    data: String,           // 被引用的数据
    ptr: *const String,     // 指向 data 的裸指针
}

在这里，ptr 指向 data。

如果结构体被移动（例如赋值给另一个变量），data 的内存地址会改变，但 ptr 仍指向旧地址，导致悬垂指针。

自引用结构的危险：移动即失效

Rust 默认允许移动（move）任何类型。当自引用结构被移动时：

整个结构体的内存会被复制到新位置。
内部指针（或引用）仍指向旧地址，而旧地址的数据已无效。

错误示例

rust 复制代码

struct SelfRef {
    data: String,
    ptr: *const String,
}

fn main() {
    let mut x = SelfRef {
        data: String::from("hello"),
        ptr: std::ptr::null(),
    };
    x.ptr = &x.data as *const String; // ptr 指向 x.data

    let y = x; // 移动 x 到 y
    // 此时 y.ptr 仍然指向 x.data 的旧地址，但 x.data 已随 x 失效！
    // 访问 y.ptr 将导致未定义行为。
}

为什么 Rust 不禁止这种写法？

因为裸指针 *const String 没有生命周期约束，Rust 无法静态检查它的有效性。

如果使用引用 &String，编译器会拒绝，因为引用必须始终有效，而移动会使引用失效。

真实世界中的自引用结构

异步 Future：

async 块内部可能会借用局部变量，生成的 Future 会持有对这些变量的引用。

如果该 Future 被移动，这些引用就会失效。（这就是为什么 std::future::Future 要求 Pin 才能安全轮询。）

生成器（Generator）：

Rust 的生成器（用于实现迭代器）同样会捕获局部变量的引用，形成自引用状态。

操作系统数据结构： 例如链表节点中的 next 指针指向自身节点（环状结构）。

如何安全处理自引用结构？

Rust 提供了 Pin 和 Unpin 机制来确保对象不会被意外移动：

Pin<P> 包装一个指针，阻止其指向的值被移动。
只有实现了 Unpin 的类型才能安全地从 Pin 中移出；自引用结构通常实现 !Unpin。

PhantomPinned 例子

rust 复制代码

use std::marker::PhantomPinned;
use std::pin::Pin;

struct SelfRef {
    data: String,
    ptr: *const String,
    _pin: PhantomPinned, // 表示该类型不能被安全移动
}

impl SelfRef {
    fn new(data: String) -> Self {
        Self { data, ptr: std::ptr::null(), _pin: PhantomPinned }
    }

    fn init(self: Pin<&mut Self>) {
        let this = unsafe { self.get_unchecked_mut() };
        this.ptr = &this.data as *const String;
    }
}

fn main() {
    let mut x = SelfRef::new("hello".to_string());
    let mut pinned = unsafe { Pin::new_unchecked(&mut x) };
    pinned.as_mut().init();
    // 现在 x 被固定，不能移动，ptr 始终有效。
}