Rust学习实践（四） -- Rust特性：智能指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
fn test_simple() {
    // 创建一个智能指针指向了存储在堆上的 3，并且 a 持有了该指针
    {
        let a = Box::new(3);
        // 智能指针实现了Deref 和 Drop特征，此处会隐式调用Deref特征，对指针进行解引用
        println!("a = {}", a); // a = 3

        // 下面一行代码将报错，表达式无法隐式调用Deref特征解引用
        // let b = a + 1; // cannot add `{integer}` to `Box<{integer}>`
        // 因此需要显式使用`*`，调用Deref特征解引用
        let b = *a + 1;
    }

    // 作用域结束，上面的智能指针就被释放了，因为Box实现了Drop特征
    // 下面使用会报错：cannot find value `a` in this scope
    // let c = *a + 2;
}

fn test_array() {
    // 在栈上创建一个长度为1000的数组
    let arr = [0;1000];
    // 将arr所有权转移arr1，由于 `arr` 分配在栈上，因此这里实际上是直接重新深拷贝了一份数据
    let arr1 = arr;

    // arr 和 arr1 都拥有各自的栈上数组，因此不会报错
    println!("{:?}", arr.len());
    println!("{:?}", arr1.len());

    // 在堆上创建一个长度为1000的数组，然后使用一个智能指针指向它
    let arr = Box::new([0;1000]);
    // 将堆上数组的所有权转移给 arr1，由于数据在堆上，因此仅仅拷贝了智能指针的结构体，底层数据并没有被拷贝
    // 所有权顺利转移给 arr1，arr 不再拥有所有权
    let arr1 = arr;
    println!("{:?}", arr1.len());
    // 由于 arr 不再拥有底层数组的所有权，因此下面代码将报错
    // println!("{:?}", arr.len());
}

fn test_box_arr() {
    let arr = vec![Box::new(1), Box::new(2)];
    // 使用 & 借用数组中的元素，否则会报所有权错误
    let (first, second) = (&arr[0], &arr[1]);
    // 表达式不能隐式的解引用，因此必须使用 ** 做两次解引用，
    // 第一次将 &Box<i32> 类型转成 Box<i32>，第二次将 Box<i32> 转成 i32
    let sum = **first + **second;
}

1
2
3
4
5
6
7
8
9
10
11
12
fn main() {
   let s = gen_static_str();
   println!("{}", s);
}

fn gen_static_str() -> &'static str{
    let mut s = String::new();
    s.push_str("hello, world");

    // 原来的 String 被消费掉，但是它的内容被转移到了堆上，并且被标记为 'static，返回了不可变的引用
    Box::leak(s.into_boxed_str())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
use std::ops::Deref;

// newtype MyBox<T>，定义一个结构体，其中包含一个泛型 T
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

// 为智能指针实现 Deref 特征
impl<T> Deref for MyBox<T> {
    // 类型别名（关联类型 Target，主要用于提升代码可读性）
    type Target = T;

    // 当解引用 MyBox 智能指针时，返回元组结构体中的元素 &self.0
    fn deref(&self) -> &Self::Target {
        // 返回的是一个常规引用，可以被 * 进行解引用
        &self.0
    }
}

fn test_deref() {
    let x = 5;
    let y = MyBox::new(x);

    println!("x = {}, y = {}", x, *y);
}

1
2
3
4
5
6
7
8
9
10
11
// 隐式 Deref
fn test_auto_deref() {
    // String 实现了 Deref 特征，可以在需要时自动被转换为 &str 类型
    let s = String::from("hello world");
    // &s 是一个 &String 类型，当它被传给 display 函数时，自动通过 Deref 转换成了 &str
    display(&s)
}

fn display(s: &str) {
    println!("{}", s);
}

1
2
3
4
5
6
7
8
9
10
11
struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Dropping Foo!")
    }
}
fn test_drop() {
    let _foo = Foo;
    println!("Running!");
}

1
2
3
4
5
6
7
8
9
10
11
fn test_mem_drop() {
    let mut foo = Foo;

    // 报错：explicit destructor calls not allowed
    // foo.drop();

    // 调用编译器自动生成的drop函数，释放内存
    drop(foo);
    // 以下代码会报错：借用了所有权被转移的值
    // println!("Running!:{:?}", foo);
}

1
2
3
4
5
6
7
8
9
// 编译报错：error[E0184]: the trait `Copy` cannot be implemented for this type; the type has a destructor
#[derive(Copy)]
struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Dropping Foo!")
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
use std::rc::Rc;
fn rc_ptr() {
    let s = String::from("hello, world");
    // 使用Rc类型，Rc::new 创建一个引用计数类型的智能指针
    // 智能指针 Rc<T> 在创建时，引用计数会加1，可通过关联函数 Rc::strong_count(&a) 获取引用计数
    let a = Rc::new(s);
    println!("a referce count1: {}", Rc::strong_count(&a));
    
    // 用 Rc::clone 克隆了一份智能指针，引用计数也会加1
    // 此处clone不是深拷贝，仅仅复制了智能指针并增加了引用计数，并没有克隆底层数据
    let b = Rc::clone(&a);
    println!("a referce count2: {}", Rc::strong_count(&a));
    println!("b referce count: {}", Rc::strong_count(&b));

    // 使用 Arc::new 创建智能指针
    use std::sync::Arc;
    let s1 = Arc::new(String::from("test arc"));
    // 可通过 *s1 解引用获取值
    println!("s1 referce count: {}, *s1:{}", Arc::strong_count(&s1), *s1);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
use std::cell::Cell;
fn cell_ptr() {
    // 此处的"asdf"是&str类型，实现了Copy
    let c = Cell::new("asdf");

    // String 没有实现 Copy 特征，所以Cell中不能存放String类型
    // let c2 = Cell::new(String::from("asdf"));
    // 编译报错：error[E0599]: the method `get` exists for struct `Cell<String>`, but its trait bounds were not satisfied
        // doesn't satisfy `String: Copy`
    // println!("c2:{}", c2.get());

    // 获取当前值，不是实时指针，后面修改不影响此处
    let one = c.get();
    // 获取值到one里后，通过c还能做修改，修改c不影响one的值
    c.set("qwer");
    let two = c.get();
    // 结果：one:asdf, two:qwer, c.get():qwer
    println!("one:{}, two:{}, c.get():{}", one, two, c.get());
    // 不可通过 *c 解引用获取值
    // println!("*c:{}", *c);
}

1
2
3
4
5
6
7
8
9
use std::cell::RefCell;
fn refcell_ptr() {
    let s = RefCell::new(String::from("hello, world"));
    let s1 = s.borrow();
    // 编译器不会报错，但违背了借用规则，会导致运行期 panic
    let s2 = s.borrow_mut();

    println!("{},{}", s1, s2);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
use std::cell::RefCell;
use std::rc::Rc;
fn rc_refcell() {
    // 用 RefCell<String> 包裹一个字符串，并通过 Rc 创建了它的三个所有者
    let s = Rc::new(RefCell::new("hello world".to_string()));

    let s1 = s.clone();
    let s2 = s.clone();
    // 通过其中一个所有者 s2 对字符串内容进行修改
    s2.borrow_mut().push_str(", xxxxx!");

    // let mut s2 = s.borrow_mut();
    // s2.push_str("xxxxx");

    // 打印结果如下：三者共享同一个底层数据，都发生了变化
    // RefCell { value: "hello world, xxxxx!" }
    // RefCell { value: "hello world, xxxxx!" }
    // RefCell { value: "hello world, xxxxx!" }
    println!("{:?}\n{:?}\n{:?}", s, s1, s2);
}