[易学易懂系列|rustlang语言|零基础|快速入门|（21）|智能指针]
[易学易懂系列|rustlang语言|零基础|快速入门|（21）|智能指针]
实用知识
智能指针
我们今天来讲讲Rust中的智能指针。
什么是指针？
在Rust，指针（普通指针），就是保存内存地址的值。这个值，指向堆heap的地址。
什么是智能指针？
在Rust,简单来说，相对普通指针，智能指针，除了保存内存地址外，还有额外的其他属性或元数据。
在Rust中，因为有所有权和借用的概念，所以引用和智能指针，又有一点不一样。
简单来说，智能指针，拥有数据所有权，而引用没有。
智能指针分以下几种：
1.Box
2.Rc
3.Ref RefMut
我们先来看看Box，来看看简单例子：
fn main() {
let b = Box::new(5);
println!("b = {}", b);
}
这段代码很简单，定义一个Box智能指针，把它绑定到变量b，b就是智能指针（在栈stack里），指向堆内存地址的数据（数据在堆heap里）。
结果打印：
b = 5
我们来看看一个复杂点的例子，我们想定义一个lisp语言中的cons list,这种类型，是个递归类型，
简单来说，它是一个封装数据的容器，如图所示：
我们来用Rust简单定义下这个数据结构，如下代码：
enum List {
Cons(i32, List),
Nil,
}
fn main() {
let list = Cons(1, Cons(2, Cons(3, Nil)));
}
用cargo run ，运行下，结果报错：
error[E0072]: recursive type `List` has infinite size
--> src\main.rs:5:1
|
5 | enum List {
| ^^^^^^^^^ recursive type has infinite size
6 | Cons(i32, List),
| ---- recursive without indirection
|
= help: insert indirection (e.g., a `Box`, `Rc`, or `&`) at some point to make `List` represxyentable
编译器报告说，这是一个递归类型，不确定长度，没办法初始化。
怎么办？
用Box，代码修改如下：
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let list = Cons(1,
Box::new(Cons(2,
Box::new(Cons(3,
Box::new(Nil))))));
}
现在一切正确。
现在的数据结构，对Rust来说是这样的，如下图所示：
Box类型因为实现了解引用特征Deref，所以它跟引用类型一样，同时，因为它实现了Drop特征，所以当它超出了作用域，它所占有的stack和heap空间会自动释放。
我们现在再来看看普通引用和智能指针的不同。
1.智能指针实现了Deref特征，所以它跟普通引用类似。
我们来看看例子：
fn main() {
let x = 5;
let y = &x;//y借用x,即y绑定到x的引用,y现在是个引用类型
assert_eq!(5, x);
assert_eq!(5, y);//error,错误，不能比较数据类型和引用类型
}
运行上面的代码，编译器报错：
error[E0277]: can't compare `{integer}` with `&{integer}`
--> src\main.rs:28:5
|
28 | assert_eq!(5, y);
| ^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}`
|
= help: the trait `std::cmp::PartialEq<&{integer}>` is not implemented for `{integer}`
怎么办？
用解引用操作符*。
我们来修改一下代码 ：
fn main() {
let x = 5;
let y = &x;
assert_eq!(5, x);
assert_eq!(5, *y);//用解引用操作符*，来取y指针指向的值
}
运行代码，一切正常。
这个解引用操作符*，就是用来取引用（指针）指向的值。
我们现在用Box类型来重写一下上面的代码：
fn main() {
let x = 5;
let y = Box::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
运行代码，一切正常。
说明 Box类型跟上面的普通引用（指针），是一样的效果。
它们唯一 的区别就是，一个是智能指针，一个是普通指针。
好理解。
现在我们再来看定义一个自己的智能指针，开始设计：
struct MyBox<T>(T);//tuple元组类型
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
然后，我们同样的方式来用这个自定义的智能指针：
fn main() {
let x = 5;
let y = MyBox::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
运行代码，报错了：
error[E0614]: type `MyBox<{integer}>` cannot be dereferenced
--> src/main.rs:14:19
|
14 | assert_eq!(5, *y);
| ^^
为什么？
因为，我们的MyBox没有实现特征Deref。
好，我们来实现Deref特征，代码更新如下：
fn main() {
let x = 5;
let y = MyBox::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
struct MyBox<T>(T);////tuple类型
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
use std::ops::Deref;
////必须实现Deref trait，否则不能使用*操作符
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T {
&self.0////tuple索引
}
}
运行代码，一切正常。
我们来分析一下代码：
type Target = T;语法是指定一个Deref特征的关联类型。
而这段代码：
fn deref(&self) -> &T {
&self.0////tuple索引
}
则实现解引用方法，这里直接返回元组tuple第一个索引。
当前我们也可以用官方标准写法：
use std::ops::Deref;
struct DerefExample<T> {
value: T,
}
impl<T> Deref for DerefExample<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.value
}
}
fn main() {
let x = DerefExample { value: 'a' };
assert_eq!('a', *x);
println!("{}", *x);
let y = DerefExample {
value: String::from("Good!"),
};
println!("{}", *y);
}
现在我们再看看把这个自定义智能指针作为传递参数：
fn hello(name: &str) {
println!("Hello, {}!", name);
}
我们先定义一个hello的方法，这个方法直接打印一条简单的问候信息。
我们看看怎么调用：
fn main() {
let m = MyBox::new(String::from("Rust"));
hello(&m);
}
完整代码如下：
use std::ops::Deref;
fn main() {
let m = MyBox::new(String::from("Rust"));
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;
fn deref(&self) -> &T {
&self.0
}
}
fn hello(name: &str) {
println!("Hello, {}!", name);
}
运行代码，打印结果信息：
Hello, Rust!
一切正常。
因为Rust实现了强制解引用机制（deref coercion），所以我们不用再用解引用操作符访问：
fn main() {
let m = MyBox::new(String::from("Rust"));
hello(&(*m)[..]);//解引用写法
}
我们再来看看特征Drop Trait
简单来说，特征Drop是用来标记相关变量超出作用域后释放资源。
在Rust所有智能指针都已经由编译器自动加入实现这个方法。
当然，我们也可以定制一下这个方法，我们来看看简单例子：
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.");
}//c,d在这里结束生命周期，这里Rust自动调用Drop实现方法
我们在main函数创建了两个实例c,d，在最后一个大括号时，结束这两个实例的“生命”，自动调用相关Drop实现方法，打印结果为：
CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!
在这里，Drop特征实现，有点类似于java的finalize方法，是一个对象或资源的临终遗言。
我们再来看看更复杂的智能指针，RC智能指针，也就是引用计数智能指针。
为什么要有引用计数智能指针呢？
因为有这样的情景，一个数据，可能有多个拥有者（当然这里的拥有者也就是线程）。这就是多所有权（multiple ownership）。
我们可以想象，这个多所有权，就像一台电视机，一个房间只有一台电视机，第一个人来了，打开电视机，第二个人，第三个人来了，就各加一个座位（这里就像引用加个计数器，每来一个人加1），有人离开了，就把座位拿开（计数器减1），直到最后一个人看完了电视，把电视关了。
如果，中间有人a离开，但还有其他人在看电视，这个a直接把电视机关了，结果肯定会引起喧嚣！！！！
我们回过头来看看之前提到过的cons list数据结构：
我现在用Box类型定义：
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let a = Cons(5,
Box::new(Cons(10,
Box::new(Nil))));
let b = Cons(3, Box::new(a));
let c = Cons(4, Box::new(a));
}
运行代码，编译错误：
error[E0382]: use of moved value: `a`
--> src/main.rs:13:30
|
12 | let b = Cons(3, Box::new(a));
| - value moved here
13 | let c = Cons(4, Box::new(a));
| ^ value used here after move
|
= note: move occurs because `a` has type `List`, which does not implement
the `Copy` trait
怎么办？
用RC类型，修改代码如下 ：
enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
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));
}
我们来看看引用计数智能指针的计数器，发生了什么，修改代码：
enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
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));
// println!("{}", c);
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))
}
运行代码，打印结果为：
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2
我们看到RC类型的引用计数器，是从1开始累加的。
中间c的生命周期结束了，就减一。
现在我们再来看看ReCell类型的智能指针。
我们从上面的例子可在看到 ，因为Rust默认的变量绑定是不可变的。
所以当我们要有一个变量，在运行时可变的。这时，就要用到ReCell类型。
看下面简单代码：
use std::cell::RefCell;
fn main() {
let c = RefCell::new(5);
*c.borrow_mut() = 7;
assert_eq!(*c.borrow(), 7);
}
我们可以让编译器通过，并且成功运行。
为什么？
我们再来看看另一个例子：
use std::cell::RefCell;
fn main() {
// let c = RefCell::new(5);
// *c.borrow_mut() = 7;
// assert_eq!(*c.borrow(), 7);
let x = RefCell::new(42);
let y = x.borrow_mut();
let z = x.borrow_mut();//每二次可变借用，已经违反了编译器的借用规则。但可以编译通过。
}
运行代码，编译通过。
我们看到两次可变借用已经违反了借用规则。
Rust的借用规则很简单：
同一时间，同一数据
1.允许一个或多个共享借用（不可变借用）
2.只允许一个可变借用。
上面的代码已经两个可变借用，但也可以通过。
ReCell主要 作用就是用于运行时来检查借用规则。这就是内部可变性的设计模式。
主要用途在哪里？
我们再来看看例子：
struct Point {
x: i32,
y: i32,
}
let mut a = Point { x: 5, y: 6 };
a.x = 10;
let b = Point { x: 5, y: 6 };
b.x = 10; // Error: cannot assign to immutable field `b.x`.错误
解决错误用Cell:
use std::cell::Cell;
struct Point {
x: i32,
y: Cell<i32>,
}
let point = Point { x: 5, y: Cell::new(6) };
point.y.set(7);
println!("y: {:?}", point.y);
以上，希望对你有用。
如果遇到什么问题，欢迎加入：rust新手群，在这里我可以提供一些简单的帮助，加微信：360369487，注明：博客园+rust
参考文章：
https://doc.rust-lang.org/stable/book/ch15-00-smart-pointers.html
https://stackoverflow.com/questions/30831037/situations-where-cell-or-refcell-is-the-best-choice
