Rust语言学习笔记（7）

Box<T>

Box<T> 是一个独占资源的智能指针

let b = Box::new(5);
println!("b = {}", b);
// 递归类型
enum List {
    Cons(i32, Box<List>),
    Nil,
}
use List::{Cons, Nil};
let list = Cons(1,
    Box::new(Cons(2,
        Box::new(Cons(3,
            Box::new(Nil))))));
// Box<T>和引用类型一样支持解引用
// 原因是实现了 Deref 特质
let x = 5;
let y = &x;
let z = Box::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
assert_eq!(5, *z);

Deref 特质

// 自定义类型实现 Deref 特质
struct MyBox<T>(T);
impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}
use std::ops::Deref;
impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.0
    }
}
let x = 5;
let y = MyBox::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);

强制解引用（Deref coercion）

fn hello(name: &str) {
    println!("Hello, {}!", name);
}
let m = MyBox::new(String::from("Rust"));
hello(&m); // hello(&(*m)[..]);

强制解引用的条件：

• 当 T: Deref<Target=U> 时从 &T 到 &U。
• 当 T: DerefMut<Target=U> 时从 &mut T 到 &mut U。
• 当 T: Deref<Target=U> 时从 &mut T 到 &U。

Drop 特质

// 自定义类型实现 Drop 特质
struct CustomSmartPointer {
    data: String,
}
impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}
let c = CustomSmartPointer { data: String::from("my stuff") };
let d = CustomSmartPointer { data: String::from("other stuff") };
println!("CustomSmartPointers created.");
/*
CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!
*/
let c = CustomSmartPointer { data: String::from("some data") };
println!("CustomSmartPointer created.");
drop(c);
println!("CustomSmartPointer dropped before the end of main.");
/*
CustomSmartPointer created.
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main.
*/

Rc<T>

Rc<T> 是一个带引用计数器的智能指针

enum List {
    Cons(i32, Rc<List>),
    Nil,
}
use self::List::{Cons, Nil};
use std::rc::Rc;
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
println!("count after creating a = {}", Rc::strong_count(&a)); // strong_count == 1
let b = Cons(3, Rc::clone(&a));
println!("count after creating b = {}", Rc::strong_count(&a)); // strong_count == 2
{
    let c = Cons(4, Rc::clone(&a));
    println!("count after creating c = {}", Rc::strong_count(&a)); // strong_count == 3
}
println!("count after c goes out of scope = {}", Rc::strong_count(&a)); // strong_count == 2

Cell<T>

Cell<T> 在运行期改变内部的值

let x = Cell::new(1);
let y = &x;
let z = &x;
x.set(2);
y.set(3);
z.set(4);
println!("{}", x.get());
// 相当于以下代码的效果（编译会出错）
let mut x = 1;
let y = &mut x;
let z = &mut x;
x = 2;
*y = 3;
*z = 4;
println!("{}", x);

RefCell<T>

RefCell<T> 在运行期实施借用原则

// 可以有多个不变借用
let a = RefCell::new(15);
let b = a.borrow();
let c = a.borrow();
println!("Value of b is : {}",b);
println!("Value of c is : {}",c);
// 不能同时有不变借用和可变借用
let a = RefCell::new(10);
let b = a.borrow();
let c = a.borrow_mut(); // cause panic.
// 可以有一个可变借用
let a = RefCell::new(15);
let b = a.borrow_mut();
println!("Now, value of b is {}",b);
// 不能有多个可变借用
let a = RefCell::new(15);
let b = a.borrow_mut();
let c = a.borrow_mut(); // cause panic.

链接

Wrapper Types in Rust: Choosing Your Guarantees

Rust Smart Pointers

Rust by Example

Rust Cookbook