Rust中的作用域及作用域的规则

所有权是 Rust 最独特的特性，它使 Rust 能够在不需要 GC 的情况下保证内存安全。在本章中，我们将讨论所有权以及几个相关特性：借用/切片，以及 Rust 如何在内存中布局数据。

Rust中的所有权

Rust 的内存管理模型

所有权是 Rust 这门编程语言的核心概念，Rust 最引以为豪的内存安全就建立在所有权之上。

所有的编程语言都存在某种管理内存的机制，拿 C 语言来说，这种机制是 malloc 和 free。这意味着开发者要手动管理内存。对于编程高手而言，这是一种拥有无限可能性的技术，但对于大多数普通人而言，它是一个 Bug 制造机器。一些语言采用了垃圾回收技术来管理内存，也就是说开发者可以只申请内存而不用手动去释放内存，然后，垃圾回收器，也就是 GC，会自动检测某块内存是否已经不再被使用，如果是的话，那么释放这块内存。但是因为 GC 的存在导致程序性能天生的下降，还有就是 GC 对程序运行带来的不确定性，任何使用 GC 的语言几乎不可能用来编写底层程序。我们这里说的底层是指贴近硬件的软件应用，例如操作系统和硬件驱动。

在生活中，如果有两种合理但不同的方法时，你应该总是研究两者的结合，看看能否找到两全其美的方法。我们称这种组合为杂合（hybrid）。例如，为什么只吃巧克力或简单的坚果，而不是将两者结合起来，成为一块可爱的坚果巧克力呢？

Rust 采用了一种中间方案 RAII（Resource Acquisition Is Initialization），它兼具 GC 的易用性和安全性，同时又有极高的性能。

栈和堆

在开始之前，我们先来回顾一下堆和栈的区别。栈是一种先进先出的数据结构，栈内的每个元素都有固定的大小，通常是你机器 CPU 的位宽。例如，如果你现在在使用 64 位机器，那么你机器上运行的任何程序的栈的宽度就是 64 位，正好是一个寄存器的大小。另一方面，如果我们要放置某个对象，例如一个字符串，由于字符串的长度是不固定的，因此无法被放置在栈中。此时我们必须使用堆，而当我们想要在堆上分配一个对象，我们向操作系统请求给定的内存数量，操作系统会在可用堆中找到一个空闲位置，然后讲标记设置为已占用，并返回指向该存储位置的指针，因此堆的组织性较差，它比栈要慢，但很多时候它是唯一的处理这些动态结构的方法。下图展示了一个字符是如何存储在内存中的：变量 s 保存在栈中，其值是一个指向堆的地址，堆中则保存了字符串的具体内容。

所有权的实际规则

• Rust 中每个值都绑定有一个变量，称为该值的所有者。
• 每个值只有一个所有者，而且每个值都有它的作用域。
• 一旦当这个值离开作用域，这个值占用的内存将被回收。

代码语言：javascript复制

fn main() {
    let value1 = 1;
    println!("{}", value1);
    {
        let value2 = 2;
    }
    // 无法在value2的作用域之外使用该变量
    // println!("{}", value2);

    let s1 = String::from("hello world");
    // 发生了所有权的转移
    let s2 = s1;
    // 由于每个值只有一个所有者，所以当所有权转移后，就无法访问s1了
    // println!("{}", s1);
    // 而所有权转移到了s2上，所以s2能够正常访问
    println!("{}", s2);

    let s3: String;
    {
        let s4 = String::from("hello world");
        s3 = s4;
        // 所有权转移了所以无法访问
        // println!("{}", s4);
    }
    // 所有权转移给了s3，此时该值的作用域也变成了s3的作用域，所以离开了s4的作用域该值还能访问
    println!("{}", s3);
}

Rust中的借用

在有些时候，我们希望使用一个值而不拥有这个值。这种需求在函数调用时特别常见，思考以下代码：

代码语言：javascript复制

fn echo(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello World!");
    echo(s);
    println!("{}", s);
}

编译将得到一个错误，我们不能再使用变量 s，应为 s 的值已经被转移到函数 echo 了。

代码语言：javascript复制

error[E0382]: borrow of moved value: `s`
 --> src/main.rs:8:20
  |
6 |     let s = String::from("Hello World!");
  |         - move occurs because `s` has type `String`, which does not implement the `Copy` trait
7 |     echo(s);
  |          - value moved here
8 |     println!("{}", s);
  |                    ^ value borrowed here after move

