当前位置: 首页>后端>正文

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

[TOC]

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中的作用域及作用域的规则,第1张

所有权的实际规则

  • Rust 中每个值都绑定有一个变量,称为该值的所有者。
  • 每个值只有一个所有者,而且每个值都有它的作用域。
  • 一旦当这个值离开作用域,这个值占用的内存将被回收。
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中的借用

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

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

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

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

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中实现引用传递的做法是类似的,就是传个指针类型而不是值。

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

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

不可变引用与可变引用

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

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

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

可变引用的规则

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

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

生命周期

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

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:接受两个字符串并返回字典序较大的字符串的函数:

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 类型字段的结构体。

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

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

静态生命周期

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

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

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

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

  • 正在存储大量数据
  • 静态对象的单地址属性是必需的
  • 内部可变性是必需的(静态对象是允许可变的)
static mut LEVELS: u32 = 0;

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

https://www.xamrdz.com/backend/3eb1936665.html

相关文章: