Rust 的所有权、借用和生命周期

Pokeya
1,116 阅读32分钟

本文介绍了 Rust 编程语言中的所有权概念，探讨了内存管理模型以及堆和栈的作用。我们详细解释了什么是所有权，以及它在编程中的重要作用。通过简单代码示例介绍所有权的规则、转移方式和生命周期，能够帮助读者更好的理解如何正确管理数据的所有权。此外，我们还重新梳理了数据类型，并提供了一些常见问题的汇总，为读者提供全面的了解和回答疑惑的机会。通过阅读本文，读者将能够对 Rust 中的所有权有一个清晰的认识，并在编程实践中正确应用这一概念。

前言

在 Rust 中，所有权、借用和生命周期是密切相关的概念，它们共同构成了 Rust 的借用检查机制。

所有权（ownership） 指的是每个值在任意时刻只有一个所有者。当所有者超出作用域或显式地将值转移给其他变量时，这个值的所有权会被释放，资源会被回收。通过所有权机制，Rust 在编译时可以确保没有发生内存泄漏或悬空引用等问题。

借用（borrowing） 是指通过引用来临时使用某个值，而不获取其所有权。借用分为可变借用和不可变借用，在特定的作用域内，对于特定的变量，可能同时存在多个不可变借用，但只能有一个可变借用。借用规则保证了在借用存在期间，原始所有者不能修改或销毁被借用的值。

生命周期（lifetimes） 是用来描述引用的有效范围，也就是引用的存在时间。通过生命周期注解，我们可以明确指定引用的有效期，并在编译时进行检查，确保引用的有效性。

这三个概念共同构成了 Rust 的借用检查机制。所有权决定了值的归属和生命周期，借用则允许临时使用值而不获取所有权，并通过生命周期注解确保借用的有效性。这种机制使得 Rust 在编译时可以检测到悬空引用、数据竞争等常见的内存安全问题，从而提供高效且安全的程序运行环境！

内存管理模型

不同的编程语言都有着自己的内存管理机制。

以 C 语言为例，它使用 malloc 和 free 来手动管理内存。对于高级程序员来说，这是一种具有无限可能性的技术，但对于大多数普通开发者而言，却是一个容易导致 Bug 的机制。

还有很多应用级编程语言，如 Python、Go、Java 等，都采用了垃圾回收（Garbage Collection）技术来自动管理内存，开发者只需申请内存而无需手动释放，垃圾回收器会自动检测不再使用的内存并进行释放。然而，由于垃圾回收机制的存在，导致程序性能天生下降，同时也带来了运行时的不确定性。任何的 GC 语言几乎都不可能用来编写底层程序，例如操作系统和硬件驱动。

在现实生活中，当存在两种合理但不同的方法时，我们应该探索将两者结合起来的可能性，以找到一种更优的解决方案。这种结合被称为混合（Hybrid）。举个例子，为什么只喝瑞幸咖啡或贵州茅台呢？我们可以将它们结合在一起，创造出美味的酱香拿铁。

Rust 采用了一种中间方案，即资源获取即初始化（RAII）。它既具备垃圾回收的易用性和安全性，又能保持极高的性能。

栈和堆

栈（stack）是一种后进先出（LIFO, Last-In-First-Out）的数据结构。而堆（heap）则是一种用于动态分配内存的内存区域，没有特定的顺序。

在堆中分配的内存可以被随机访问，没有像栈那样严格的先进先出规则。当我们在堆上分配内存时，操作系统会根据请求的大小为我们提供一块连续的内存空间，并返回一个指向该内存的指针。因此，我们可以根据需要在任何时间访问堆中的内存，而不需要按照特定的顺序进行操作。

堆内存的管理通常由编程语言的运行时系统或者手动编写的代码负责。在使用完堆上的内存后，我们需要手动释放它，以便让操作系统重新回收这部分内存。

Stack

Stack (LIFO) 后进先出

www.kirillvasiltsov.com/writing/how…

web.mit.edu/rust-lang_v…

image.png

