Rust全部权语义模型

　　编程语言的内存管理，大概能够分为自动和手动两种。

　　自动管理就是用 GC(垃圾回收)来自动管理内存，像 Java、Ruby、Golang、Elixir 等语言都依赖于 GC。而 C/C++ 倒是依赖于手工管理内存，程序员使用 malloc 和 free 函数来分配释放内存。

　　GC技术通过这么多年的发展，是相对安全的内存管理，也解放了程序员，可是在一些系统级编程领域，其实是须要避免 GC，由于 GC 会引发“世界暂停”，这将带来性能问题，因此在系统级编程领域C/C++占绝对的霸主地位。

　　可是，有C/C++就够了吗?靠手工来管理内存，会带来不少安全问题，好比悬垂指针，诚然有最佳实践引导，就算经验丰富的熟手也难以免相似内存安全的错误。

　　Rust 的出现，就是为了解决这个痛点，它强大的全部权系统，就像是黑暗中的明灯。

　　我曾经也对其感到疑虑，这凭空产生的 Rust 的全部权系统是否是拍脑壳发明的，这真的是解决内存安全问题的“银弹”吗?

　　其实历史上也曾经有过解决内存安全问题的努力，好比 Cyclone 语言，它是一门对 C 语言进行安全升级的语言，基于区域(region，有点和 Rust 全部权系统中的生命周期相相似)的内存管理，避免一些潜在的内存安全问题，可是，功能极其有限，相似的尝试还有ML Kit。

　　就是这些早期的方案，给了Rust语言灵感，才造就如今的全部权系统，因此Rust的全部权系统并不是凭空产生。至因而不是“银弹”，还不敢下结论，至少，Rust的全部权系统是迄今为止最精妙最科学的方案了。

　　语义模型

　　什么叫语义模型?语义，顾名思义，是指语言的含义。咱们在学习一个新概念的时候，首先就要搞明白它的语义。而语义模型，是指语义构建的心智模型，由于概念点不是孤立存在的，彼此之间必然有紧密的联系，咱们经过挖掘其语义之间的关联规则，在你的认知中造成一颗“语义树”，这样的理解才是通透的。全部权的“语义树”，以下图所示：

　　上图中的语义树，主要是想表达下面几层意思：

　　● 全部权是有好多个概念系统性组成的一个总体概念。

　　● let绑定，绑定了什么?变量 + 做用域 + 数据(内存)。

　　● move、lifetime、RAII都是和做用域相关的，因此想理解它们就先要理解做用域。

　　全部权

　　全部权，顾名思义，至少应该包含两个对象：“全部者”和“全部物”。在Rust中，“全部者”就是变量，“全部物”是数据，抽象来讲，就是指某一片内存。let关键字，容许你绑定“全部者”和“全部物”，好比下面代码：

　　let num = String::from("42");

　　let 关键字，让 num 绑定了42，那么能够说，num拥有42的全部权。但这个全部权，是有范围限制的，这个范围就是做用域(scope)，准确来讲是拥有域(owner scope)。换句话说，num在当前做用域下，拥有42的全部权。若是它要进入别的做用域，就必须交出全部权。好比下面的代码：

　　let num = String::from("42");

　　let num2 = num;

　　let关键字会开启一个隐藏做用域，咱们能够借助于MIR来查看，编译这两行代码，查看其MIR：

　　scope 1 {

　　let _1: std::string::String; // "num" in scope 1 at :4:8: 4:11

　　scope 2 {

　　let _2: std::string::String; // "num2" in scope 2 at :5:8: 5:12

　　}

　　}

　　Scope 1就是num所在的做用域，scope 2是num2所在的做用域。当你此时想像下面这样使用num的时候：

　　let num = String::from("42");let num2 = num;println!("{:?}", num);

　　编译器会报错：error[E0382]: use of moved value: `num`。由于num变量的全部权已经转移了。

　　移动(move)语义

　　移动，是指全部权的转移。何时全部权会转移呢?就是当变量切换做用域的时候，所谓移动，固然是从一个地方挪到另外一个地方。其实你也能够这样认为，当变量切换到另外一个做用域，它在当前做用域的绑定将会失效，它拥有的数据则会在另外一个做用域被从新绑定。

　　可是对于实现了Copy Trait的类型来讲，当移动发生的时候，它们能够Copy的副本代替本身去移动，而自身还保留着全部权。好比，Rust中的基本数字类型都默认实现了Copy Trait，好比下面示例：

　　let num = 42;

　　let num2 = num;

　　println!("{:?}", num);

　　此时，咱们打印num，编译器不会报错。num已经move了，可是由于数字类型是默认实现Copy Trait，因此它move的是自身的副本，其全部权还在，并未发生转移，经过编译。不过须要注意的是，Rust 不容许自身或其任何部分实现了Drop trait 的类型使用Copy trait。

　　当move发生的时候，全部权被转移的变量，将会被释放。

　　做用域(Scope)

