所有权|zy's blog

所有权规则

Rust中的每一个值都有一个对应的变量作为它的所有者
在同一个时间段内，值有且仅有一个所有者
当所有者离开自己的作用域时，它持有的值就会被释放掉

变量作用域

作用域是一个对象在程序内有效的范围。假设有个变量let s = "hello"; 这里的s指向了一个字符串字面量，如下示例对变量s的作用域进行了说明：

fn main() {                     //由于变量s未被声明，所以在这里不可用
    let s = "hello";      // 从这里开始变量s开始有用
    // s相关操作    
}                               //作用域到此结束，s不可用

s进入作用域后变得有效
它会保持自己的有效性直到自己离开作用域

String类型

为了演示所有权相关的规则，我们使用string类型。与所有权有关的部分，同样适用于其他标准库中的数据类型或自己创建的其他复杂的数据类型。在上一段的示例中，我们使用了硬编码进程序的字符串值，但由于字符串字面量不可变并且我们无法在编码时确定字符串的值，所以我们使用String类型，这个类型会在堆上分配存储空间以处理未知大小的文本。可以调用from函数根据字符串字面量来创建一个string实例：`

let mut s = String::from("hello");
s.push_str(",world!"); // push_str()函数向s的尾部添加了一段字面量
println!("{}",s);// 这里会输出完整的hello,world!

内存与分配

因为字符串字面量作为硬编码的文本直接嵌入了最终的可执行文件，所以访问字符串字面量非常高效；但是我们无法将未知大小或在运行时会改变的文本统统作为字符串字面量。对于String类型，为了支持这些文本，需要在堆内分配一块编译时未知大小的空间，这就意味着：

我们使用的内存是操作系统运行时动态分配的
当使用完这些空间，我们需要归还这部分内容给操作系统

这里的第一步在String::from 时完成，这个函数与大多编程语言一样，由程序员发起堆内存的分配请求。但是，对不同的编程语言来说，第二部有不同的实现方法。在某些拥有垃圾回收机制(GC)的语言中,GC会代替程序员来记录并且清除不再使用的内存，对于没有GC的语言来说，则由程序员来这些工作，但是正确完成这些任务往往十分复杂。如果未释放内存，就会造成内存泄露；如果过早释放，就会形成非法变量；如果重复释放同一空间，则会发生无法预见的后果。所以我们要严格将分配和释放操作严格对应。

在rust中，内存会自动的在拥有它的变量离开作用域后进行释放。如变量的作用域中的内容所示，有一个很适合回收内存的地方，就是s离开作用域的地方。rust在变量离开作用域的时候会调用一个名为drop的特殊函数。String类型的作者可以在这个函数中编写释放内存的代码。rust会在作用域结束即}处自动调用drop函数。

变量和数据的交互

移动

// 例1
let x = 5;
let y = x;

如示例1所示两个值5都会被推入栈中。

// 例2
let s1 = String::from("hello");
let s2 = s1;

示例2和示例1的代码非常相似，但是示例二并不是简单的拷贝。

图1 s1内存布局

len字段被用于记录当前String中的文本使用了多少字节的内存。capacity则用来记录String总共获取的内存字节数。图片左侧的这部分存储在栈中。图片有右侧显示了字符串存储于堆上的文本内容。当我们使用let s2 = s1; 时，我们复制了一次String的数据，即我们复制了它存储于栈上的内容也就是图1左侧的内容，如下图2所示：

图2 s2复制后，s1与s2内存布局

由于rust复制时不会深度复制堆上的内容，所以布局并不会像图3这样，因为如果堆上的数据过大，这样的复制方式会造成巨大的性能消耗。

图3 同时复制堆数据

在上面的所有权规则中提到过：当所有者离开自己的作用域时，它持有的值就会被释放。但图2中展示的内存布局中有两个指针指向了相同的地址，这就导致当s2和s1离开自己的作用域时，会释放重复的内存，这就会导致内存二次释放的问题，这个问题可能造成正在使用的数据发生损坏，引发其他问题。为了确保内存安全，避免复制分配的内存，rust在这种场景下将s1废弃，不作为一个有效变量。当我们尝试编译示例2的代码时，会有如下输出：

error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:4:19
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 |     println!("{}",s1);
  |                   ^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let s2 = s1.clone();
  |                ++++++++

这涉及到浅度拷贝（shallow copy）与深度拷贝（deep copy）这两个术语，我们会将这里复制指针、长度、及容量字段的行为视为浅度拷贝。但是在rust中，会将第一个变量视为无效，所以我们使用术语移动（move）来描述这个操作。在示例2中，我们可以说s1被移动到了s2。这一操作解决了释放内存的问题。同时，这里还涉及到rust另一个设计原则，rust不会自动创建数据的深度拷贝，所以所有的自动赋值操作都可以被视为高效的。

克隆

但是当我们确实需要深度拷贝String堆上的内容，我们可以使用clone方法，如下示例三所示。

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();
    println!("s1={},s2={}",s1,s2);
}

这段代码完实现上图3的操作。

栈上数据的复制

如上示例1所示的代码：

//示例1
fn main() {
    let x = 5;
    let y = x;
    println!("x = {}.y = {}",x,y);
}

这与上面的内容有些矛盾，这段代码并没有使用clone方法却能通过编译。这是因为类似于整形的类型可以在编译时确定自身大小，可以将数据完整的存入栈中，此时对这些数据的复制时快速的。所以，对于这些变量来说深度拷贝与浅度拷贝没有任何区别。

引用与借用

//例3
fn main(){
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
    s.len()
}

在示例3中，calculate_length函数使用了String的引用作为参数而没有直接转移所有权。let len = calculate_length(&s1); 中的&代表引用语义，它让函数在不获取所有权的前提下使用值。如下图4所示是这一过程的图解：

图4 &String指向String s1图解

解引用

与&相反的引用被成为解引用（dereferencing），使用*作为运算符。在后续的文章中会学习到。

函数调用过程

&s1在不转移所有权的情况下创建了指向s1的引用，当引用离开作用域时，s1的值不会被丢弃。

借用

这种通过引用来传递参数的方法也被成为借用（borrowing）

此时，我们尝试修改借用的值：

//例4
fn main(){
    let s1 = String::from("hello");
    change("&s1");
}

fn change(some_string:&String){
    some_string.push_str(",word");
}

编写代码如例4所示，此时代码无法通过编译，因为rust不允许对引用指向的值进行修改。

可变引用

修改一下例4的代码，将变量s1声明为可变变量。

//例5
fn main(){
    let mut s1 = String::from("hello");
    change(&mut s1);
}

fn change(some_string:&mut String){
    some_string.push_str(",word");
}

但是可变引用在使用上存在限制：在同一作用域下，一次只能声明一个可变引用；如下例子所示:

//例6
fn main(){
    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s;
    println!("{}, {}", r1, r2);
}

编译时报错如下：

warning: unused variable: `r1`
 --> 4_8.rs:3:9
  |
3 |     let r1 = &mut s;
  |         ^^ help: if this is intentional, prefix it with an underscore: `_r1`
  |
  = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `r2`
 --> 4_8.rs:4:9
  |
4 |     let r2 = &mut s;
  |         ^^ help: if this is intentional, prefix it with an underscore: `_r2`

warning: 2 warnings emitted

这个报错是因为第一个可变借用 r1 必须要持续到最后一次使用的位置 println!，在 r1 创建和最后一次使用之间，我们又尝试创建第二个可变借用 r2。这个规则使可变引用的使用收到严格的限制。但是遵守这条限制能帮我们避免数据竞争。

数据竞争

数据竞争（data race)会在指令满足以下三个条件时发生：

两个或更多的指针同时访问同一数据
至少有一个指针被用来写入数据
没有同步数据访问的机制

数据竞争会导致未定义行为，这种行为很可能超出我们的预期，难以在运行时追踪，并且难以诊断和修复。而 Rust 避免了这种情况的发生，因为它不会编译存在数据竞争的代码。

通过花括号创建多个可变引用

通常，我们可以使用花括号来创建一个新的作用域来创建多个可变引用。

//例7
let mut s = String::from("hello");

{
    let r1 = &mut s;

} // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用

let r2 = &mut s;

不可同时创建可变引用与不可变引用

//例8
let mut s = String::from("hello");

let r1 = &s; // 没问题
let r2 = &s; // 没问题
let r3 = &mut s; // 大问题

println!("{}, {}, and {}", r1, r2, r3);

报错如下：

error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> 4_9.rs:6:14
  |
4 |     let r1 = &s; // 没问题
  |              -- immutable borrow occurs here
5 |     let r2 = &s; // 没问题
6 |     let r3 = &mut s; // 大问题
  |              ^^^^^^ mutable borrow occurs here
7 |
8 |     println!("{}, {}, and {}", r1, r2, r3);
  |                                -- immutable borrow later used here

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0502`.