练习一下 Stack 模型

It’s called a ‘stack’ because it works like a stack of dinner plates: the first plate you put down is the last plate to pick back up. Stacks are sometimes called ‘last in, first out queues’ for this reason, as the last value you put on the stack is the first one you retrieve from it.

fn bar() {
    let i = 6;
}

fn foo() {
    let a = 5;
    let b = 100;
    let c = 1;

    bar();
}

fn main() {
    let x = 42;

    foo();
}

让我们详细分析一下这段代码中栈帧（stack frame）的生命周期情况：

  1. 当 main() 函数被调用时，一个新的栈帧被创建并推入栈中。栈帧包含了 x 变量，并位于栈的顶部。

  2. 在 foo() 函数内部，三个新变量 a、b 和 c 被定义并分配到栈帧中。它们依次被添加到栈的顶部。

  3. 当 bar() 函数被调用时，另一个新的栈帧被创建并推入栈中。栈帧包含了 i 变量，并位于栈的顶部。

  4. 在 bar() 函数执行完毕后，栈顶的栈帧（对应 bar() 的栈帧）会被从栈中移除，因为函数已经返回。

  5. 回到 foo() 函数，在 bar() 函数调用之后，该栈帧继续存在。foo() 函数执行完毕后，它的栈帧会被从栈中移除。

  6. 最后回到 main() 函数，当 foo() 函数调用结束后，该栈帧也会被移除。

  7. 当 main() 函数执行完毕后，整个程序的栈帧都会被清空，栈被释放，生命周期结束。

Tips：值得注意的是，在 foo() 函数执行完毕后，包括 a、b 和 c 变量的栈帧会一起从栈上移除。这是因为栈的机制是基于函数调用的，当函数结束时，对应的栈帧就会被删除，而不是逐个删除栈帧内的变量。所以，无论是 a、b 和 c 的定义顺序如何，它们都会在 foo() 函数结束时一起消失。

Heap

In Rust, you can allocate memory on the heap with the Box type. Here’s an example:

fn main() {
    let x = Box::new(5);
    let y = 42;
    let z = "hello world";
}

Here’s what happens in memory when main() is called. The memory now looks like this:

AddressNameValue
(2^30) -15
(2^30) -2
(2^30) -3
(2^30) -4"hello world"
.........
2z→ (2^30) -4
1y42
0x→ (2^30) -1

这个表格说明了在堆和栈上分配的变量和数据的存储方式。堆上存储的数据可以通过指针进行访问，而栈上存储的数据则直接存储在相应的地址上。栈类似于叠盘子，后进先出（LIFO），而堆则更像一盘散沙，没有特定的顺序。

什么是所有权

所有权是 Rust 特有的机制，也是 Rust 这门编程语言的核心概念，它是语言层面上提供的解决方案，让程序员不必过多关注对 堆内存（Heap） 的管理，Rust 最引以为豪的内存安全正是建立在所有权之上的！

所有权是 Rust 中用于 管理堆内存的机制，所有权系统使 Rust 能够在编译时检查内存访问错误。通过这种方式，Rust 能够确保内存分配的安全性和有效性，同时避免了由于程序员手动管理内存而可能出现的错误，如内存泄漏、野指针和双重释放等。

在 Rust 中，每一个值都有一个所有者，即拥有该值的变量。当所有者超出作用域时，该值将被自动释放。这种自动释放的方式称为 "drop"。它确保在程序运行时，每个堆上的值都有唯一的所有者，并在编译时检查所有权的转移，从而避免了内存安全问题。

所有权的作用

在许多编程语言中，程序员不必经常关心数据存储在栈还是堆中。但是，在像 Rust 这样的系统级编程语言中，数据存储在栈还是堆上对语言的行为产生了重大影响，并且必须在这两者之间做出选择。

所有权系统的目的是追踪哪些代码正在使用堆上的哪些数据，最大限度地减少堆上重复数据的数量，并清理不再使用的数据以确保不会耗尽空间。一旦理解了所有权，程序员就不需要经常考虑栈和堆了，但是理解所有权系统可以帮助解释为什么必须以这种方式管理堆数据。

