@ -1,5 +1,5 @@
## 结构体自引用
## 结构体自引用
结构体自引用在Rust中是一个众所周知的难题， ， ， ， ，
结构体自引用在 Rust 中是一个众所周知的难题，而且众说纷纭，也没有一篇文章能把相关的话题讲透，那本文就王婆卖瓜，来试试看能不能讲透这一块儿内容，让读者大大们舒心。
## 平平无奇的自引用
## 平平无奇的自引用
可能也有不少人第一次听说自引用结构体，那咱们先来看看它们长啥样。
可能也有不少人第一次听说自引用结构体，那咱们先来看看它们长啥样。
@ -12,7 +12,7 @@ struct RefWithinMe<'a> {
pointer_to_value: & 'a str,
pointer_to_value: & 'a str,
}
}
```
```
以上就是一个很简单的自引用结构体, 看上去好像没什么，那来试着运行下：
以上就是一个很简单的自引用结构体，
```rust
```rust
fn main(){
fn main(){
let s = "aaa".to_string();
let s = "aaa".to_string();
@ -23,7 +23,7 @@ fn main(){
}
}
```
```
运行后报错:
运行后报错：
```console
```console
let v = SelfRef {
let v = SelfRef {
12 | value: s,
12 | value: s,
@ -34,8 +34,8 @@ fn main(){
因为我们试图同时使用值和值的引用，最终所有权转移和借用一起发生了。所以，这个问题貌似并没有那么好解决，不信你可以回想下自己具有的知识，是否可以解决？
因为我们试图同时使用值和值的引用，最终所有权转移和借用一起发生了。所以，这个问题貌似并没有那么好解决，不信你可以回想下自己具有的知识，是否可以解决？
## 使用Option
## 使用 Option
最简单的方式就是使用`Opiton`分两步来实现:
最简单的方式就是使用 `Opiton` 分两步来实现：
```rust
```rust
#[derive(Debug)]
#[derive(Debug)]
struct WhatAboutThis< 'a> {
struct WhatAboutThis< 'a> {
@ -54,7 +54,7 @@ fn main() {
}
}
```
```
在某种程度上来说，`Option`这个方法可以工作，但是这个方法的限制较多，例如从一个函数创建并返回它是不可能的:
在某种程度上来说，`Option` 这个方法可以工作，但是这个方法的限制较多，例如从一个函数创建并返回它是不可能的：
```rust
```rust
fn creator< 'a>() -> WhatAboutThis< 'a> {
fn creator< 'a>() -> WhatAboutThis< 'a> {
let mut tricky = WhatAboutThis {
let mut tricky = WhatAboutThis {
@ -67,7 +67,7 @@ fn creator<'a>() -> WhatAboutThis<'a> {
}
}
```
```
报错如下:
报错如下：
```console
```console
error[E0515]: cannot return value referencing local data `tricky.name`
error[E0515]: cannot return value referencing local data `tricky.name`
--> src/main.rs:24:5
--> src/main.rs:24:5
@ -79,9 +79,9 @@ error[E0515]: cannot return value referencing local data `tricky.name`
| ^^^^^^ returns a value referencing data owned by the current function
| ^^^^^^ returns a value referencing data owned by the current function
```
```
其实从函数签名就能看出来端倪，`'a`生命周期是凭空产生的！
其实从函数签名就能看出来端倪，`'a` 生命周期是凭空产生的！
如果是通过方法使用，你需要一个无用`， ， ， ， ：
如果是通过方法使用，你需要一个无用 `&'a self` 生命周期标识，一旦有了这个标识，代码将变得更加受限，你将很容易就获得借用错误，就连 NLL 规则都没用：
```rust
```rust
#[derive(Debug)]
#[derive(Debug)]
struct WhatAboutThis< 'a> {
struct WhatAboutThis< 'a> {
@ -107,8 +107,8 @@ fn main() {
}
}
```
```
## unsafe实现
## unsafe 实现
既然借用规则妨碍了我们，那就一脚踢开:
既然借用规则妨碍了我们，那就一脚踢开：
```rust
```rust
#[derive(Debug)]
#[derive(Debug)]
struct SelfRef {
struct SelfRef {
@ -134,7 +134,8 @@ impl SelfRef {
}
}
fn pointer_to_value(& self) -> & String {
fn pointer_to_value(& self) -> & String {
assert!(!self.pointer_to_value.is_null(), "Test::b called without Test::init being called first");
assert!(!self.pointer_to_value.is_null(),
"Test::b called without Test::init being called first");
unsafe { & *(self.pointer_to_value) }
unsafe { & *(self.pointer_to_value) }
}
}
}
}
@ -143,13 +144,13 @@ fn main() {
let mut t = SelfRef::new("hello");
let mut t = SelfRef::new("hello");
t.init();
t.init();
// 打印值和指针地址
// 打印值和指针地址
println!("{}, {:p}",t.value(), t.pointer_to_value());
println!("{}, {:p}", t.value(), t.pointer_to_value());
}
}
```
```
在这里，我们在`pointer_to_value`中直接存储原生指针， ， ， ， `unsafe`代码,
在这里，我们在 `pointer_to_value` 中直接存储原生指针，而不是 Rust 的引用，因此不再受到 Rust 借用规则和生命周期的限制，而且实现起来非常清晰、简洁。但是缺点就是，通过指针获取值时需要使用 `unsafe` 代码。
当然，上面的代码你还能通过原生指针来修改`String`，但是需要将`*const`修改为`*mut`:
当然，上面的代码你还能通过原生指针来修改 `String` ，但是需要将 `*const` 修改为 `*mut` ：
```rust
```rust
#[derive(Debug)]
#[derive(Debug)]
struct SelfRef {
struct SelfRef {
@ -183,36 +184,36 @@ impl SelfRef {
fn main() {
fn main() {
let mut t = SelfRef::new("hello");
let mut t = SelfRef::new("hello");
t.init();
t.init();
println!("{}, {:p}",t.value(), t.pointer_to_value());
println!("{}, {:p}", t.value(), t.pointer_to_value());
t.value.push_str(", world");
t.value.push_str(", world");
unsafe {
unsafe {
(& mut *t.pointer_to_value).push_str("!");
(& mut *t.pointer_to_value).push_str("!");
}
}
println!("{}, {:p}",t.value(), t.pointer_to_value());
println!("{}, {:p}", t.value(), t.pointer_to_value());
}
}
```
```
运行后输出:
运行后输出：
```console
```console
hello, 0x16f3aec70
hello, 0x16f3aec70
hello, world!, 0x16f3aec70
hello, world!, 0x16f3aec70
```
```
上面的`unsafe`虽然简单好用，但是它不太安全，是否还有其他选择？还真的有，那就是`Pin`。
上面的 `unsafe` 虽然简单好用，但是它不太安全，是否还有其他选择？还真的有，那就是 `Pin`
## 无法被移动的Pin
## 无法被移动的 Pin
Pin在后续章节会深入讲解， ，
` ` 在后续章节会深入讲解，目前你只需要知道它可以固定住一个值，防止该值在内存中被移动。
通过开头我们知道，自引用最麻烦的就是创建引用的同时，值的所有权会被转移，而通过Pin就可以很好的防止这一点:
通过开头我们知道，自引用最麻烦的就是创建引用的同时，值的所有权会被转移，而通过 `Pin` 就可以很好的防止这一点：
```rust
```rust
use std::marker::PhantomPinned;
use std::marker::PhantomPinned;
use std::pin::Pin;
use std::pin::Pin;
use std::ptr::NonNull;
use std::ptr::NonNull;
// 下面是一个自引用数据结构体，因为slice字段是一个指针, 指向了data 字段
// 下面是一个自引用数据结构体，因为 slice 字段是一个指针，指向了 data 字段
// 我们无法使用普通引用来实现，
// 我们无法使用普通引用来实现，因为违背了 Rust 的编译规则
// 因此， ，
// 因此，这里我们使用了一个原生指针，通过 NonNull 来确保它不会为 null
struct Unmovable {
struct Unmovable {
data: String,
data: String,
slice: NonNull< String > ,
slice: NonNull< String > ,
@ -220,7 +221,7 @@ struct Unmovable {
}
}
impl Unmovable {
impl Unmovable {
// 为了确保函数返回时数据的所有权不会被转移, 我们将它放在堆上, 唯一的访问方式就是通过指针
// 为了确保函数返回时数据的所有权不会被转移，我们将它放在堆上， 唯一的访问方式就是通过指针
fn new(data: String) -> Pin< Box < Self > > {
fn new(data: String) -> Pin< Box < Self > > {
let res = Unmovable {
let res = Unmovable {
data,
data,
@ -246,20 +247,20 @@ fn main() {
let mut still_unmoved = unmoved;
let mut still_unmoved = unmoved;
assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data));
assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data));
// 因为我们的类型没有实现`Unpin`特征，下面这段代码将无法编译
// 因为我们的类型没有实现 `Unpin` 特征，下面这段代码将无法编译
// let mut new_unmoved = Unmovable::new("world".to_string());
// let mut new_unmoved = Unmovable::new("world".to_string());
// std::mem::swap(& mut *still_unmoved, & mut *new_unmoved);
// std::mem::swap(& mut *still_unmoved, & mut *new_unmoved);
}
}
```
```
上面的代码也非常清晰，虽然使用了`unsafe`，其实更多的是无奈之举，跟之前的`unsafe`实现完全不可同日而语。
上面的代码也非常清晰，虽然使用了 `unsafe` `unsafe` 实现完全不可同日而语。
其实`Pin`在这里并没有魔法，它也并不是实现自引用类型的主要原因，最关键的还是里面的原生指针的使用，而`Pin`起到的作用就是确保我们的值不会被移走，否则指针就会指向一个错误的地址！
其实 `Pin` 在这里并没有魔法，它也并不是实现自引用类型的主要原因，最关键的还是里面的原生指针的使用，而 `Pin` 起到的作用就是确保我们的值不会被移走，否则指针就会指向一个错误的地址！
## 使用ouroboros
## 使用 ouroboros
对于自引用结构体，三方库也有支持的，其中一个就是[ouroboros](https://github.com/joshua-maros/ouroboros)，当然它也有自己的限制，我们后面会提到，先来看看该如何使用：
对于自引用结构体，三方库也有支持的，其中一个就是 [
```rust
```rust
use ouroboros::self_referencing;
use ouroboros::self_referencing;
@ -286,11 +287,11 @@ fn main(){
}
}
```
```
可以看到，`ouroboros`使用起来并不复杂，就是需要你去按照它的方式创建结构体和引用类型：`SelfRef`变成`SelfRefBuilder`，引用字段从`pointer_to_value`变成`pointer_to_value_builder`，并且连类型都变了。
可以看到，`ouroboros` 使用起来并不复杂，就是需要你去按照它的方式创建结构体和引用类型：`SelfRef` 变成 `SelfRefBuilder` `pointer_to_value` 变成 `pointer_to_value_builder`
在使用时，通过`borrow_value`来借用`value`的值，通过`borrow_pointer_to_value`来借用`pointer_to_value`这个指针。
在使用时，通过 `borrow_value` 来借用 `value` 的值，通过 `borrow_pointer_to_value` 来借用 `pointer_to_value` 这个指针。
看上去很美好对吧？但是你可以尝试着去修改`String`字符串的值试试，`ouroboros`限制还是较多的，但是对于基本类型依然是支持的不错，以下例子来源于官方:
看上去很美好对吧？但是你可以尝试着去修改 `String` 字符串的值试试，`ouroboros` 限制还是较多的，但是对于基本类型依然是支持的不错，以下例子来源于官方：
```rust
```rust
use ouroboros::self_referencing;
use ouroboros::self_referencing;
@ -331,19 +332,19 @@ fn main() {
}
}
```
```
总之， ， ， ， ， ，
总之，使用这个库前，强烈建议看一些官方的例子中支持什么样的类型和 API， ， ， ，
只能说，它确实帮助我们解决了问题，但是一个是破坏了原有的结构，另外就是并不是所有数据类型都支持：它需要目标值的内存地址不会改变，因此`Vec`动态数组就不适合， ， ，
只能说，它确实帮助我们解决了问题，但是一个是破坏了原有的结构，另外就是并不是所有数据类型都支持：它需要目标值的内存地址不会改变，因此 `Vec` 动态数组就不适合， ， 会重新分配一块空间来存放该数组，这会导致内存地址的改变。
类似的库还有:
类似的库还有：
- [rental ](https://github.com/jpernst/rental )，
- [rental ](https://github.com/jpernst/rental )，
- [owning-ref ](https://github.com/Kimundi/owning-ref-rs ) ，将所有者和它的引用绑定到一个封装类型
- [owning-ref ](https://github.com/Kimundi/owning-ref-rs )，将所有者和它的引用绑定到一个封装类型
这三个库， ， ， ， ， ，
这三个库，各有各的特点，也各有各的缺陷，建议大家需要时，一定要仔细调研，并且写 demo 进行测试，不可大意。
> rental虽然不怎么维护， ， ，
> rental 虽然不怎么维护，但是可能依然是这三个里面最强大的，而且网上的用例也比较多，容易找到参考代码
## Rc+RefCell或Arc+Mutex
## Rc + RefCell 或 Arc + Mutex
类似于循环引用的解决方式，自引用也可以用这种组合来解决，但是会导致代码的类型标识到处都是，大大的影响了可读性。
类似于循环引用的解决方式，自引用也可以用这种组合来解决，但是会导致代码的类型标识到处都是，大大的影响了可读性。
@ -352,7 +353,7 @@ fn main() {
## 学习一本书：如何实现链表
## 学习一本书：如何实现链表
最后，推荐一本专门将如何实现链表的书(真是富有Rust特色， ，
最后，推荐一本专门将如何实现链表的书（真是富有 Rust 特色， ） ，
## 总结
## 总结
Allan Downey
3 years ago