rust
/
rust-course
mirror of https://github.com/sunface/rust-course
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '12108c0325'
${ noResults }
rust-course/advance/circle-self-ref/self-referential.html

563 lines
74 KiB
Raw Normal View History Unescape

deploy
1 month ago
<!DOCTYPE HTML>
<html lang="zh-CN" class="light" dir="ltr">
<head>
<!-- Book generated using mdBook -->
<meta charset="UTF-8">
<title>结构体中的自引用 - Rust语言圣经(Rust Course)</title>
<!-- Custom HTML head -->
<meta name="description" content="">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="theme-color" content="#ffffff">
<link rel="icon" href="../../favicon.svg">
<link rel="shortcut icon" href="../../favicon.png">
<link rel="stylesheet" href="../../css/variables.css">
<link rel="stylesheet" href="../../css/general.css">
<link rel="stylesheet" href="../../css/chrome.css">
<link rel="stylesheet" href="../../css/print.css" media="print">
<!-- Fonts -->
<link rel="stylesheet" href="../../FontAwesome/css/font-awesome.css">
<link rel="stylesheet" href="../../fonts/fonts.css">
<!-- Highlight.js Stylesheets -->
<link rel="stylesheet" href="../../highlight.css">
<link rel="stylesheet" href="../../tomorrow-night.css">
<link rel="stylesheet" href="../../ayu-highlight.css">
<!-- Custom theme stylesheets -->
<link rel="stylesheet" href="../../theme/style.css">
</head>
<body class="sidebar-visible no-js">
<div id="body-container">
<!-- Provide site root to javascript -->
<script>
var path_to_root = "../../";
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
</script>
<!-- Work around some values being stored in localStorage wrapped in quotes -->
<script>
try {
var theme = localStorage.getItem('mdbook-theme');
var sidebar = localStorage.getItem('mdbook-sidebar');
if (theme.startsWith('"') && theme.endsWith('"')) {
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
}
if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
}
} catch (e) { }
</script>
<!-- Set the theme before any content is loaded, prevents flash -->
<script>
var theme;
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
if (theme === null || theme === undefined) { theme = default_theme; }
var html = document.querySelector('html');
html.classList.remove('light')
html.classList.add(theme);
var body = document.querySelector('body');
body.classList.remove('no-js')
body.classList.add('js');
</script>
<input type="checkbox" id="sidebar-toggle-anchor" class="hidden">
<!-- Hide / unhide sidebar before it is displayed -->
<script>
var body = document.querySelector('body');
var sidebar = null;
var sidebar_toggle = document.getElementById("sidebar-toggle-anchor");
if (document.body.clientWidth >= 1080) {
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
sidebar = sidebar || 'visible';
} else {
sidebar = 'hidden';
}
sidebar_toggle.checked = sidebar === 'visible';
body.classList.remove('sidebar-visible');
body.classList.add("sidebar-" + sidebar);
</script>
<nav id="sidebar" class="sidebar" aria-label="Table of contents">
<div class="sidebar-scrollbox">
<ol class="chapter"><li class="chapter-item affix "><a href="../../about-book.html">关于本书</a></li><li class="chapter-item affix "><a href="../../into-rust.html">进入 Rust 编程世界</a></li><li class="chapter-item affix "><a href="../../first-try/sth-you-should-not-do.html">避免从入门到放弃</a></li><li class="chapter-item affix "><a href="../../community.html">社区和锈书</a></li><li class="spacer"></li><li class="chapter-item affix "><a href="../../some-thoughts.html">Xobserve: 一切皆可观测</a></li><li class="chapter-item affix "><a href="../../beat-ai.html">BeatAI: 工程师 AI 入门圣经</a></li><li class="chapter-item affix "><li class="part-title">Rust 语言基础学习</li><li class="spacer"></li><li class="chapter-item "><a href="../../first-try/intro.html"><strong aria-hidden="true">1.</strong> 寻找牛刀，以便小试</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../first-try/installation.html"><strong aria-hidden="true">1.1.</strong> 安装 Rust 环境</a></li><li class="chapter-item "><a href="../../first-try/editor.html"><strong aria-hidden="true">1.2.</strong> 墙推 VSCode!</a></li><li class="chapter-item "><a href="../../first-try/cargo.html"><strong aria-hidden="true">1.3.</strong> 认识 Cargo</a></li><li class="chapter-item "><a href="../../first-try/hello-world.html"><strong aria-hidden="true">1.4.</strong> 不仅仅是 Hello world</a></li><li class="chapter-item "><a href="../../first-try/slowly-downloading.html"><strong aria-hidden="true">1.5.</strong> 下载依赖太慢了？</a></li></ol></li><li class="chapter-item "><a href="../../basic/intro.html"><strong aria-hidden="true">2.</strong> Rust 基础入门</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/variable.html"><strong aria-hidden="true">2.1.</strong> 变量绑定与解构</a></li><li class="chapter-item "><a href="../../basic/base-type/index.html"><strong aria-hidden="true">2.2.</strong> 基本类型</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/base-type/numbers.html"><strong aria-hidden="true">2.2.1.</strong> 数值类型</a></li><li class="chapter-item "><a href="../../basic/base-type/char-bool.html"><strong aria-hidden="true">2.2.2.</strong> 字符、布尔、单元类型</a></li><li class="chapter-item "><a href="../../basic/base-type/statement-expression.html"><strong aria-hidden="true">2.2.3.</strong> 语句与表达式</a></li><li class="chapter-item "><a href="../../basic/base-type/function.html"><strong aria-hidden="true">2.2.4.</strong> 函数</a></li></ol></li><li class="chapter-item "><a href="../../basic/ownership/index.html"><strong aria-hidden="true">2.3.</strong> 所有权和借用</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/ownership/ownership.html"><strong aria-hidden="true">2.3.1.</strong> 所有权</a></li><li class="chapter-item "><a href="../../basic/ownership/borrowing.html"><strong aria-hidden="true">2.3.2.</strong> 引用与借用</a></li></ol></li><li class="chapter-item "><a href="../../basic/compound-type/intro.html"><strong aria-hidden="true">2.4.</strong> 复合类型</a><a class="toggle"><div>❱</div></a></li><li><ol class="section"><li class="chapter-item "><a href="../../basic/compound-type/string-slice.html"><strong aria-hidden="true">2.4.1.</strong> 字符串与切片</a></li><li class="chapter-item "><a href="../../basic/compound-type/tuple.html"><strong aria-hidden="true">2.4.2.</strong> 元组</a></li><li class="chapter-item "><a href="../../basic/compound-type/struct.html"><strong aria-hidden="true">2.4.3.</strong> 结构体</a></li><li class="chapter-item "><a href="../../basic/compound-type/enum.html"><strong aria-hidden="true">2.4.4.</strong> 枚举</a></li><li class="chapter-item "><a href="../../basic/compound-type/array.html"><strong aria-hidden="true">2.4.5.</strong> 数组</a></l
</div>
<div id="sidebar-resize-handle" class="sidebar-resize-handle">
<div class="sidebar-resize-indicator"></div>
</div>
</nav>
<!-- Track and set sidebar scroll position -->
<script>
var sidebarScrollbox = document.querySelector('#sidebar .sidebar-scrollbox');
sidebarScrollbox.addEventListener('click', function(e) {
if (e.target.tagName === 'A') {
sessionStorage.setItem('sidebar-scroll', sidebarScrollbox.scrollTop);
}
}, { passive: true });
var sidebarScrollTop = sessionStorage.getItem('sidebar-scroll');
sessionStorage.removeItem('sidebar-scroll');
if (sidebarScrollTop) {
// preserve sidebar scroll position when navigating via links within sidebar
sidebarScrollbox.scrollTop = sidebarScrollTop;
} else {
// scroll sidebar to current active section when navigating via "next/previous chapter" buttons
var activeSection = document.querySelector('#sidebar .active');
if (activeSection) {
activeSection.scrollIntoView({ block: 'center' });
}
}
</script>
<div id="page-wrapper" class="page-wrapper">
<div class="page">
<div id="menu-bar-hover-placeholder"></div>
<div id="menu-bar" class="menu-bar sticky">
<div class="left-buttons">
<label id="sidebar-toggle" class="icon-button" for="sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
<i class="fa fa-bars"></i>
</label>
<button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
<i class="fa fa-paint-brush"></i>
</button>
<ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
<li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
<li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
<li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
<li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
<li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
</ul>
<button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
<i class="fa fa-search"></i>
</button>
</div>
<h1 class="menu-title">Rust语言圣经(Rust Course)</h1>
<div class="right-buttons">
<a href="../../print.html" title="Print this book" aria-label="Print this book">
<i id="print-button" class="fa fa-print"></i>
</a>
<a href="https://github.com/sunface/rust-course" title="Git repository" aria-label="Git repository">
<i id="git-repository-button" class="fa fa-github"></i>
</a>
<a href="https://github.com/sunface/rust-course/edit/main/src/advance/circle-self-ref/self-referential.md" title="Suggest an edit" aria-label="Suggest an edit">
<i id="git-edit-button" class="fa fa-edit"></i>
</a>
</div>
</div>
<div id="search-wrapper" class="hidden">
<form id="searchbar-outer" class="searchbar-outer">
<input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
</form>
<div id="searchresults-outer" class="searchresults-outer hidden">
<div id="searchresults-header" class="searchresults-header"></div>
<ul id="searchresults">
</ul>
</div>
</div>
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
<script>
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
});
</script>
<div id="content" class="content">
<!-- Page table of contents -->
<div class="sidetoc"><nav class="pagetoc"></nav></div>
<main>
<h2 id="结构体自引用"><a class="header" href="#结构体自引用">结构体自引用</a></h2>
<p>结构体自引用在 Rust 中是一个众所周知的难题，而且众说纷纭，也没有一篇文章能把相关的话题讲透，那本文就王婆卖瓜，来试试看能不能讲透这一块儿内容，让读者大大们舒心。</p>
<h2 id="平平无奇的自引用"><a class="header" href="#平平无奇的自引用">平平无奇的自引用</a></h2>
<p>可能也有不少人第一次听说自引用结构体，那咱们先来看看它们长啥样。</p>
<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
</span><span class="boring">fn main() {
</span>struct SelfRef&lt;'a&gt; {
value: String,
// 该引用指向上面的value
pointer_to_value: &amp;'a str,
}
<span class="boring">}</span></code></pre></pre>
<p>以上就是一个很简单的自引用结构体，看上去好像没什么，那来试着运行下：</p>
<pre><pre class="playground"><code class="language-rust edition2021">fn main(){
let s = &quot;aaa&quot;.to_string();
let v = SelfRef {
value: s,
pointer_to_value: &amp;s
};
}</code></pre></pre>
<p>运行后报错：</p>
<pre><code class="language-console"> let v = SelfRef {
12 | value: s,
| - value moved here
13 | pointer_to_value: &amp;s
| ^^ value borrowed here after move
</code></pre>
<p>因为我们试图同时使用值和值的引用，最终所有权转移和借用一起发生了。所以，这个问题貌似并没有那么好解决，不信你可以回想下自己具有的知识，是否可以解决？</p>
<h2 id="使用-option"><a class="header" href="#使用-option">使用 Option</a></h2>
<p>最简单的方式就是使用 <code>Option</code> 分两步来实现：</p>
<pre><pre class="playground"><code class="language-rust edition2021">#[derive(Debug)]
struct WhatAboutThis&lt;'a&gt; {
name: String,
nickname: Option&lt;&amp;'a str&gt;,
}
fn main() {
let mut tricky = WhatAboutThis {
name: &quot;Annabelle&quot;.to_string(),
nickname: None,
};
tricky.nickname = Some(&amp;tricky.name[..4]);
println!(&quot;{:?}&quot;, tricky);
}</code></pre></pre>
<p>在某种程度上来说，<code>Option</code> 这个方法可以工作，但是这个方法的限制较多，例如从一个函数创建并返回它是不可能的：</p>
<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
</span><span class="boring">fn main() {
</span>fn creator&lt;'a&gt;() -&gt; WhatAboutThis&lt;'a&gt; {
let mut tricky = WhatAboutThis {
name: &quot;Annabelle&quot;.to_string(),
nickname: None,
};
tricky.nickname = Some(&amp;tricky.name[..4]);
tricky
}
<span class="boring">}</span></code></pre></pre>
<p>报错如下：</p>
<pre><code class="language-console">error[E0515]: cannot return value referencing local data `tricky.name`
--&gt; src/main.rs:24:5
|
22 | tricky.nickname = Some(&amp;tricky.name[..4]);
| ----------- `tricky.name` is borrowed here
23 |
24 | tricky
| ^^^^^^ returns a value referencing data owned by the current function
</code></pre>
<p>其实从函数签名就能看出来端倪，<code>'a</code> 生命周期是凭空产生的！</p>
<p>如果是通过方法使用，你需要一个无用 <code>&amp;'a self</code> 生命周期标识，一旦有了这个标识，代码将变得更加受限，你将很容易就获得借用错误，就连 NLL 规则都没用：</p>
<pre><pre class="playground"><code class="language-rust edition2021">#[derive(Debug)]
struct WhatAboutThis&lt;'a&gt; {
name: String,
nickname: Option&lt;&amp;'a str&gt;,
}
impl&lt;'a&gt; WhatAboutThis&lt;'a&gt; {
fn tie_the_knot(&amp;'a mut self) {
self.nickname = Some(&amp;self.name[..4]);
}
}
fn main() {
let mut tricky = WhatAboutThis {
name: &quot;Annabelle&quot;.to_string(),
nickname: None,
};
tricky.tie_the_knot();
// cannot borrow `tricky` as immutable because it is also borrowed as mutable
// println!(&quot;{:?}&quot;, tricky);
}</code></pre></pre>
<h2 id="unsafe-实现"><a class="header" href="#unsafe-实现">unsafe 实现</a></h2>
<p>既然借用规则妨碍了我们，那就一脚踢开：</p>
<pre><pre class="playground"><code class="language-rust edition2021">#[derive(Debug)]
struct SelfRef {
value: String,
pointer_to_value: *const String,
}
impl SelfRef {
fn new(txt: &amp;str) -&gt; Self {
SelfRef {
value: String::from(txt),
pointer_to_value: std::ptr::null(),
}
}
fn init(&amp;mut self) {
let self_ref: *const String = &amp;self.value;
self.pointer_to_value = self_ref;
}
fn value(&amp;self) -&gt; &amp;str {
&amp;self.value
}
fn pointer_to_value(&amp;self) -&gt; &amp;String {
assert!(!self.pointer_to_value.is_null(),
&quot;Test::b called without Test::init being called first&quot;);
unsafe { &amp;*(self.pointer_to_value) }
}
}
fn main() {
let mut t = SelfRef::new(&quot;hello&quot;);
t.init();
// 打印值和指针地址
println!(&quot;{}, {:p}&quot;, t.value(), t.pointer_to_value());
}</code></pre></pre>
<p>在这里，我们在 <code>pointer_to_value</code> 中直接存储裸指针，而不是 Rust 的引用，因此不再受到 Rust 借用规则和生命周期的限制，而且实现起来非常清晰、简洁。但是缺点就是，通过指针获取值时需要使用 <code>unsafe</code> 代码。</p>
<p>当然，上面的代码你还能通过裸指针来修改 <code>String</code>，但是需要将 <code>*const</code> 修改为 <code>*mut</code>：</p>
<pre><pre class="playground"><code class="language-rust edition2021">#[derive(Debug)]
struct SelfRef {
value: String,
pointer_to_value: *mut String,
}
impl SelfRef {
fn new(txt: &amp;str) -&gt; Self {
SelfRef {
value: String::from(txt),
pointer_to_value: std::ptr::null_mut(),
}
}
fn init(&amp;mut self) {
let self_ref: *mut String = &amp;mut self.value;
self.pointer_to_value = self_ref;
}
fn value(&amp;self) -&gt; &amp;str {
&amp;self.value
}
fn pointer_to_value(&amp;self) -&gt; &amp;String {
assert!(!self.pointer_to_value.is_null(), &quot;Test::b called without Test::init being called first&quot;);
unsafe { &amp;*(self.pointer_to_value) }
}
}
fn main() {
let mut t = SelfRef::new(&quot;hello&quot;);
t.init();
println!(&quot;{}, {:p}&quot;, t.value(), t.pointer_to_value());
t.value.push_str(&quot;, world&quot;);
unsafe {
(&amp;mut *t.pointer_to_value).push_str(&quot;!&quot;);
}
println!(&quot;{}, {:p}&quot;, t.value(), t.pointer_to_value());
}</code></pre></pre>
<p>运行后输出：</p>
<pre><code class="language-console">hello, 0x16f3aec70
hello, world!, 0x16f3aec70
</code></pre>
<p>上面的 <code>unsafe</code> 虽然简单好用，但是它不太安全，是否还有其他选择？还真的有，那就是 <code>Pin</code>。</p>
<h2 id="无法被移动的-pin"><a class="header" href="#无法被移动的-pin">无法被移动的 Pin</a></h2>
<p><code>Pin</code> 在后续章节会深入讲解，目前你只需要知道它可以固定住一个值，防止该值在内存中被移动。</p>
<p>通过开头我们知道，自引用最麻烦的就是创建引用的同时，值的所有权会被转移，而通过 <code>Pin</code> 就可以很好的防止这一点：</p>
<pre><pre class="playground"><code class="language-rust edition2021">use std::marker::PhantomPinned;
use std::pin::Pin;
use std::ptr::NonNull;
// 下面是一个自引用数据结构体，因为 slice 字段是一个指针，指向了 data 字段
// 我们无法使用普通引用来实现，因为违背了 Rust 的编译规则
// 因此，这里我们使用了一个裸指针，通过 NonNull 来确保它不会为 null
struct Unmovable {
data: String,
slice: NonNull&lt;String&gt;,
_pin: PhantomPinned,
}
impl Unmovable {
// 为了确保函数返回时数据的所有权不会被转移，我们将它放在堆上，唯一的访问方式就是通过指针
fn new(data: String) -&gt; Pin&lt;Box&lt;Self&gt;&gt; {
let res = Unmovable {
data,
// 只有在数据到位时，才创建指针，否则数据会在开始之前就被转移所有权
slice: NonNull::dangling(),
_pin: PhantomPinned,
};
let mut boxed = Box::pin(res);
let slice = NonNull::from(&amp;boxed.data);
// 这里其实安全的，因为修改一个字段不会转移整个结构体的所有权
unsafe {
let mut_ref: Pin&lt;&amp;mut Self&gt; = Pin::as_mut(&amp;mut boxed);
Pin::get_unchecked_mut(mut_ref).slice = slice;
}
boxed
}
}
fn main() {
let unmoved = Unmovable::new(&quot;hello&quot;.to_string());
// 只要结构体没有被转移，那指针就应该指向正确的位置，而且我们可以随意移动指针
let mut still_unmoved = unmoved;
assert_eq!(still_unmoved.slice, NonNull::from(&amp;still_unmoved.data));
// 因为我们的类型没有实现 `Unpin` 特征，下面这段代码将无法编译
// let mut new_unmoved = Unmovable::new(&quot;world&quot;.to_string());
// std::mem::swap(&amp;mut *still_unmoved, &amp;mut *new_unmoved);
}</code></pre></pre>
<p>上面的代码也非常清晰，虽然使用了 <code>unsafe</code>，其实更多的是无奈之举，跟之前的 <code>unsafe</code> 实现完全不可同日而语。</p>
<p>其实 <code>Pin</code> 在这里并没有魔法，它也并不是实现自引用类型的主要原因，最关键的还是里面的裸指针的使用，而 <code>Pin</code> 起到的作用就是确保我们的值不会被移走，否则指针就会指向一个错误的地址！</p>
<h2 id="使用-ouroboros"><a class="header" href="#使用-ouroboros">使用 ouroboros</a></h2>
<p>对于自引用结构体，三方库也有支持的，其中一个就是 <a href="https://github.com/joshua-maros/ouroboros">ouroboros</a>，当然它也有自己的限制，我们后面会提到，先来看看该如何使用：</p>
<pre><pre class="playground"><code class="language-rust edition2021">use ouroboros::self_referencing;
#[self_referencing]
struct SelfRef {
value: String,
#[borrows(value)]
pointer_to_value: &amp;'this str,
}
fn main(){
let v = SelfRefBuilder {
value: &quot;aaa&quot;.to_string(),
pointer_to_value_builder: |value: &amp;String| value,
}.build();
// 借用value值
let s = v.borrow_value();
// 借用指针
let p = v.borrow_pointer_to_value();
// value值和指针指向的值相等
assert_eq!(s, *p);
}</code></pre></pre>
<p>可以看到，<code>ouroboros</code> 使用起来并不复杂，就是需要你去按照它的方式创建结构体和引用类型：<code>SelfRef</code> 变成 <code>SelfRefBuilder</code>，引用字段从 <code>pointer_to_value</code> 变成 <code>pointer_to_value_builder</code>，并且连类型都变了。</p>
<p>在使用时，通过 <code>borrow_value</code> 来借用 <code>value</code> 的值，通过 <code>borrow_pointer_to_value</code> 来借用 <code>pointer_to_value</code> 这个指针。</p>
<p>看上去很美好对吧？但是你可以尝试着去修改 <code>String</code> 字符串的值试试，<code>ouroboros</code> 限制还是较多的，但是对于基本类型依然是支持的不错，以下例子来源于官方：</p>
<pre><pre class="playground"><code class="language-rust edition2021">use ouroboros::self_referencing;
#[self_referencing]
struct MyStruct {
int_data: i32,
float_data: f32,
#[borrows(int_data)]
int_reference: &amp;'this i32,
#[borrows(mut float_data)]
float_reference: &amp;'this mut f32,
}
fn main() {
let mut my_value = MyStructBuilder {
int_data: 42,
float_data: 3.14,
int_reference_builder: |int_data: &amp;i32| int_data,
float_reference_builder: |float_data: &amp;mut f32| float_data,
}.build();
// Prints 42
println!(&quot;{:?}&quot;, my_value.borrow_int_data());
// Prints 3.14
println!(&quot;{:?}&quot;, 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!(&quot;{:?}&quot;, *int_ref);
// As long as the struct is still alive.
drop(my_value);
// This will cause an error!
// println!(&quot;{:?}&quot;, *int_ref);
}</code></pre></pre>
<p>总之，使用这个库前，强烈建议看一些官方的例子中支持什么样的类型和 API，如果能满足的你的需求，就果断使用它，如果不能满足，就继续往下看。</p>
<p>只能说，它确实帮助我们解决了问题，但是一个是破坏了原有的结构，另外就是并不是所有数据类型都支持：它需要目标值的内存地址不会改变，因此 <code>Vec</code> 动态数组就不适合，因为当内存空间不够时，Rust 会重新分配一块空间来存放该数组，这会导致内存地址的改变。</p>
<p>类似的库还有：</p>
<ul>
<li><a href="https://github.com/jpernst/rental">rental</a>， 这个库其实是最有名的，但是好像不再维护了，用倒是没问题</li>
<li><a href="https://github.com/Kimundi/owning-ref-rs">owning-ref</a>，将所有者和它的引用绑定到一个封装类型</li>
</ul>
<p>这三个库，各有各的特点，也各有各的缺陷，建议大家需要时，一定要仔细调研，并且写 demo 进行测试，不可大意。</p>
<blockquote>
<p>rental 虽然不怎么维护，但是可能依然是这三个里面最强大的，而且网上的用例也比较多，容易找到参考代码</p>
</blockquote>
<h2 id="rc--refcell-或-arc--mutex"><a class="header" href="#rc--refcell-或-arc--mutex">Rc + RefCell 或 Arc + Mutex</a></h2>
<p>类似于循环引用的解决方式，自引用也可以用这种组合来解决，但是会导致代码的类型标识到处都是，大大的影响了可读性。</p>
<h2 id="终极大法"><a class="header" href="#终极大法">终极大法</a></h2>
<p>如果两个放在一起会报错，那就分开它们。对，终极大法就这么简单，当然思路上的简单不代表实现上的简单，最终结果就是导致代码复杂度的上升。</p>
<h2 id="学习一本书如何实现链表"><a class="header" href="#学习一本书如何实现链表">学习一本书：如何实现链表</a></h2>
<p>最后，推荐一本专门讲如何实现链表的书（真是富有 Rust 特色，链表都能复杂到出书了 o_o），<a href="https://rust-unofficial.github.io/too-many-lists/">Learn Rust by writing Entirely Too Many Linked Lists</a></p>
<h2 id="总结"><a class="header" href="#总结">总结</a></h2>
<p>上面讲了这么多方法，但是我们依然无法正确的告诉你在某个场景应该使用哪个方法，这个需要你自己的判断，因为自引用实在是过于复杂。</p>
<p>我们能做的就是告诉你，有这些办法可以解决自引用问题，而这些办法每个都有自己适用的范围，需要你未来去深入的挖掘和发现。</p>
<p>偷偷说一句，就算是我，遇到自引用一样挺头疼，好在这种情况真的不常见，往往是实现特定的算法和数据结构时才需要，应用代码中几乎用不到。</p>
<div id="giscus-container"></div>
</main>
<nav class="nav-wrapper" aria-label="Page navigation">
<!-- Mobile navigation buttons -->
<a rel="prev" href="../../advance/circle-self-ref/circle-reference.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
<i class="fa fa-angle-left"></i>
</a>
<a rel="next prefetch" href="../../advance/concurrency-with-threads/intro.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
<i class="fa fa-angle-right"></i>
</a>
<div style="clear: both"></div>
</nav>
</div>
</div>
<nav class="nav-wide-wrapper" aria-label="Page navigation">
<a rel="prev" href="../../advance/circle-self-ref/circle-reference.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
<i class="fa fa-angle-left"></i>
</a>
<a rel="next prefetch" href="../../advance/concurrency-with-threads/intro.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
<i class="fa fa-angle-right"></i>
</a>
</nav>
</div>
<script>
window.playground_copyable = true;
</script>
<script src="../../ace.js"></script>
<script src="../../editor.js"></script>
<script src="../../mode-rust.js"></script>
<script src="../../theme-dawn.js"></script>
<script src="../../theme-tomorrow_night.js"></script>
<script src="../../elasticlunr.min.js"></script>
<script src="../../mark.min.js"></script>
<script src="../../searcher.js"></script>
<script src="../../clipboard.min.js"></script>
<script src="../../highlight.js"></script>
<script src="../../book.js"></script>
<script type="text/javascript" charset="utf-8">
var pagePath = "advance/circle-self-ref/self-referential.md"
</script>
<!-- Custom JS scripts -->
<script src="../../assets/custom.js"></script>
<script src="../../assets/bigPicture.js"></script>
</div>
</body>
</html>