所有权与堆内存

在 Rust 中，栈和堆的使用方式不同，而且在语言层面上提供了不同的机制来管理它们。

栈的使用是由编译器自动管理的，通常用来存储固定大小的数据。每当一个变量被声明时，编译器就会为它在栈上分配一块空间，当它超出作用域后，编译器就会自动释放这块空间。这种自动管理的机制使得栈的使用非常高效，而且不容易出错。

堆的使用则需要手动管理，通常用来存储动态大小的数据，比如字符串、向量等。在 C/C++ 中，手动管理堆的内存很容易出错，比如内存泄漏、野指针等问题。但是在 Rust 中，通过所有权系统和智能指针，可以避免这些问题。所有权系统确保每个值只有一个所有者，从而确保了内存安全性；而智能指针则可以根据需要自动管理内存的生命周期，从而减少手动管理的负担。

因此，Rust 的特性不仅包括所有权，还包括借用、生命周期、模式匹配、函数式编程等。这些特性使得 Rust 成为一门高效、安全、灵活的系统编程语言。

所有权规则

我们需要时刻去思考，关于 Rust 这个变量，它的所有权是谁，它的所有权被传递到了哪里。它是如何产生的，它是如何结束的。

所有权是 Rust 语言中的一个重要概念，用于管理内存的分配和释放。以下是 Rust 中的所有权规则：

  1. Rust 中的每一个值都有一个被称为其所有者（owner）的变量。
  2. 在任意时刻，一个值有且只有一个有效的所有者。
  3. 当拥有某个值的所有者超出其作用域时，该值将被释放。

这些规则确保了内存的安全和有效的资源管理。

示例代码

让我们通过一个简单的代码示例来解释下 Rust 中所有权的三条规则：

fn main() {
    let s = String::from("Hello"); // 创建一个新的字符串

    {
        let s2 = s;                // 所有权转移，s2成为新的所有者
        println!("{}", s2);        // 可以正常访问和使用s2
    }                              // s2 的作用域结束，其所拥有的值将被释放

    println!("{}", s);             // 此处尝试访问已经被释放的值，会导致编译错误！

}                                  // s 的作用域结束，其所拥有的值也将被释放

在上述代码中，我们创建了一个 String 类型的变量 s，它是一个拥有 Hello 字符串的所有者。根据第一条所有权规则，每个值都有一个唯一的所有者，因此 s 是该字符串的唯一所有者。

然后，在新的作用域内，我们将 s 的所有权转移到了变量 s2。这符合第二条所有权规则，即一个值只能有一个有效的所有者。现在，s2 成为了该字符串的所有者，并且可以在该作用域内正常访问和使用它。

当 s2 的作用域结束时，按照第三条所有权规则，其所拥有的值将被释放。这意味着内存将被回收，并且无法再访问或使用该值。

如果我们尝试在 println!("{}", s); 处访问已经被释放的值，由于 s 的所有权已经转移给了 s2，编译器会报错，因为该值已不存在。

通过这个例子，我们可以看到 Rust 中的所有权规则如何管理对值的拥有和释放，确保内存安全和避免悬空引用。

所有权转移

在 Rust 中，所有权的转移是通过移动、借用和引用来实现的。

  • 移动（Move）：当将一个值赋予另一个变量或传递给函数时，所有权会从一个所有者转移到另一个所有者。原始所有者将不再有效地拥有该值。
  • 借用（Borrow）：可以通过借用将值的临时访问权（共享访问）授予其他变量或函数，而不转移所有权。借用可以是可变（mutable）或不可变（immutable）的。
  • 引用（Reference）：通过引用，我们可以创建对值的非拥有性访问权，并允许多个引用同时存在。引用与借用类似，但有更灵活的作用域和生命周期。

使用所有权规则，Rust 能够在编译时检测并防止常见的内存错误，如空指针、数据竞争和悬垂引用。这使得 Rust 成为一个安全且高效的系统级编程语言。

