学习笔记 20240809 Rust语言-结构体自引用以及解决方法

20240809

结构体自引用

可能也有不少人第一次听说自引用结构体，那咱们先来看看它们长啥样。

struct SelfRef<'a> {
    value: String,

    // 该引用指向上面的value
    pointer_to_value: &'a str,
}

fn main(){
    let s = "aaa".to_string();
    let v = SelfRef {
        value: s,//s的所有权被转移给value
        pointer_to_value: &v.value[..]
        //这里不能写pointer_to_value: &s[..],因为s的所有权转移给了value，这时不能再借用s了
    };
}

运行后报错：

error[E0425]: cannot find value `v` in this scope
  --> src/main.rs:12:28
   |
12 |         pointer_to_value: &v.value[..]

在 main 函数中，尝试创建 SelfRef 实例时，&v.value[…] 试图引用 v 的 value 字段，但是此时 v 还没有被完全构造出来，因此这个引用是无效的。这就是一种结构体自引用的问题。

为了修复这些问题，你可以修改 SelfRef 结构体，使其不包含对自身的引用，或者重新设计代码逻辑，以避免这种自引用的情况。

下面是一个简单的修改示例，移除了自引用：

#[allow(unused)]
struct SelfRef<'a> {
    value: String,
    pointer_to_value: &'a str,
}
#[allow(unused)]
fn main() {
    let s = "aaa";//将s改为&str类型
    let v = SelfRef {
        value: s.to_string(),
        pointer_to_value: s, //s是&str类型，因此可以直接借用
    };
}

如果不能更改s是String类型的前提呢，可以使用Option解决。

使用 Option

最简单的方式就是使用 Option 分两步来实现：

#[derive(Debug)]
struct WhatAboutThis<'a> {
    name: String,
    nickname: Option<&'a str>,
}

fn main() {
    let mut tricky = WhatAboutThis {
        name: "Annabelle".to_string(),
        nickname: None,
    };
    tricky.nickname = Some(&tricky.name[..4]);

    println!("{:?}", tricky);
}

WhatAboutThis { name: "Annabelle", nickname: Some("Anna") }

在某种程度上来说，Option 这个方法可以工作，但是这个方法的限制较多，例如从一个函数创建并返回它是不可能的：

fn creator<'a>() -> WhatAboutThis<'a> {
    let mut tricky = WhatAboutThis {
        name: "Annabelle".to_string(),
        nickname: None,
    };
    tricky.nickname = Some(&tricky.name[..4]);

    tricky
}

报错如下：

error[E0515]: cannot return value referencing local data `tricky.name`
  --> src/main.rs:24:5
   |
22 |     tricky.nickname = Some(&tricky.name[..4]);
   |                             ----------- `tricky.name` is borrowed here
23 |
24 |     tricky
   |     ^^^^^^ returns a value referencing data owned by the current function

这段代码中存在一个生命周期问题，导致编译失败。问题在于 tricky.nickname 试图存储一个对 tricky.name 的引用，但是 tricky 是一个局部变量，其生命周期不会超过 creator 函数的作用域。因此，返回 tricky 作为 WhatAboutThis<'a> 实例时，nickname 中的引用将指向一个已经无效的值。这是一种结构体自引用与函数生命周期结合所产生的问题。

要解决这个问题，你需要确保 WhatAboutThis 实例中的所有数据都拥有足够的生命周期，以便它们可以安全地存在到 creator 函数返回之后。由于 nickname 字段是一个对 name 字段的引用，你需要以一种方式构造 WhatAboutThis，使得 nickname 的引用在 name 的整个生命周期内都是有效的。

一种方法是将 nickname 存储为 String 的值，而不是对 name 的引用。这样，你就可以避免生命周期问题，因为 nickname 将拥有自己的数据副本。这里遇到的问题和解决方法很像之前学过的悬垂引用以及解决方法，详情看这里"悬垂引用"。

下面是如何修改代码的示例：

struct WhatAboutThis<> {
    name: String,
    nickname: String, // 不再是引用，而是拥有自己的数据
}
#[allow(unused)]
fn creator<'a>() -> WhatAboutThis<> {
    let name = "Annabelle".to_string();
    let nickname = name[..4].to_string(); // 创建 nickname 的数据副本

    WhatAboutThis {
        name,
        nickname,
    }
}

