脚本之家

电脑版
提示:原网页已由神马搜索转码, 内容由www.jb51.net提供.
您的位置：首页→ 软件编程→ Rust语言→ Rust 所有权机制

Rust 所有权机制原理深入剖析

  更新时间：2023年01月03日 14:01:52  作者：ooooooh灰灰 
这篇文章主要为大家介绍了Rust 所有权机制原理深入剖析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

what's ownership?

常见的高级语言都有自己的 Garbage Collection（GC）机制来管理程序运行的内存，例如 Java、Go 等。而 Rust 引入了一种全新的内存管理机制，就是 ownership（所有权）。它在编译时就能够保证内存安全，而不需要 GC 来进行运行时的内存回收。

在 Rust 中 ownership 有以下几个规则：

  • 每个值都有一个 woner（所有者）
  • 在同一时间，每个值只能有一个 owner
  • 当 owner 离开作用域，这个值就会被丢弃

Scope (作用域)

通过作用域来划分 owner 的生命周期，作用域是一段代码的范围，例如函数体、代码块、if 语句等。当 owner 离开作用域，这个值就会被丢弃。

example:

fn main() {
    let s = String::from("hello"); // 变量 s 进入作用域，分配内存
    // s 在这里可用
} // 函数体结束，变量 s 离开作用域，s 被丢弃，内存被回收

ownership transfer（所有权转移）

和大多数语言一样，Rust 在栈上分配基本类型的值，例如整型、浮点型、布尔型等。而在堆上分配复杂类型的值，例如 String、Vec 等。所以，这里就引入了两个概念，move和 clone。

move

move操作会将变量的所有权转移给另一个变量，这样原来的变量就不能再使用了。这里需要注意的是，move操作只会发生在栈上的值，因为在堆上的值是不可复制的，所以只能通过 clone操作来复制。

example:

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

在上面的代码例子中，如果你执行就会在编译时报错：

  --> src/main.rs:11:32
   |
9  |     let s1 = String::from("hello");
   |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
10 |     let s2 = s1;
   |              -- value moved here
11 |     print!("s1 = {}, s2 = {}", s1, s2);
   |                                ^^ value borrowed here after move

编译器提示我们，s1在赋值给 s2时发生了 move的操作，它把字符串 hello的所有权移交给了 s2，此时 s1的作用域到这里就结束了，所以后面再使用 s1就会报错。

clone

clone操作会将变量的值复制一份，这样原来的变量和新的变量就都可以使用了。

这里需要注意的是，clone操作只会发生在堆上的值，因为在栈上的值是可复制的，所以只能通过 move操作来转移所有权。

example:

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

我们对 s1进行 clone操作，这样 s1和 s2都可以使用了，而且 s1的所有权也没有被转移，所以后面还可以继续使用 s1。

copy

如果一个类型实现了 copy这个 trait，使用它的变量不会移动，而是被简单地复制，使它们在分配给另一个变量后仍然有效。

example:

fn main() {
    let x = 5;
    let y = x;
    print!("x = {}, y = {}", x, y);
}

当 x赋值给 y后，x和 y都可以使用，而且 x的所有权也没有被转移，所以后面还可以继续使用 x。这是因为 i32这个类型实现了 copy这个 trait，所以 x的值被复制了一份，所以 x和 y都可以使用。

以下这些数据类型实现了 copy这个 trait：

  • 所有的整数类型，例如：u32、i32。
  • 布尔类型，bool，有 true和 false两个值。
  • 所有的浮点数类型，例如：f64、f32。
  • 字符类型，char。
  • 元组，当且仅当它们的元素类型都实现了 copy这个 trait。例如，(i32, i32)实现了 copy，但是 (i32, String)就没有实现。

References and Borrowing（引用和借用）

我们将创建引用的动作称为借用。就像在现实生活中一样，如果一个人拥有某样东西，你可以向他们借用。完成后，您必须将其归还。你不拥有它。 引用有以下几个规则：

  • 在任何给定时间，你可以拥有任意数量的引用，但是只能拥有一个可变引用。
  • 引用必须总是有效的。

example1:

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()
} // s 作用域失效，但是由于 s 是一个引用，没有所有权，所以不会发生任何事情

上面代码中，我们使用符号 &来创造一个变量的引用。这里我们使用 &s1来把这个引用指向 s1。函数 calculate_length的参数 s的类型是 &String，这意味着它是一个指向 String类型的引用，然后在函数体内获取 s的长度并返回给调用者。

example2:

fn main(){
    // 同一时间可以拥有多个不可变引用
    let s1 = String::from("hello");
    let s2 = &s1;
    let s3 = &s1;
    println!("s1 = {}, s2 = {}, s3 = {}", s1, s2, s3);
}

Mutable References（可变引用）

可变引用指的是可以改变引用值的引用。在同一作用域中，同一时间只能有一个可变引用。

example:

fn main(){
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);
}
fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

上面代码中，我们用 mut先创建了一个可变变量 s,然后使用 &mut s创建了一个指向 s的可变引用。函数 change的入参也是一个指向 String类型的可变引用，这样我们就可以在函数 change中改变 s的值了。

example2:

fn main() {
    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s;  // 在这里。编译器会报错，因为在同一作用域中，同一时间只能有一个可变引用。
    println!("{}, {}", r1, r2);
}
  --> src/main.rs:41:14
   |
40 |     let r1 = &mut s;
   |              ------ first mutable borrow occurs here
41 |     let r2 = &mut s;
   |              ^^^^^^ second mutable borrow occurs here
42 |
43 |     println!("{}, {}", r1, r2);
   |                        -- first borrow later used here

Dangling References（悬垂引用）

悬垂引用是指引用一个不存在的值。在 Rust 中，这是不可能的，因为编译器会在编译时就检查这种情况。下面是一个例子：

fn main() {
    let reference_to_nothing = dangle(); // 获得一个指向不存在值的引用
}
fn dangle() -> &String {
    let s = String::from("hello"); // s 进入作用域
    &s // 返回 s 的引用
} // s 作用域结束，s 被丢弃，内存被释放
  --> src/main.rs:51:16
   |
51 | fn dangle() -> &String {
   |                ^ expected named lifetime parameter

因为变量 s的作用域只在 dangle函数内，当 dangle函数返回 s的引用时，s已经被释放了，所以这个引用就是悬垂引用了。 解决这个的方法是返回一个 String而不是一个引用，这样 s就不会被释放，而是把 s的所有权转移给了调用者，也就不存在悬垂引用了。

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

以上就是Rust 所有权机制原理深入剖析的详细内容，更多关于Rust 所有权机制的资料请关注脚本之家其它相关文章！

相关文章

    • Rust字符串字面值的一些经验总结
      字符串有两种表现形式,一种是基本类型,表示字符串的切片,以&str表示,另一种是可变的string类型,下面这篇文章主要给大家介绍了关于Rust字符串字面值的相关资料,需要的朋友可以参考下
      2022-04-04
    • Rust结构体的定义与实例化详细讲解
      结构体是一种自定义的数据类型，它允许我们将多个不同的类型组合成一个整体。下面我们就来学习如何定义和使用结构体，并对比元组与结构体之间的异同，需要的可以参考一下
      2022-12-12
    • Rust生命周期常见误区(中英对照)全面指南
      这篇文章主要WEIDJAI 介绍了Rust生命周期常见误区(中英对照)的全面指南,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
      2023-11-11
    • Rust use关键字妙用及模块内容拆分方法
      这篇文章主要介绍了Rust use关键字妙用|模块内容拆分,文中还给大家介绍use关键字的习惯用法，快速引用自定义模块内容或标准库，以此优化代码书写，需要的朋友可以参考下
      2022-09-09
    • 详解Rust语言中anyhow的使用
      anyhow是一个Rust库,用于简化错误处理和提供更好的错误报告,这个库适合用于应用程序,而不是用于创建库,因为它提供了一个非结构化的,方便使用的错误类型,本文就给大家讲讲Rust语言中anyhow的使用,需要的朋友可以参考下
      2023-08-08
    • Rust处理错误的实现方法
      程序在运行的过程中，总是会不可避免地产生错误，而如何优雅地解决错误，也是语言的设计哲学之一。本文就来和大家来了Rust是如何处理错误的，感兴趣的可以了解一下
      2023-03-03
    • rust声明式宏的实现
      声明式宏使得你能够写出类似 match 表达式的东西,来操作你所提供的 Rust代码,它使用你提供的代码来生成用于替换宏调用的代码,感兴趣的可以了解一下
      2023-12-12
    • 深入了解Rust的切片使用
      除了引用，Rust 还有另外一种不持有所有权的数据类型：切片（slice），切片允许我们引用集合中某一段连续的元素序列，而不是整个集合。本文让我们来深入了解Rust的切片
      2022-11-11
    • Rust中的引用与借用举例详解
      这篇文章主要给大家介绍了关于Rust中引用与借用的相关资料,rust中借用和引用的附带功效都一样,就是都有生命周期,文中通过代码介绍的非常详细,对大家学习或者使用Rust具有一定的参考价值,需要的朋友可以参考下
      2023-11-11
    • 利用Rust编写一个简单的字符串时钟
      这篇文章主要为大家详细介绍了一个用rust写的一个简单的练手的demo，一个字符串时钟，在终端用字符串方式显示当前时间，感兴趣的小伙伴可以了解一下
      2022-12-12

    最新评论