Rust学习笔记007-所有权

什么是所有权

Rust的核心功能(之一)就是所有权,其令 Rust 无需垃圾回收即可保障内存安全。

所有运行的程序都必须管理其使用计算机内存的方式:

  • 一些语言中具有垃圾回收机制,在程序运行时不断地寻找不再使用的内存;
  • 在另一些语言中,程序员必须亲自分配和释放内存。
  • Rust 则选择了第三种方式:通过所有权系统管理内存,编译器在编译时会根据一系列的规则进行检查。在运行时,所有权系统的任何功能都不会减慢程序。

所有权规则

  • Rust中的每一个值都有一个被称为其所有者(owner)的变量;
  • 值只有一个所有者;
  • 当所有者(变量)离开作用域时,这个值将被丢弃;

变量作用域

{                     		 // s 在这里无效, 它尚未声明
    let s = "hello";  		 // 从此处起,s 是有效的
 	//...				 	 // 使用 s
}                      		 // 此作用域已结束,s 不再有效

String类型

String类型被分配到堆上,所以能够存储在编译时未知大小的文本。可以使用 from 函数基于字符串字面值来创建 String,如下:

let s = String::from("hello");

这两个冒号(::)是运算符,允许将特定的 from 函数置于 String 类型的命名空间下,而不需要使用类似 string_from 这样的名字。

修改此类字符串 :

let mut s = String::from("hello");
s.push_str(", world!"); 	// push_str() 在字符串后追加字面值
println!("{}", s); 			// 将打印 `hello, world!`

那么这里有什么区别呢?为什么 String 可变而字面值却不行呢?区别在于两个类型对内存的处理上。

内存与分配

字符串字面值,我们在编译时就知道其内容,所以文本被直接硬编码进最终的可执行文件中。

对于 String 类型,为了支持一个可变,可增长的文本片段,需要在堆上分配一块在编译时未知大小的内存来存放内容。

这意味着:

  • 必须在运行时向操作系统请求内存。
  • 需要一个当我们处理完String 时将内存返回给操作系统的方法。

Rust 采取的策略是:内存在拥有它的变量离开作用域后就被自动释放。

👆上面这句话很重要,建议读三遍。

{
    let s = String::from("hello"); // 从此处起,s 是有效的
    // 使用 s
}                                  // 此作用域已结束,
                                   // s 不再有效

这是一个将 String 需要的内存返回给操作系统的很自然的位置:当 s 离开作用域的时候

当变量离开作用域,Rust 为我们调用一个特殊的函数,这个函数叫做 drop。在这里 String 的作者可以放置释放内存的代码。Rust 在结尾的 } 处自动调用 drop

数据移动
let x = 5;
let y = x;

我们大致可以猜到这在干什么:“将 5 绑定到 x;接着生成一个值 x 的拷贝并绑定到 y”。现在有了两个变量,xy,都等于 5

现在看看这个 String 版本:

let s1 = String::from("hello");
let s2 = s1;

这看起来与上面的代码非常类似,所以我们可能会假设他们的运行方式也是类似的:也就是说,第二行可能会生成一个 s1 的拷贝并绑定到 s2 上。不过,事实上并不完全是这样。

👇下面这张图展示了String类型的底层存储由三部分组成:

  • 一个指向存放字符串内容内存的指针
  • 一个长度
  • 一个容量
    这一组数据存储在栈上。右侧则是堆上存放内容的内存部分。在这里插入图片描述
    当我们将 s1 赋值给 s2,String 的数据被复制了,这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制指针指向的堆上数据。换句话说,内存中数据的表现如下图所示:
    在这里插入图片描述

之前我们提到过当变量离开作用域后,Rust 自动调用 drop 函数并清理变量的堆内存。不过上图展示了两个数据指针指向了同一位置。这就有了一个问题:当 s2 和 s1 离开作用域,他们都会尝试释放相同的内存。这是一个叫做 二次释放的错误,也是之前提到过的内存安全性 bug 之一。两次释放(相同)内存会导致内存污染,它可能会导致潜在的安全漏洞。

