介绍
相关概念
指针：一个变量在内存中包含的是另一个地址（指向其他数据）
Rust中最常见的指针就是“引用”
引用：
使用&
借用它指向的值
没有其余的开销
智能指针
智能指针是这样的一些数据结构：
行为和指针相似
有额外的元数据和功能
引用计数（reference counting）智能指针类型
通过记录所有者的数量，使一份数据被多个所有者同时持有
并在没有任何所有者时自动清理数据
引用和智能指针的其他不同
引用：只借用数据
智能指针：很多时候都拥有它所指向的数据
智能指针的例子
String和Vec<T>
都拥有一片内存区域，且允许用户对其操作
还拥有元数据（例如容量等）
提供额外的功能或保障（String保障其数据是合法的UTF-8编码）
智能指针的实现
智能指针通常使用struct实现，并且实现了：
Deref和Drop这两个trait
Deref trait：允许智能指针struct的实例像引用一样使用
Drop trait：允许你自定义当智能指针实例走出作用域时的代码
使用Box指向Heap上的数据
使用Box<T>来指向Heap（堆内存）上的数据
Box<T>
Box<T>是最简单的智能指针：
允许你在heap上存储数据（而不是stack）
stack上是指向heap数据的指针
没有性能开销
没有其他额外的功能
实现了Deref trait和Drop trait
Box<T>的常用场景
在编译时，某类型的大小无法确定。但使用该类型时，上下文却需要知道它的确切大小。
当你有大量数据，想移交所有权，但需要确保在操作时数据不会被复制。
使用某个值时，你只关心它是否实现了特定的trait，而不是它的具体类型。
使用Box<T>在Heap上存储数据
fn main() {
let b = Box::new(5);
println!("b = {}", b);
}
使用Box 赋能递归类型
在编译时，Rust需要知道一个类型所占的空间大小。
而递归类型的大小无法在编译时确定
但Box类型大小确定
在递归类型中使用Box就可以解决上述问题
函数语言中的Cons list
关于Cons List
Cons List是来自Lisp语言的一种数据结构。
Cons List里每一个成员由两个元素组成。
当前项的值
下一个元素
Cons List里最后一个成员只包含一个Nil值（相当于终止的标记），没有下一个元素
Cons List并不是Rust的常用集合
通常情况下，Vec<T>是更好的选择
创建一个Cons List
Try:
use crate::List::{ Cons, Nil };
fn main() {
let list = Cons(1, Cons(2, Cons(3, Nil)));
}
enum List {
Cons(i32, List),
Nil,
}
Rust如何确定为枚举分配的空间大小
enum Message {
Quit,
Move {x:i32, y:i32},
Write(String),
ChangeColor(i32, i32, i32),
}使用Box来获得确定大小的递归类型
Box<T>是一个指针，Rust知道它需要多少空间，因为：
指针的大小不会基于它指向的数据的大小变化而变化。
use crate::List::{ Cons, Nil };
fn main() {
let list = Cons(1,
Box::new(Cons(2,
Box::new(Cons(3,
Box::new(Nil))))));
}
enum List {
Cons(i32, Box<List>),
Nil,
}
Box<T>:
只提供了“间接”存储和heap内存分配的功能
没有其他额外功能
没有性能开销
适用于需要“间接”存储的场景，例如Cons List
实现了Deref trait和Drop trait
（如果rust结构体包含自身的时候最好用引用是吗？如果必须拥有成员的所有权就得使用box这种？）
Deref Trait
实现Deref Trait使我们可以自定义解引用运算符*的行为。
通过实现Deref，智能指针可像常规引用一样来处理
解引用运算符
常规引用是一种指针
fn main() {
let x = 5;
let y = &x;
assert_eq!(5, x);
assert_eq!(5, *y); // *是解引用符号
}把Box<T>当做引用
Box<T>可以替代上例中的引用
fn main() {
let x = 5;
let y = Box::new(x);
assert_eq!(5, x);
assert_eq!(5, *y); // *是解引用符号
}定义自己的智能指针
Box<T>被定义成拥有一个元素的tuple struct
（例子）MyBox<T>
实现Deref Trait
标准库中的Deref trait要求我们实现一个deref方法：
该方法借用self
返回一个指向内部数据的引用
use std::ops::Deref;
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
impl<T> Deref for MyBox<T> {
type Target = T; // 定义了Deref这个trait的关联类型
fn deref(&self) -> &T {
&self.0
}
}
fn main() {
let x = 5;
let y = MyBox::new(x);
// let y = Box::new(x);
assert_eq!(5, x);
assert_eq!(5, *y); // *是解引用符号
// *(y.deref())
}（Deref本质是引用的转换，把自身的引用转换成内部数据的引用。）
函数和方法的隐式解引用转化（Deref Coercion）
隐式解引用转化（Deref Coercion）是为函数和方法提供的一种便捷特性
假设T实现了Deref Trait：
Deref Coercion可以把T的引用转化为T经过Deref操作后生成的引用
当把某类型的引用传递给函数或方法时，但它的类型与定义的参数类型不匹配：
Deref Coercion就会自动发生
编译器会对deref进行一系列调用，来把它转化为所需的参数类型
在编译时完成，没有额外性能开销
use std::ops::Deref;
fn hello(name: &str) {
println!("Hello, {}", name);
}
fn main() {
let m = MyBox::new(String::from("Rust"));
// &m &MyBox<String>
// deref &String
// deref &str
hello(&m);
// hello(&(*m)[ .. ]);
}
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
impl<T> Deref for MyBox<T> {
type Target = T; // 定义了Deref这个trait的关联类型
fn deref(&self) -> &T {
&self.0
}
}
解引用与可变性
可使用DerefMut trait重载可变引用的*运算符
在类型和trait在下列三种情况发生时，Rust会执行deref coercion：
Drop Trait
实现Drop Trait，可以让我们自定义当值将要离开作用域时发生的动作
例如：文件、网络资源释放等
任何类型都可以实现Drop Trait
Drop trait只要求你实现drop方法
参数：对self的可变引用
Drop trait在预导入模块里（prelude）
struct CustomSmartPointer {
data: String,
}
impl Drop for CustomSmartPointer {
fn drop(&mut self) {
println!(
"Dropping CustomSmartPointer with data `{}`!",
self.data
);
}
}
fn main() {
let c = CustomSmartPointer { data: String::from("my stuff") };
let d = CustomSmartPointer { data: String::from("other stuff") };
println!("CustomSmartPointers created.");
}
使用std::mem::drop来提前drop值
很难直接禁用自动的drop功能，也没必要
Drop trait的目的就是进行自动的释放处理逻辑
Rust不允许手动调用Drop trait的drop方法
但可以使用标准库的std::mem::drop函数，来提前drop值
Rc<T>：引用计数智能指针
Rc<T>：引用计数智能指针
有时，一个值会有多个所有者
为了支持多重所有权：Re<T>
reference counting（引用计数）
追踪所有值得引用
0个引用：该值可以被清理掉
Re<T>使用场景
需要在heap上分配数据，这些数据被程序的多个部分读取（只读），但在编译时无法确定那个部分最后使用完这些数据
Re<T>只能用于单线程场景
例子
Re<T>不在预导入模块（prelude）
Re::clone(&a)函数：增加引用计数
Re::strong_count(&a)：获得引用计数
还有Re::weak_count函数
例子
两个List共享另一个List所有权
use crate::List::{Cons, Nil};
use std::rc::Rc;
enum List {
Cons(i32, Rc<List>),
Nil
}
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10,
Rc::new(Nil)))));
let b = Cons(3, Rc::clone(&a));
let c = Cons(4, Rc::clone(&a));
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
enum List {
Cons(i32, Rc<List>),
Nil
}
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10,
Rc::new(Nil)))));
println!("count after creating a = {}", Rc::strong_count(&a));
let b = Cons(3, Rc::clone(&a));
println!("count after creating b = {}", Rc::strong_count(&a));
{
let c = Cons(4, Rc::clone(&a));
println!("count after creating c = {}", Rc::strong_count(&a));
}
println!("count after c goes out of scope = {}",
Rc::strong_count(&a));
}
Rc<T>
Rc<T>通过不可变引用，使你可以在程序不同部分之间共享只读数据
RefCell<T>和内部可变性
内部可变性
内部可变性时Rust的设计模式之一
它允许你在支持有不可变引用的前提下对数据进行修改
数据结构中使用了unsafe代码来绕过rust正常的可变性和借用规则
RefCell<T>
与Re<T>不同，RefCell<T>类型代表了其持有数据的唯一所有权
RefCell<T>与Box<T>的区别
借用规则在不同阶段进行检查的比较
RefCell<T>也只能用于单线程场景
选择Box<T>, Rc<T>,RefCell<T>的依据
内部可变性：可变的借用一个不可变的值
使用RefCell<T>在运行时记录借用信息
两个方法（安全接口）
borrow方法
返回智能指针Ref<T>，它实现了Deref
borrow_mut方法
返回智能指针RefMut<T>，它实现了Deref
将Rc<T>和RefCell<T>结合使用来实现一个拥有多重所有权的可变数据
#[derive(Debug)]
enum List {
Cons(Rc<RefCell<i32>>, Rc<List>),
Nil,
}
use crate::List::{ Cons, Nil };
use std::rc::Rc;
use std::cell::RefCell;
fn main() {
let value = Rc::new(RefCell::new(5));
let a = Rc::new(Cons(Rc::clone(&value),
Rc::new(Nil)));
let b = Cons(Rc::new(RefCell::new(6)),
Rc::clone(&a));
let c = Cons(Rc::new(RefCell::new(10)),
Rc::clone(&a));
*value.borrow_mut() += 10;
println!("a after = {:?}", a);
println!("b after = {:?}", b);
println!("c after = {:?}", c);
}
其他可实现内部可变性的类型
Cell<T>：通过复制来访问数据
Mutex<T>：用于实现跨线程情形下的内部可变性模式
循环引用可导致内存泄漏
Rust可能发生内存泄漏
Rust的内存安全机制可以保证很难发生内存泄漏，但不是不可能
例如使用Re<T>和RefCell<T>就可能创造出循环引用，从而发生内存泄漏：
每个项的引用数量不会变成0，值也不会被处理掉。
例子：
防止内存泄漏的解决办法
依靠开发者来保证，不能依靠Rust
重组数据结构：一些引用来表达所有权，一些引用不表达所有权
循环引用中的一部分具有所有权关系，另一部分不涉及所有权关系
而只有所有权关系才影响值得清理
防止循环引用：把Rc<T>换成Weak<T>
Rc::clone为Rc<T>实例的strong_count加1，Rc<T>的实例只有在strong_count为0的时候才会被清理
Rc<T>实例通过调用Rc::downgrade方法可以创建值得Weak Reference（弱引用）
返回类型Weak<T>（智能指针）
调用Rc::downgrade会为weak_count加1
Rc<T>使用weak_count来追踪存在多少Weak<T>
weak_count不为0并不影响Rc<T>实例的清理
Strong Vs Weak
总结
接着奏乐接着舞。
所谓成长，不过是用时间慢慢擦亮你的眼睛，少时看重的，年长后却视若鸿毛，少时看轻的，年长后却视若泰山，成长之路，亦是渐渐放下执念，内心归于平静的旅程。也许，我们永远都不会知道自己走向何方，遇见何人，最后会变成什么样的人，但请一定要记住，能让自己登高的，永远不是别人的肩膀。人生的道路刚刚启程，接下来的旅程全由你自己选择，而当你累了倦了也不要迷茫，回头看一看，家里的大门永远为你敞开。
--萧炎之父萧战
1806
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