示例代码

移动（Move）示例：

由于所有权转移，代码编译失败。

fn foo(s: String) {
    println!("{}", s);             // 打印传入的字符串变量s的值
}

fn main() {
    let s = String::from("hello"); // 创建一个拥有所有权的String对象并将其绑定到变量s
    foo(s);                        // 将变量s作为参数传递给函数foo，发生所有权的转移
    println!("{}", s);             // 尝试打印s，但由于s的所有权已经在调用foo函数时转移，所以会导致编译错误，"value borrowed here after move"
}

借用（Borrow）示例：

通过借用的方式修复了所有权转移引起的问题。

fn foo(s: &String) {
    println!("{}", s);             // 打印传入的字符串引用s的值
}

fn main() {
    let s = String::from("hello"); // 创建一个拥有所有权的String对象并将其绑定到变量s
    foo(&s);                       // 将s的引用作为参数传递给函数foo
    println!("{}", s);             // 可以正常打印s，因为只是借用了s的引用，没有发生所有权转移
}

引用（Reference）示例：

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

fn foo(s: &str) {
    println!("{}", s);
}

fn main() {
    let s = "hello";               // 这里的&str是一种静态字符串切片，它是对存在于程序的常量区的字符串的不可变引用或常量引用。
    foo(s);
    println!("{}", s);
}

引用和借用

在 Rust 中，"引用"（reference）是一个通用的概念，表示对某个值的别名或指向。它包括可变引用和不可变引用，用于共享数据的访问权限。而 "借用"（borrowing）则是使用引用来共享数据的一种特定模式。它遵循 Rust 的借用规则（Borrowing Rules），以确保安全地访问和操作数据，同时避免数据竞争。

因此，我们可以将借用视为一种特殊类型的引用。也可以说借用是引用的一个子集，是引用的一种特殊形式，用于描述通过引用共享数据并遵守借用规则的行为。

可变引用的规则

规则一

在同一时间内，最多只能存在一个可变引用！

fn main() {
    let mut value = "hello";
    let ref1 = &mut value;   // 第一个可变引用
    let ref2 = &mut value;   // 尝试创建第二个可变引用，会导致编译错误
}

error[E0499]: cannot borrow `value` as mutable more than once at a time
 --> src/main.rs:4:22
  |
3 |     let ref1 = &mut value;
  |                ---------- first mutable borrow occurs here
4 |     let ref2 = &mut value;
  |                ^^^^^^^^^^ second mutable borrow occurs here

这个限制的好处是 Rust 可以在编译时就避免数据竞争。数据竞争（data race）类似于竞态条件，它可由这三个行为造成：

  • 两个或更多指针同时访问同一数据。
  • 至少有一个指针被用来写入数据。
  • 没有同步数据访问的机制。

数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！

规则二

在不同作用域中，可以允许拥有多个可变引用，注意我们强调的是不能同时拥有。

fn main() {
    let mut value = "hello";
    {
        let ref1 = &mut value; // 第一个可变引用，它在单独的作用域
    }
    let ref2 = &mut value;     // 创建第二个可变引用，准确说，不能称为第二个，因为它是该作用域中的第一个
}

规则三

在同一时间，允许存在多个不可变引用。

fn main() {
    let mut value = String::from("hello");

    let ref1 = &value;         // 编译通过
    let ref2 = &value;         // 编译通过

    println!("{}", ref1);
    println!("{}", ref2);
}

规则四

在同一时间，不能同时出现可变引用和不可变引用！

fn main() {
    let mut value = String::from("hello");

    let ref1 = &value;         // 编译通过
    let ref2 = &value;         // 编译通过
    let ref3 = &mut value;     // 编译报错：同时存在可变引用和不可变引用
    ref3.push_str(" world!");

    println!("{}", ref1);
    println!("{}", ref2);
    println!("{}", ref3);
}