　　没有GC帮助咱们自动管理内存，咱们只能依赖全部权这套规则来手工管理内存，这就增长了咱们的心智负担。而全部权的这套规则，是依赖于做用域的，因此咱们须要对Rust中的做用域有必定了解。

　　咱们在以前的描述中已经见过了隐式做用域，也就是在当前做用域中由let开启的做用域。在Rust中，也有一些特殊的宏，好比println!()，也会产生一个默认的scope，而且会隐式借用变量。除此以外，更明显的做用域 范围则是函数，也就是说，一个函数自己，就是一个显式的做用域。你也可使用一对花括号({})来建立显式的做用域。

　　除此以外，一个函数自己就显式的开辟了一个独立的做用域。好比：

　　fn sum(a: u32, b: u32) -> u32 {

　　a + b

　　}

　　fn main(){

　　let a = 1;

　　let b = 2;

　　sum(a, b);

　　}

　　上面的代码中，当调用sum函数的时候，a和b看成参数传递过去，此时就会发生全部权move的行为，可是由于a和b都是基本数据类型，实现了Copy Trait，因此它们的全部权没有被转移。若是换了是没有实现Copy Trait的变量，全部权就会被转移。

　　做用域在Rust中的做用就是制造一个边界，这个边界是全部权的边界。变量走出其所在做用域，全部权会move。若是不想让全部权move，则可使用“引用”来“出借”变量，而此时做用域的做用就是保证被“借用”的变量准确归还。

　　引用和借用

　　有的时候，咱们并不想让变量的全部权转移，好比，我写一个函数，该函数只是给某个数组插入一个固定的值：

　　fn push(vec: &mut Vec) {

　　vec.push(1);

　　}

　　fn main(){

　　let mut vec = vec![0, 1, 3, 5];

　　push(&mut vec);

　　println!("{:?}", vec);

　　}

　　此时，咱们把数组vec传给push函数，就不但愿把全部权转移，因此，只须要传入一个可变引用&mut vec，由于咱们须要修改vec，这样push函数就得了vec变量的可变借用，让咱们去修改。push函数修改完，会将借用的全部权归还给vec，而后println!函数就能够顺利使用vec来输出打印。

　　引用很是方便咱们使用，可是若是滥用的话，会引发安全问题，好比悬垂指针。看下面示例：

　　let r;

　　{

　　let a = 1;

　　r = &a;

　　}

　　println!("{}", r);

　　上面代码中，当a离开做用域的时候会被释放，但此时r还持有一个a的借用，编译器中的借用检查器就会告诉你：`a` does not live long enough。翻译过来就是：`a`活的不够久。这表明着a的生命周期过短，而没法借用给r，不然&a就指向了一个曾经存在但如今已再也不存在的对象，这就是悬垂指针，也有人将其称为野指针。

　　生命周期

　　上面的示例中，是在同一个函数做用域下，编译器能够识别出生命周期的问题，可是当咱们在函数之间传递引用的时候，编译器就很难自动识别出这些问题了，因此Rust要求咱们为这些引用显式的指定生命周期标记，若是你不指定生命周期标记，那么编译器将会“鞭策”你。

　　struct Foo {

　　x: &i32,

　　}

　　fn main() {

　　let y = &5;

　　let f = Foo { x: y };

　　println!("{}", f.x);

　　}无锡妇科医院哪家好 http://www.wxbhnkyy39.com/

　　上面这段代码，编译器会提示你：missing lifetime specifier。这是由于，y这个借用被传递到了 let f = Foo { x: y }所在做用域中。因此须要确保借用y活得比Foo结构体实例长才行，不然，若是借用y被提早释放，Foo结构体实例就会形成悬垂指针了。因此咱们须要为其增长生命周期标记：

　　struct Foo<'a> {

　　x: &'a i32,

　　}

　　fn main() {

　　let y = &5;

　　let f = Foo { x: y };

　　println!("{}", f.x);

　　}

　　加上生命周期标记之后，编译器中的借用检查器就会帮助咱们自动比对参数变量的做用域长度，从而确保内存安全。

　　再来看一个例子：

　　fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {

　　if x.len() > y.len() {

　　x

　　} else {

　　y

　　}

　　}

　　fn main() {

　　let a = "hello";

　　let result;

　　{

　　let b = String::from("world");

　　result = longest(a, b.as_str());

　　}

　　println!("The longest string is {}", result);

　　}

　　此段代码，编译器会报错：`b` does not live long enough。这是由于result在外部做用域定义的，result的生命周期是和main函数同样长的，也就是说，在main函数做用域结束以前，result都必须存活。而此时，变量b在花括号定义的做用域中，出了做用域b就会被释放。而根据longest函数签名中的生命周期标注，参数b的生命周期必须和返回值的生命周期一致，因此，借用检查器果断的判断出`b` does not live long enough。

　　“显式的指定”，这是Rust的设计哲学之一。这对于新手，尤为是习惯了动态语言的人来讲，多是一个心智负担。显式的指定方便了编译器，可是对于程序员来讲略显繁琐。不过为了安全考虑，咱们就欣然接受这套规则吧。

　　首发于知乎专栏