CodingRust基本语法
Source
Edit
History

所有权 ownership 和 借用

所有权规则

  1. Each value in Rust has an owner .
    • 一个值只允许有一个 owner
    • 预防bug 二次释放（double free）
  2. There can only be one owner at a time.
    • 一个值只能拥有一个所有者
  3. When the owner goes out of scope, the value will be dropped.
    • 离开范围被 丢弃(drop)

浅拷贝 和 深拷贝

默认所有都是浅拷贝

深拷贝操作：

1
2
let s1 = String::from("hello");
let s2 = s1.clone();

数据直接存储在 栈 中，叫 Copy 特征，

不可变引用 &T 可Copy

函数传值与返回的所有权

  • 参数传入函数调用内后，所有权也被移出当前作用域
  • 函数内变量移出作用域。
    • 顺序：后进先出；
    • 堆释放内存：调用 drop 方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动到函数里 ...
                                    // ... 所以到这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 应该移动函数里，
                                    // 但 i32 是 Copy 的，所以在后面可继续使用 x

} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
  // 所以不会有特殊操作

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 这里，some_integer 移出作用域。不会有特殊操作

返回值：

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
fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 移给 s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中,
                                        // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String {             // gives_ownership 将返回值移动给
                                             // 调用它的函数

    let some_string = String::from("hello"); // some_string 进入作用域.

    some_string                              // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

    a_string  // 返回 a_string 并移出给调用的函数
}

移出给调用的函数

引用(Ref)与解引用(Deref)

获取变量的引用，称之为借用(borrowing)

1
2
3
4
5
6
7
fn main() {
    let x = 5;
    let y = &x;

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

常规引用是一个指针类型

&x 获取引用

*y 解引用

自动 解引用(deref) 机制

Rust 有自动解引用机制

1
2
3
4
5
6
fn main() {
    let s = "hello";
    println!("length: {}", s.len());
    println!("length: {}", (&s).len());
    println!("length: {}", (&&&&&&&&&&&&&s).len());
}

Rust编译器帮我们做了隐式的 deref 调用，当它找不到这个成员方法的时候，它会自动尝试使用deref方法后再找该方法，一直循环下去。编译器在 &&&str 类型里面找不到len方法，就尝试将它deref，变成 &&str 类型，再寻找len方法，还是没找到，那么继续deref，变成 &str ，直到找到len方法，于是就调用这个方法。

以下写法在编译器看起来是一样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
use std::rc::Rc;
use std::ops::Deref;

fn main() {
    let s = Rc::new(String::from("hello"));

    println!("length: {}", s.len());
    println!("length: {}", s.deref().len());
    println!("length: {}", s.deref().deref().len());

    println!("length: {}", (*s).len());
    println!("length: {}", (&*s).len());
    println!("length: {}", (&**s).len());
}

当自动解引用发生冲突时，就需要手动解引用了

可变引用 与 不可变引用

默认的引用是不可变的，

可变引用： 

1
2
let mut s = String::from("hello");
let r1 = &mut s;
  • 需注意
    • 同一作用域，特定数据只能有一个可变引用
    • 可变引用与不可变引用不能同时存在

NLL 引用的作用域

引用的作用域 s 从创建开始，一直持续到它最后一次使用的地方，这个跟变量的作用域有所不同

1
2
3
4
5
6
7
8
9
10
11
12
fn main() {
   let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // 新编译器中，r1,r2作用域在这里结束

    let r3 = &mut s;
    println!("{}", r3);
} // 老编译器中，r1、r2、r3作用域在这里结束
  // 新编译器中，r3作用域在这里结束

这种编译器优化行为，Rust 专门起了一个名字 —— Non-Lexical Lifetimes(NLL) ：专门用于找到某个引用在作用域 } 结束前就不再被使用的代码位置。

悬垂引用(Dangling References)

指针指向某个值后，这个值被释放掉了，而指针仍然存

在 Rust 中，编译器可以确保数据不会在引用结束前被释放，要想释放数据，必须先停止其引用的使用。