这个代码报错原因理解起来就很简单，拜托人家 ref1 和 ref2 都定义不可变了，而且它们还没有使用该不可变引用，好家伙你 ref3 一上来就声明想给人家改了，这未免也太不讲道理了，所以 Rust 从语言层面也防止了这样的情况发生！于是，我们的代码改成这样就可以了：

fn main() {
    let mut value = String::from("hello");

    let ref1 = &value;         // 编译通过
    let ref2 = &value;         // 编译通过

    println!("{}", ref1);      // 使用完毕
    println!("{}", ref2);      // 使用完毕

    let ref3 = &mut value;     // 编译通过
    ref3.push_str(" world!");  // 更改引用

    println!("{}", ref3);      // 使用完毕
}

生命周期

什么是生命周期

一个变量的生命周期从创建开始，到销毁该变量结束。通过使用生命周期，编译器可以确保所有的借用都是有效的，也就是在借用存在时原值不会被销毁。

在大多数情况下，一个变量的生命周期和其作用域是一致的。变量的作用域是指在程序中该变量可以被访问和使用的范围。在这个范围内，变量是有效的，我们可以对它进行操作。当超出变量的作用域时，变量会被销毁，其占用的资源会被释放。

生命周期注解用来表明引用的有效期，以确保在引用存在的同时，被引用的值仍然有效。通过使用生命周期注解，我们可以告诉编译器引用的有效范围，从而遵守借用规则并避免悬空引用或非法引用的问题。

总结起来，生命周期的作用是为了确保在借用存在时，被借用的值仍然有效，并且与变量的作用域相一致。这样可以在编译时检查出潜在的错误，并确保代码的正确性和安全性。

生命周期注解

自动推断

在大多数情况下，Rust 编译器能够自动推断每个变量的生命周期。然而，在某些情况下，我们需要手动在代码中注明生命周期。一个常见的场景是与 &str 进行交互时。

何时使用

生命周期注解主要在存在借用的情况下使用。当函数、结构体、枚举、方法或闭包涉及到引用类型时，就需要考虑生命周期注解！

注解语法

生命周期注解采用了一种不太常见的语法：生命周期参数名称必须以撇号 ' 开头，且通常使用全小写字母命名（类似于泛型）。'a 是大多数开发者默认使用的名称。生命周期参数注解位于引用的 & 之后，并使用一个空格将引用类型和生命周期注解分隔开来。

fn function_name<'a>(parameter: &'a Type) -> &'a ReturnType {
    // 函数体
}
  • 'a 是生命周期参数的名称，通常使用单个小写字母来表示。
  • parameter 是一个带有生命周期注解的引用类型参数，用于指定参数的生命周期。
  • Type 是参数的类型。
  • ReturnType 是函数返回值的类型，并且也使用了相同的生命周期注解。

静态生命周期

Rust 中的生命周期注解有多种表示方式，其中最常见的是使用单引号标记的小写字母，例如 'a、'b 等。这些标记的生命周期是具体而临时的，可以根据具体的代码上下文来确定。

另外，还有一种特殊的生命周期注解 'static，表示静态生命周期。静态生命周期代表整个程序的执行周期，从程序启动到结束一直有效。 'static 生命周期注解用于指定引用具有最长的生命周期，确保所引用的数据在整个程序执行期间都有效。

简单示例

我们定义了一个 longest 函数，用来比较两个字符串字面量的长度，并返回较长的那个字符串。

先来个错误版本的写法：

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    println!("Longest string: {}", longest("Hello", "Rust"));
}

我们来简单分析一下这段代码。longest 函数返回一个借用值 &str，但是在 if 语句中可能返回 x 或者 y，这样就会导致 x 和 y 的生命周期不一致。然而，根据逻辑，x 和 y 应该具有相同的生命周期才对，这样才公平嘛！为了确保 x 和 y 处于相同的生命周期内，我们需要使用生命周期注解对这段代码进行修正。

正确写法如下所示：

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    println!("Longest string: {}", longest("Hello", "Rust"));
}