在这个版本中，nickname 是 name 前四个字符的副本，存储为 String,并不是一个指向原来数据的String类型，新数据与原数据不在一个位置。详情见"3.切片"。这样，WhatAboutThis 实例就可以安全地返回，因为 nickname 不再依赖于任何局部变量的生命周期。

如果你确实需要 nickname 是一个引用而不是一个值，那么你需要重新考虑你的设计，可能需要使用生命周期注解来确保 nickname 的引用在 WhatAboutThis 实例的生命周期内有效。但是，这通常涉及到更复杂的生命周期管理，并且可能需要对数据结构或函数签名进行调整。

如果是通过方法使用,你需要一个无用 &'a self 生命周期标识，一旦有了这个标识，代码将变得更加受限，你将很容易就获得借用错误，就连 NLL 规则都没用.参考如下：

#[derive(Debug)]
struct WhatAboutThis<'a> {
    name: String,
    nickname: Option<&'a str>,
}

impl<'a> WhatAboutThis<'a> {
    fn tie_the_knot(&'a mut self) {
       self.nickname = Some(&self.name[..4]);
    }
}

fn main() {
    let mut tricky = WhatAboutThis {
        name: "Annabelle".to_string(),
        nickname: None,
    };
    tricky.tie_the_knot();

    // cannot borrow `tricky` as immutable because it is also borrowed as mutable
    // println!("{:?}", tricky);
}

既然借用规则妨碍了我们，那就一脚踢开,了解unsafe。

unsafe 实现

看代码之前补充一些知识：

• *const String 是 Rust 中的一种原始指针类型，表示对 String 类型的不可变引用的裸指针。在 Rust 中，指针分为两种：可变指针（*mut T）和不可变指针（*const T）。*const T 表示指针指向的数据不能通过这个指针来修改，但可以读取。
• 在 Rust 中，裸指针（raw pointer）不会自动进行空值检查或生命周期管理，因此使用它们需要特别小心。通常，Rust 推荐使用智能指针（如 Box, Rc, Arc 等）来管理内存，因为它们会自动处理所有权和生命周期问题。
• 解引用裸指针需要在 unsafe 代码块中进行，因为 Rust 的安全保证不适用于裸指针操作。
• 裸指针不包含有关其指向数据的生命周期信息。因此，使用裸指针时，程序员需要手动确保指针指向的数据在指针的整个使用期间保持有效。

以下是一个示例代码，演示了如何获取 String 类型实例的内存地址以及它指向的堆内存地址：

String 类型是一个复杂类型，由存储在栈中的堆指针、字符串长度、字符串容量共同组成，其中堆指针是最重要的，它指向了真实存储字符串内容的堆内存。

fn main() {
    let s = String::from("Hello, world!");

    // 获取 String 实例本身的内存地址
    let s_ptr: *const String = &s;

    // 获取 String 指向的堆内存地址
    let heap_ptr: *const u8 = s.as_ptr();

    unsafe {
        // 打印 String 实例的内存地址
        println!("String instance address: {:p}", s_ptr);

        // 打印 String 指向的堆内存地址
        println!("Heap memory address: {:p}", heap_ptr);
    }
}

大概了解了裸指针与String类型的关系，我们看下面的正餐：

#[derive(Debug)]
struct SelfRef {
    value: String,
    pointer_to_value: *const String,
}

impl SelfRef {  //为结构体实现四个方法
    fn new(txt: &str) -> Self {
        SelfRef {
            value: String::from(txt),
            pointer_to_value: std::ptr::null(),//创建一个空指针
        }
    }

    fn init(&mut self) {
        let self_ref: *const String = &self.value;
        //这行代码创建了一个指向 self.value 的不可变裸指针 self_ref。&self.value 是对 self.value 的借用，它返回一个指向 String 的引用。然后，这个引用被转换为一个裸指针 *const String
        self.pointer_to_value = self_ref;
        //这行代码将 self_ref 赋值给 self.pointer_to_value。现在，self.pointer_to_value 也指向了 self.value 的内存地址。这意味着 SelfRef 结构体的 pointer_to_value 字段现在存储了一个指向 self.value 的裸指针
    }

    fn value(&self) -> &str {
        &self.value
    }