这是因为我们在不可变引用的同时创建了不可变引用。但是，存在多个不可变引用是合法的。

悬垂引用

在一个拥有指针的语言中，很容易会失误创建出悬垂指针。这类指针曾指向曾经引用过的某处内存，但是内存释放或是被分配作其他用途。在rust中，编译器会确保引用永远不会进入这种悬垂状态。下面，我们创建一个悬垂引用。

//例9
fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

在编译时，会出现如下错误：

... 
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
  |
5 | fn dangle() -> &'static String {
  |                ~~~~~~~~
...

错误信息中还有个新的概念，声明周期（lifetime），这个在后续的章节中会有介绍。现在回头看dangle()函数，在函数中，我们创建了一个变量s，函数想返回这个变量s的引用，但是在let s = String::from("hello"); 后，s离开作用域，内存被销毁，此是的&s 指向了一个无效的String ,现在我们修改代码如下：

//例10
fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

此时，我们直接返回了Strng，同时s的作用域转移至了调用者。

引用的规则

同一时刻，要么只拥有一个可变引用，要么只能拥有任意数量的不可变引用。
引用总是有效的

zy's blog

所有权

所有权规则

变量作用域

String类型

内存与分配

变量和数据的交互

移动

克隆

栈上数据的复制

引用与借用

解引用

函数调用过程

借用

可变引用

数据竞争

通过花括号创建多个可变引用

不可同时创建可变引用与不可变引用

悬垂引用

引用的规则

切片

flowersea

所有权规则

变量作用域

String类型

内存与分配

变量和数据的交互

移动

克隆

栈上数据的复制

引用与借用

解引用

函数调用过程

借用

可变引用

数据竞争

通过花括号创建多个可变引用

不可同时创建可变引用与不可变引用

悬垂引用

引用的规则

切片

RISC-V 汇编语言学习

Archlinux下rust的配置

flowersea