在修正后的代码中，我们添加了生命周期注解 <'a> 来指定 x 和 y 具有相同的生命周期，并且函数返回值的生命周期也与输入参数一致。这样就解决了引用生命周期不一致的问题，并确保了代码的正确性和安全性。

常见用法

在 Rust 中，生命周期注解可以用于函数、结构体、枚举、方法、闭包等多个地方。

以下是一些常见的用法：

  1. 函数签名：生命周期注解通常用于函数参数和返回值的类型之前，以指定参数和返回值具有相同的生命周期。
fn foo<'a>(x: &'a str, y: &'a str) -> &'a str {
    // 函数体
}
  1. 结构体定义：生命周期注解可以用于结构体字段的类型之前，以确保该字段引用的数据在结构体中保持有效。
struct MyStruct<'a> {
    field: &'a str,
}
  1. 枚举定义：生命周期注解也可以用于枚举成员的类型之前，以指定不同成员共享相同的生命周期。
enum MyEnum<'a> {
    Variant1(&'a str),
    Variant2(&'a str),
}
  1. 方法签名：生命周期注解可以用于方法参数和返回值的类型前面，与函数类似。
impl<'a> MyStruct<'a> {
    fn method(&self, other: &'a str) -> &'a str {
        // 方法体
    }
}
  1. 闭包：当使用具有引用参数的闭包时，需要使用生命周期注解来确保闭包捕获的引用在闭包内有效。
fn main() {
    let x = "Hello";
    let closure = |y: &'static str| -> &'static str {
        if y.len() > x.len() {
            y
        } else {
            x
        }
    };
    println!("Longest string: {}", closure("Rust"));
}

注意使用 'static 生命周期注解需要谨慎，因为它表示引用的生命周期最长，并要求所引用的数据在程序执行期间一直有效。在实际编程中，应根据实际需求选择适当的生命周期注解，以确保代码正确且安全。

名词解释

【内存泄漏（memory leak）】
内存泄漏是指程序中分配的内存没有被正确释放，导致系统中出现无法访问的空闲内存。这种空闲内存可能会被其他程序占用，导致内存的浪费和程序的运行不稳定。
内存泄漏通常是由程序员错误使用内存分配和释放函数造成的，比如忘记释放内存、释放了错误的内存地址等。

【野指针（dangling pointer）】
野指针是指一个指针，它指向已经被释放或者未分配的内存空间。这样的指针会导致程序崩溃或不可预期的行为，因为访问这样的内存地址可能会导致访问到其他程序正在使用的内存空间，或者操作系统不允许访问的内存空间。
野指针通常是由于程序员错误地使用了已经释放的内存地址或者没有初始化的指针变量，或者在变量的生命周期已经结束后仍然使用了指向该变量的指针。
因此，在编写程序时应该避免野指针的出现，可以通过一些技术手段来避免，如合理使用内存分配和释放函数，使用空指针或者空引用来代替未初始化的指针，以及在指针的使用过程中进行有效性检查等。

【双重释放（double free）】
双重释放指的是在程序中释放同一个内存地址两次或以上。这通常是由于程序中出现了一些逻辑错误，例如多次调用了free()函数，或者对已经释放的指针进行了第二次释放。
双重释放会导致程序崩溃或者产生其他不可预知的结果，因为这可能会破坏内存管理系统的数据结构，例如堆的空闲列表或内存池等。此外，双重释放还可能导致安全漏洞，例如内存泄漏或者缓冲区溢出等。
为了避免双重释放，程序员需要在使用free()函数释放内存之前，确保该内存没有被释放过。通常，这可以通过对指针进行检查来实现，例如将指针设置为NULL，这样如果程序再次尝试释放这个指针，就会产生运行时错误。此外，使用一些内存安全的编程工具，例如智能指针、垃圾回收器等，也可以避免双重释放的问题。

重新梳理类型

当我们回顾了堆和栈的概念，深入了解了 Rust 的所有权系统，并学习了大部分的数据类型后，让我们再次回顾整理一下所学内容。

数据类型分类

在 Rust 中，我们可以将类型分为两个主要类别：基本类型（Primitive types）和复合类型（Compound types）。它们在内存中的分配方式和所有权机制上有所不同。

基本类型（Primitive types）

基本类型是 Rust 内建的简单数据类型，它们通常占用固定大小的空间，并按值进行复制。这些类型都是分配在栈上的。以下是一些常见的基本类型：

  • 整数类型（Integer types）
  • 浮点数类型（Floating-point types）
  • 布尔类型（Boolean type）
  • 字符类型（Character type）

由于基本类型是按值复制的，因此它们没有所有权的概念。

复合类型（Compound types）

复合类型由多个值组合而成，可以是拥有所有权的类型。这些类型通常具有动态大小，并且在堆上分配内存。以下是一些常见的复合类型：

  • 字符串类型（String type）
  • 数组类型（Array type）
  • 元组类型（Tuple type）
  • 结构体类型（Struct type）
  • 枚举类型（Enum type）
  • 函数类型（Function type）

在复合类型中，最常见的拥有所有权的类型是字符串类型 String。它使用堆内存来存储和管理动态长度的字符串数据。另外一些复合类型也可能涉及到所有权的转移或借用。

与此相反，&str 类型是一个字符串切片，它是对其他地方存储的字符串数据的引用。&str 自身存储在栈上，但它所引用的字符串数据实际上可能存储在常量区或堆上。

需要注意的是，并非所有分配在堆上的类型都具有所有权。例如，数组类型、元组类型和结构体类型可以在栈上或堆上分配，具体取决于它们的大小和生命周期。

总之，基本类型通常在栈上分配，并按值复制。复合类型可以包含拥有所有权的类型，并且通常在堆上分配，但并不是所有在堆上分配的类型都具有所有权。

常见问题汇总

问题一：字符串字面量和 String 类型有什么不同？

在 Rust 中，字符串有两种常见的表示方式：字符串字面量和 String 类型。下面详细解释一下它们之间的不同之处。

  1. 字符串字面量（String Literal）：在 Rust 中，字符串字面量是由双引号包围的文本，例如 "hello world"。这些字符串字面量是静态分配的，存储在程序的常量区（数据段）中。它们的长度是在编译时确定的，并且不可更改。当你创建一个字符串字面量时，编译器会为其分配内存，并将其视为 &str 类型的不可变引用。因此，let s = "hello world"; 创建的是一个指向静态数据区的 &str 引用。

    fn main() {
    let s1 = "hello world"; // 创建一个字符串字面量，并将其绑定到变量s1
    let s2 = s1;            // 将s1赋值给s2，由于字符串字面量是不可变的，复制操作是通过对指针的复制来完成的
    println!("{:?}", s1);   // 此处打印s1，因为它是不可变的字符串字面量，所以仍然可以正常访问和打印
}

  2. String 类型：String 是一个动态分配的、可变长度的字符串类型，可以通过 String::from 或 to_string 方法来创建。与字符串字面量不同，String 类型存储在堆上，而不是常量区。它具有动态可变性，可以根据需要增长或缩小。创建 String 对象时，会在堆上分配足够的内存来存储字符串数据，并返回一个拥有所有权的 String 对象。

    fn main() {
    let s1 = String::from("hello world"); // 创建一个动态分配的字符串，并将其所有权绑定到变量s1
    let s2 = s1;                          // 将s1的所有权转移给s2，s1将不再有效
    println!("{:?}", s1);                 // 此处尝试打印s1，但由于所有权已被转移，s1将不再有效，因此会发生编译错误
}

总结起来，字符串字面量是静态分配的、不可变的，在常量区存储，并作为 &str 类型的不可变引用。而 String 类型是动态分配的、可变的，在堆上存储，并具有所有权。

这两种字符串表示方式在使用和操作上有一些不同，例如对于字符串的修改、拼接、传递等。根据具体需求和场景，选择合适的字符串类型可以使代码更加灵活和高效。

问题二：哪些类型可以在堆上分配内存，但并不具有所有权？

  1. 引用类型（References）：包括借用引用 &T 和可变引用 &mut T。引用是对其他数据的非所有权引用，它们本身不负责内存的分配和释放。
  2. 字符串切片（&str）：&str 是对其他地方存储的字符串数据的引用，它也不拥有该字符串数据的所有权。
  3. 动态数组切片（Vec<T>）：Vec<T> 是一个动态分配的数组，它在堆上分配了一块连续的内存来存储元素。尽管 Vec<T> 拥有对这块内存的所有权，但它本身并不是一个拥有所有权的类型。相反，它通过引用或切片向外部提供对堆上数据的访问。

需要注意的是，虽然这些类型没有直接的所有权，但它们可以通过传递引用或切片来共享对堆上数据的访问权限。这种方式使得数据能够被多个地方同时引用而不需要进行拷贝，从而提高了效率。

问题三：为什么有的复合类型可以在栈上或堆上分配呢？

数组类型、元组类型和结构体类型在 Rust 中可以在栈上或堆上分配内存，具体取决于它们的大小和生命周期。

  1. 栈上分配：对于较小且大小在编译时可确定的数据结构，Rust 倾向于在栈上进行分配。这些数据结构包括固定长度的数组、元组（当元素数量和类型都是已知的）以及小型结构体。在栈上分配内存速度更快，不需要手动释放内存，也不会有堆上内存分配的开销。当这些数据结构超出作用域时，它们会自动被弹出栈并释放内存。

    fn main() {
    let v1 = ('a', true, 1, "hello");  // 栈上分配！
    let v2 = v1;
    println!("{:?}", v1); // 由于元组的各成员值都是不可变的且具备 Copy trait（对于基本类型），或者是引用类型（不涉及所有权转移），因此栈上的数据可以被多个变量共享，不涉及借用或所有权转移等行为，程序能够正常运行。
}

  2. 堆上分配：对于较大或者在编译时大小未知的数据结构，Rust 通常在堆上分配内存。这样做的原因是堆上的内存空间更灵活，可以动态地增长或缩小。堆上分配需要手动管理内存，即需要调用 Box::new 或者 Vec::new() 等方法来创建一个指向堆上数据的指针，并在使用完后手动释放内存。使用堆上分配的数据结构可以跨越多个作用域存在。

    fn main() {
    let v1 = ('a', true, Box::new(1), String::from("hello")); // 堆上分配！
    let v2 = v1;
    println!("{:?}", v1); // 由于元组的成员值中包含了堆上分配并且拥有所有权的对象，进行元组整体赋值给其他变量时会发生所有权的转移行为。根据 Rust 的所有权规则，一个对象的所有权只能属于一个变量，因此在转移所有权后，原来的变量将无法再访问这些堆上数据，并会导致编译错误（"value borrowed here after move"）。
}

关于如何决定存储位置，Rust 编译器会根据数据结构的大小和生命周期来作出决策。较小且大小已知的数据结构通常在栈上分配，而较大或者大小未知的数据结构则在堆上分配。

这种灵活性使得 Rust 在内存管理方面能够更高效地处理不同类型的数据结构，同时保证安全性和性能。

问题四：切片类型到底是在栈上还是在堆上分配？

在 Rust 中，切片（Slice）数据结构实际上是一个指向已分配内存的引用，因此它本身并不存储数据。切片可以存在于栈上，但指向的数据通常是在堆上分配的。

具体来说，切片包含两个部分：指针和长度。指针指向切片引用的数据的起始位置，而长度表示切片引用的数据的大小。由于切片只是对底层数据的引用，并不拥有所有权，所以它的大小是固定的，并且在编译时就可以确定。

切片本身在栈上分配，并且可以轻松地复制和传递。但是，它所引用的数据通常是在堆上分配的，例如通过 String 或 Vec<T> 动态分配的数据。这些动态分配的数据在堆上分配，并且被切片引用。

简而言之，切片本身是在栈上分配的，但它们通常引用在堆上分配的数据。

avatar
文章
阅读
粉丝