    fn pointer_to_value(&self) -> &String {
        assert!(!self.pointer_to_value.is_null(),
            "Test::b called without Test::init being called first");
        //如果 assert! 宏的条件为 false，程序将中止执行，并显示一条错误信息
        //如果 self.pointer_to_value 是一个 null 指针，is_null() 将返回 true，应用 ! 运算符后，表达式的值变为 false。assert!将触发panic，并且显示后面的错误信息
        //如果 self.pointer_to_value 不是 null 指针，is_null() 将返回 false，应用 ! 运算符后，表达式的值变为 true。assert!不显示错误信息，继续往下执行
        unsafe { &*(self.pointer_to_value) }
        //*(self.pointer_to_value)：这是解引用操作，解引用操作将裸指针转换为对应的类型值，这里就是 String
        //&*(self.pointer_to_value)即返回一个&String类型
    }
}

fn main() {
    let mut t = SelfRef::new("hello");
    t.init();
    // 打印值和指针地址
    println!("{}, {:p}", t.value(), t.pointer_to_value());
}

在这里，我们在 pointer_to_value 中直接存储裸指针，而不是 Rust 的引用，因此不再受到 Rust 借用规则和生命周期的限制，而且实现起来非常清晰、简洁。但是缺点就是，通过指针获取值时需要使用 unsafe 代码。

当然，上面的代码你还能通过裸指针来修改 String，但是需要将 *const 修改为 *mut：

#[derive(Debug)]
struct SelfRef {
    value: String,
    pointer_to_value: *mut String,
}

impl SelfRef {
    fn new(txt: &str) -> Self {
        SelfRef {
            value: String::from(txt),
            pointer_to_value: std::ptr::null_mut(),
        }
    }

    fn init(&mut self) {
        let self_ref: *mut String = &mut self.value;
        self.pointer_to_value = self_ref;
    }

    fn value(&self) -> &str {
        &self.value
    }

    fn pointer_to_value(&self) -> &String {
        assert!(!self.pointer_to_value.is_null(), "Test::b called without Test::init being called first");
        unsafe { &*(self.pointer_to_value) }
    }
}

fn main() {
    let mut t = SelfRef::new("hello");
    t.init();
    println!("{}, {:p}", t.value(), t.pointer_to_value());

    t.value.push_str(", world");
    unsafe {
        (&mut *t.pointer_to_value).push_str("!");
    }

    println!("{}, {:p}", t.value(), t.pointer_to_value());
}

运行后输出：

hello, 0x16f3aec70
hello, world!, 0x16f3aec70

上面的 unsafe 虽然简单好用，但是它不太安全，是否还有其他选择？还真的有，那就是 Pin。

无法被移动的 Pin

Pin 在后续章节会深入讲解，目前你只需要知道它可以固定住一个值，防止该值在内存中被移动。

通过开头我们知道，自引用最麻烦的就是创建引用的同时，值的所有权会被转移，而通过 Pin 就可以很好的防止这一点：

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

// 下面是一个自引用数据结构体，因为 slice 字段是一个指针，指向了 data 字段
// 我们无法使用普通引用来实现，因为违背了 Rust 的编译规则
// 因此，这里我们使用了一个裸指针，通过 NonNull 来确保它不会为 null
struct Unmovable {
    data: String,
    slice: NonNull<String>,
    _pin: PhantomPinned,
}

impl Unmovable {
    // 为了确保函数返回时数据的所有权不会被转移，我们将它放在堆上，唯一的访问方式就是通过指针
    fn new(data: String) -> Pin<Box<Self>> {
        let res = Unmovable {
            data,
            // 只有在数据到位时，才创建指针，否则数据会在开始之前就被转移所有权
            slice: NonNull::dangling(),
            _pin: PhantomPinned,
        };
        let mut boxed = Box::pin(res);

        let slice = NonNull::from(&boxed.data);
        // 这里其实安全的，因为修改一个字段不会转移整个结构体的所有权
        unsafe {
            let mut_ref: Pin<&mut Self> = Pin::as_mut(&mut boxed);
            Pin::get_unchecked_mut(mut_ref).slice = slice;
        }
        boxed
    }
}

fn main() {
    let unmoved = Unmovable::new("hello".to_string());
    // 只要结构体没有被转移，那指针就应该指向正确的位置，而且我们可以随意移动指针
    let mut still_unmoved = unmoved;
    assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data));

    // 因为我们的类型没有实现 `Unpin` 特征，下面这段代码将无法编译
    // let mut new_unmoved = Unmovable::new("world".to_string());
    // std::mem::swap(&mut *still_unmoved, &mut *new_unmoved);
}