为了确保内存安全,Rust的处理是,与其尝试拷贝被分配的内存,Rust 则认为 s1 不再有效,因此 Rust 不需要在 s1 离开作用域后清理任何东西。

看看在 s2 被创建之后尝试使用 s1 会发生什么:

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

你会得到一个类似如下的错误,因为 Rust 禁止你使用无效的引用。

error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:4:31
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 |     println!("s1 = {}, s2 = {}", s1, s2);
  |                                  ^^ value borrowed here after move

如果你在其他语言中听说过术语 浅拷贝(shallow copy)和 深拷贝(deep copy),那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝

这种 Rust 使第一个变量无效的操作被称为 移动(move),而不是浅拷贝。

那么当s1被移动到s2时,究竟发生了什么?
在这里插入图片描述

这样就解决了我们的问题!因为只有 s2 是有效的,当其离开作用域,它就释放自己的内存,完毕。

另外,这里还隐含了一个设计选择:Rust 永远也不会自动创建数据的 “深拷贝”。因此,任何 自动 的复制可以被认为对运行时性能影响较小。

克隆

如果确实需要复制String堆上的数据,可以使用clone方法。

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

运行可以正常输出。

但是要注意,当调用clone方法时可能比较消耗资源。

拷贝

继续讨论下面的一段代码:

let x = 5;
let y = x;
println!("x = {}, y = {}", x, y);

运行发现也没报错,和我们上面介绍的很矛盾:没有调clone,x也没被移动到y中。

原因是这种在编译时就已知大小的类型会被存储在栈上,拷贝也相当快速,就没必要在创建变量 y 后使 x 无效,即相当于自动调用了clone

Copy trait
如果一个类型拥有Copy trait,一个旧的变量在将其赋值给其他变量后仍然可用(比如上面代码里面x)。Rust 不允许自身或其任何部分实现了Drop trait 的类型使用 Copy trait

那么什么类型是Copy 的呢?可以查看给定类型的文档来确认,不过作为一个通用的规则,任何简单标量值的组合可以是 Copy 的,不需要分配内存或某种形式资源的类型是 Copy 的。

如下是一些 Copy 的类型:

  • 所有整数类型,比如 u32
  • 布尔类型bool,它的值是 true 和 false。
  • 所有浮点数类型,比如 f64
  • 字符类型,char
  • 元组,当且仅当其包含的类型也都是 Copy 的时候。比如,(i32, i32) 是 Copy 的,但 (i32, String)就不是。

所有权与函数

将值传递给函数在语义上与给变量赋值相似,向函数传递值可能会移动或者复制,就像赋值语句一样。

fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动到函数里 ...
                                    // ... 所以到这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 应该移动函数里,
                                    // 但 i32 是 Copy 的,所以在后面可继续使用 x

} // 这里, x 先移出了作用域,然后是 s。但因为 s 的值已被移走,
  // 所以不会有特殊操作

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 这里,some_string 移出作用域并调用 `drop` 方法。占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 这里,some_integer 移出作用域。不会有特殊操作

返回值和作用域

返回值也可以转移所有权。

fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 移给 s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中, 
                                        // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域,但已被移走,
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String {             // gives_ownership 将返回值移动给
                                             // 调用它的函数

    let some_string = String::from("hello"); // some_string 进入作用域.

    some_string                              // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

    a_string  // 返回 a_string 并移出给调用的函数
}

变量的所有权总是遵循相同的模式:

  • 将值赋给另一个变量时移动它,除非变量类型实现了Copy trait注解。
  • 当持有堆中数据值的变量离开作用域时,其值将通过drop 被清理掉,除非数据被移动为另一个变量所有。
多值返回

函数或者方法可以使用元组来实现多值返回。

fn main() {
    let s1 = String::from("hello");
    let (s2, len) = calculate_length(s1);
    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() 返回字符串的长度
    (s, length)
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值