函数 echo 并不想要拥有 “Hello World!”，它只是想去临时使用以下它。这类功能通过使用引用来提供。通过引用，我们可以“借用”一些值，而无需拥有它们。这与Golang中实现引用传递的做法是类似的，就是传个指针类型而不是值。

代码语言：javascript复制

fn echo(s: &String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello World!");
    echo(&s);
    println!("{}", s);
}

不可变引用与可变引用

默认情况下，引用是不可变的。如果希望修改引用的值，需要使用 &mut，如下代码所示：

代码语言：javascript复制

fn change(s: &mut String) {
    s.push_str(" changed!")
}

fn main() {
    let mut s = String::from("Hello World!");
    change(&mut s);
    println!("{}", s);
}

可变引用的规则

可变引用具有一个最重要的规则：同一时间至多只能存在一个可变引用。此规则主要用于防止数据竞争，这样不同的线程之间就无法修改同一块内存了：

代码语言：javascript复制

fn main() {
    let s = String::from("Hello World!");
    let s1_ref = &mut s;
    let s2_ref = &mut s; // cannot borrow as mutable
}

生命周期

一个变量的生命周期从创建的时候开始，到销毁该变量的时候生命周期结束。编译器通过生命周期确保所有的借用都是有效的：即确保借用存在时，原值不会被销毁。在绝大多数情况下，生命周期和变量的作用域是一致的：

代码语言：javascript复制

fn main() {
    let i = 3; // i 的生命周期开始
    {
        let borrow1 = &i; // borrow1 的生命周期开始
        println!("borrow1: {}", borrow1);
    } // borrow1 的生命周期结束
    {
        let borrow2 = &i; // borrow2 的生命周期开始
        println!("borrow2: {}", borrow2);
    } // borrow2 的生命周期结束
} // i 的生命周期结束

在上述的代码中，可以看到对一个值的引用的生命周期总是处于原值的生命周期之内。

生命周期注解

在绝大多数情况下，Rust 编译器可以自动推导每个变量的生命周期。但有时候也需要我们手动在代码中注明生命周期，例如存在两个不同的引用变量，而编译器又无法自动推导的情况。比较常见的场景是与 &str 交互的时候。生命周期注解有着一个不太常见的语法：生命周期参数名称必须以撇号 ' 开头，其名称通常全是小写，类似于泛型其名称非常短。 'a 是大多数人默认使用的名称。生命周期参数注解位于引用的 & 之后，并有一个空格来将引用类型与生命周期注解分隔开。

例 1：接受两个字符串并返回字典序较大的字符串的函数：

代码语言：javascript复制

fn bigger<'a>(str1: &'a str, str2: &'a str) -> &'a str {
    if str1 > str2 {
        str1
    } else {
        str2
    }
}

fn main() {
    println!("{}", bigger("a", "b"));
}

要注意的是，生命周期注解并不改变任何引用的生命周期的长短。

例 2：定义存在一个 &str 类型字段的结构体。

代码语言：javascript复制

struct Person<'a> {
    name: &'a str,
}

fn main() {
    let p = Person {name: "Jack"};
    println!("{}", p.name);
}

静态生命周期

具有静态生命周期的引用在整个程序运行期间一直存在。它使用 static 关键字。具有静态生命周期的对象容易与常量搞混淆，虽然两者都在整个程序运行之中存在，但它们的区别是静态生命周期的对象有且只有一个内存地址，而常量则不一定。

我们以下面这个例子来理解静态生命周期。我们试图编写一个函数，该函数返回一个字符串 &str。但问题来了，字符串的内容 “Hello World!” 的作用域是函数体，而函数却试图返回它的引用。为了解决这个问题，需要将 &str 修改为 &'static str，它表明其所引用的内容的生命周期是整个程序运行期间。

代码语言：javascript复制

fn hello_world() -> &'static str {
    return "Hello World!";
}

何时应该使用静态生命周期：

• 正在存储大量数据
• 静态对象的单地址属性是必需的
• 内部可变性是必需的（静态对象是允许可变的）

代码语言：javascript复制

static mut LEVELS: u32 = 0;

fn main() {
    // 因为 static mut 允许多线程进行修改
    // 所以对 static mut 的修改必须放置在 unsafe 块中
    unsafe {
        println!("{}", LEVELS);
        LEVELS  = 1;
        println!("{}", LEVELS);
    }
}

rust 编程算法 ide c++

0 人点赞