上面的代码也非常清晰，虽然使用了 unsafe，其实更多的是无奈之举，跟之前的 unsafe 实现完全不可同日而语。

其实 Pin 在这里并没有魔法，它也并不是实现自引用类型的主要原因，最关键的还是里面的裸指针的使用，而 Pin 起到的作用就是确保我们的值不会被移走，否则指针就会指向一个错误的地址！

使用 ouroboros

对于自引用结构体，三方库也有支持的，其中一个就是 ouroboros，当然它也有自己的限制，我们后面会提到，先来看看该如何使用：

use ouroboros::self_referencing;

#[self_referencing]
struct SelfRef {
    value: String,

    #[borrows(value)]
    pointer_to_value: &'this str,
}

fn main(){
    let v = SelfRefBuilder {
        value: "aaa".to_string(),
        pointer_to_value_builder: |value: &String| value,
    }.build();

    // 借用value值
    let s = v.borrow_value();
    // 借用指针
    let p = v.borrow_pointer_to_value();
    // value值和指针指向的值相等
    assert_eq!(s, *p);
}

可以看到，ouroboros 使用起来并不复杂，就是需要你去按照它的方式创建结构体和引用类型：SelfRef 变成 SelfRefBuilder，引用字段从 pointer_to_value 变成 pointer_to_value_builder，并且连类型都变了。

在使用时，通过 borrow_value 来借用 value 的值，通过 borrow_pointer_to_value 来借用 pointer_to_value 这个指针。

看上去很美好对吧？但是你可以尝试着去修改 String 字符串的值试试，ouroboros 限制还是较多的，但是对于基本类型依然是支持的不错，以下例子来源于官方：

use ouroboros::self_referencing;

#[self_referencing]
struct MyStruct {
    int_data: i32,
    float_data: f32,
    #[borrows(int_data)]
    int_reference: &'this i32,
    #[borrows(mut float_data)]
    float_reference: &'this mut f32,
}

fn main() {
    let mut my_value = MyStructBuilder {
        int_data: 42,
        float_data: 3.14,
        int_reference_builder: |int_data: &i32| int_data,
        float_reference_builder: |float_data: &mut f32| float_data,
    }.build();

    // Prints 42
    println!("{:?}", my_value.borrow_int_data());
    // Prints 3.14
    println!("{:?}", my_value.borrow_float_reference());
    // Sets the value of float_data to 84.0
    my_value.with_mut(|fields| {
        **fields.float_reference = (**fields.int_reference as f32) * 2.0;
    });

    // We can hold on to this reference...
    let int_ref = *my_value.borrow_int_reference();
    println!("{:?}", *int_ref);
    // As long as the struct is still alive.
    drop(my_value);
    // This will cause an error!
    // println!("{:?}", *int_ref);
}

总之，使用这个库前，强烈建议看一些官方的例子中支持什么样的类型和 API，如果能满足的你的需求，就果断使用它，如果不能满足，就继续往下看。

只能说，它确实帮助我们解决了问题，但是一个是破坏了原有的结构，另外就是并不是所有数据类型都支持：它需要目标值的内存地址不会改变，因此 Vec 动态数组就不适合，因为当内存空间不够时，Rust 会重新分配一块空间来存放该数组，这会导致内存地址的改变。

类似的库还有：

• rental， 这个库其实是最有名的，但是好像不再维护了，用倒是没问题
• owning-ref，将所有者和它的引用绑定到一个封装类型

这三个库，各有各的特点，也各有各的缺陷，建议大家需要时，一定要仔细调研，并且写 demo 进行测试，不可大意。

总结

上面讲了这么多方法，但是我们依然无法正确的告诉你在某个场景应该使用哪个方法，这个需要你自己的判断，因为自引用实在是过于复杂。

我们能做的就是告诉你，有这些办法可以解决自引用问题，而这些办法每个都有自己适用的范围，需要你未来去深入的挖掘和发现。

好在自引用这种情况真的不常见，往往是实现特定的算法和数据结构时才需要，应用代码中几乎用不到。

参考文献

Rust语言圣经-结构体自引用