前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Rust中的作用域及作用域的规则

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

作者头像
端碗吹水
发布2022-06-02 09:45:36
3.9K1
发布2022-06-02 09:45:36
举报
文章被收录于专栏:程序猿的大杂烩

所有权是 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);
    }
}
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2022-06-01,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • Rust中的所有权
    • Rust 的内存管理模型
      • 栈和堆
        • 所有权的实际规则
        • Rust中的借用
          • 不可变引用与可变引用
            • 可变引用的规则
            • 生命周期
            • 生命周期注解
            • 静态生命周期
            领券
            问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档