Rust 入门 (四)

in 编程
关注公众号【好便宜】( ID:haopianyi222 ),领红包啦~
阿里云,国内最大的云服务商,注册就送数千元优惠券:https://t.cn/AiQe5A0g
腾讯云,良心云,价格优惠: https://t.cn/AieHwwKl
搬瓦工,CN2 GIA 优质线路,搭梯子、海外建站推荐: https://t.cn/AieHwfX9

所有权是 rust 语言独有的特性,它保证了在没有垃圾回收机制下的内存安全,所以理解 rust 的所有权是很有必要的。接下来,我们来讨论所有权和它的几个特性:借用、切片和内存结构。

什么是所有权

Rust 的核心特性是所有权。各种语言都有它们自己管理内存的方式,有些是使用垃圾回收机制,有些是手动管理内存,而 rust 使用的是所有权机制来管理内存。

所有权规则

所有权规则如下:

不懂没关系,跳过往后看。

变量作用域

rust 语言的变量作用域和其他语言是类似的,看例子:

{                      // 变量 s 还没有被声明,s 在这里是无效的
    let s = "hello";   // 变量 s 是这里声明的,从这里开始生效

    // 从这里开始,可以使用 s 做一些工作
}                      // 变量 s 超出作用域,s 从这里开始不再生效

可以总结两点重要特性:

String 类型

在章节三中学习的数据类型都是存储在内存的栈空间中,当它们的作用域结束时清空栈空间,我们现在学习一下内存的堆空间中存储的数据是在何时被 rust 清空的。

<br>

我们在这里使用 String 类型作为例子,当然只是简单的使用,具体的内容后文介绍。

let s = "hello";

这个例子是把 hello 字符串硬编码到程序中,我们把它叫做 字符串文字 (string literals 我不知道别人是怎么翻译的,我实在想不到合适的词,先这样叫着吧),字符串文字很方便,但是它不能适用于任何场景,比如我们想要输入一个文本串的时候,原理如下:

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

这种双冒号的语法细节下个章节再说,这里先聚焦于字符串,例子中创建的字符串是可以改变的,比如:

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

s.push_str(", world!"); // push_str() 在上个字符串后追加一个字符串

println!("{}", s); // 这里会打印 `hello, world!`

内存分配

字符串文字是在编译期间就有确定的字符内容,所以文本可以直接硬编码到程序中,这就是字符串文字快捷方便的原因。但是字符串文字又是不可变的,我们没办法分配内存给编译期间未知大小及变化的字符串。

<br>
字符串类型则支持字符串的修改和增长,即使编译期间未知大小,也可以在堆内存分配一块空间用于存储数据,这意味着:
* 内存必须是在运行时,从操作系统中请求 (和大多数编程语言类似,当我们调用 String::from 方法时,就完成了对内存的请求)
* 当不使用这块内存时,我们才会把它返还给操作系统 (和其它语言不同,其它语言是使用垃圾回收机制或手动释放内存)

rust 则是另一种方式:一旦变量超出作用域,程序自动返还内存,通过下面的例子来看这个概念:

{
    let s = String::from("hello"); // s 从这里开始生效

    // 利用 s 做一些事情
}                                  // s 超出作用域,不再生效

当 s 超出作用域,rust 会自动帮我们调用一个特殊的函数—— drop 函数,它是用于返还内存的,当程序执行到 大括号右半块 } 的时候自动调用该函数。

变量和数据交互方式:移动

在 rust 中,可以使用不同的方式在多个变量间交互相同的数据,比如:

let x = 5; // 把 5 绑定到 x 上
let y = x; // 把 x 的值复制给 y,此时,x 和 y 的值都是 5

再比如:

let s1 = String::from("hello"); // 创建一个字符串绑定到 s1 上
let s2 = s1;			// 把 s1 的值移动给 s2,此时,s1 就失效了,只有 s2 是有效的

s1 为什么失效,因为字符串是存储在堆内存中的,这里只是把栈内存中的 s1 的数据移动给 s2,堆内存不变,这种方式叫做浅克隆,也叫移动。如果想让 s1 仍然有效,可以使用深克隆。

变量和数据交互方式:克隆

关于深克隆,我们直接看例子吧:

let s1 = String::from("hello"); // 创建一个字符串绑定到 s1 上
let s2 = s1.clone();		// 把 s1 的值克隆给 s2,此时,s1 和 s2 都是有效的

println!("s1 = {}, s2 = {}", s1, s2); // 打印 s1 和 s2

下一章节再详细介绍这种语法。

只有栈数据:复制

我们再回到前面的例子中:

let x = 5; // 把 5 绑定到 x 上
let y = x; // 把 x 的值复制给 y,此时,x 和 y 的值都是 5

println!("x = {}, y = {}", x, y); // 打印 x 和 y

这里没有使用 clone 这个方法,但是 x 和 y 都是有效的。因为 x 和 y 都是整型,整型存储在栈内存中,即使调用了 clone 方法,也是做相同的事。下面总结一下复制的类型:

所有权和函数

这里直接放一个例子应该就说清楚了,如下:

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

    takes_ownership(s);             // s 移动到函数里

    // s 从这里开始不再生效,如果还使用 s,则会在编译期报错

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

    makes_copy(x);                  // x 复制(移动)到函数里,
                                    // 但由于 x 是 i32 ,属于整型,仍有效
                                    // 使用 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 移动进函数,函数返回值移动给 s3

} // s3 超出作用域被删除,s2 超出作用域被删除,s1 超出作用域被删除

fn gives_ownership() -&gt; 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) -&gt; String { // a_string 进入作用域

    a_string  // a_string 是返回值,移出调用函数
}

引用和借用

前面都是把值传入传出函数,这里我们学习一下引用,看个例子:

fn main() {
    let s1 = String::from("hello");  // 创建一个字符串 s1

    let len = calculate_length(&amp;s1); // 把 字符串 s1 的引用传给函数

    println!("The length of '{}' is {}.", s1, len); // 这里可以继续使用 s1
}

fn calculate_length(s: &amp;String) -&gt; usize { // 接收到 字符串 s1 的引用 s
    s.len()  // 这里返回函数的长度
} // s 超出作用域,但是这里没有字符串的所有权,不释放内存

&s1 语法是创建一个指向 s1 的值的引用,而不是 s1 本身,当引用超出作用域不会释放引用指向值的内存。被调用函数声明参数的时候,参数的类型也需要使用 & 来告知函数接收的参数是个引用。

修改引用

在上述例子中,如果在 calculate_length 函数中修改字符串的内容,编译器会报错,因为传入的引用在默认情况下是不可变引用,如果想要修改引用的内容,需要添加关键字 mut,看例子:

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

    change(&amp;mut s); // mut 同意函数修改 s 的值
}

fn change(some_string: &amp;mut String) { // mut 声明函数需要修改 some_string 的值
    some_string.push_str(", world");	// 追加字符串
}

可变引用有一个很大的限制:在特定作用域中针对同一引用,只能有一个可变引用。比如:

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

let r1 = &amp;mut s; // 这是第一个借用的可变引用
let r2 = &amp;mut s; // 这是第二个借用的可变引用,这里会编译不通过

println!("{}, {}", r1, r2);

这个限制的好处是编译器可以编译期间阻止数据竞争,数据竞争发生在如下情况:

数据竞争会造成不可预知的错误,而且在运行时修复是很困难的,rust 在编译期间就阻止了数据竞争情况的发生。但是在不同的作用域下,是可以有多个可变引用的,比如:

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

{
    let r1 = &amp;mut s;

} // r1 超出作用域

// 这里可以借用新的可变引用了
let r2 = &amp;mut s;

可变引用和不可变引用放在一起,也会出错,比如:

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

let r1 = &amp;s; // 不可变引用,没问题
let r2 = &amp;s; // 不可变引用,没问题
let r3 = &amp;mut s; // 可变引用,会发生大问题,因为后面还在使用 r1 和 r2

println!("{}, {}, and {}", r1, r2, r3);

当存在不可变引用时,就不能再借用可变引用了。不可变引用不会修改引用的值,所以可以借用多个不可变引用。但是如果不可变引用都不使用了,就又可以借用可变引用了,比如:

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

let r1 = &amp;s; // 不可变引用,没问题
let r2 = &amp;s; // 不可变引用,没问题
println!("{} and {}", r1, r2);
// r1 和 r2 从这里开始不再使用了

let r3 = &amp;mut s; // 可变引用,也没问题了,因为后面没使用 r1 和 r2 的了
println!("{}", r3);

悬空引用

在一些指针语言中,很容易就会错误地创建悬空指针。悬空指针就是过早地释放了指针指向的内存,也就是说,堆内存已经释放了,而指针还指向这块堆内存。在 rust 中,编译器可以保证不会产生悬空引用:如果有引用指向数据,编译器会确保引用指向的数据不会超出作用域,比如:

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -&gt; &amp;String { // 这里希望返回字条串的引用
    let s = String::from("hello"); // 创建字符串

    &amp;s // 这里返回了字符串的引用

} // 这里会把字符串的内存释放,因为 s 在这里超出作用域

这个函数做个简单的修改就好了,看如下例子:

fn no_dangle() -&gt; String { // 不返回字符串引用了,直接返回字符串
    let s = String::from("hello");

    s // 返回字符串
}

引用规则

引用的规则如下:

切片类型

另一个没有所有权的数据类型是切片。切片是集合中相邻的一系列元素,而不是整个集合。

<br>

做个小小的编程题目:有一个函数,输入一个英文字符串,返回第一个单词。如果字符串没有空格,则认为整个字符串是一个单词,返回整个字符串。

<br>

我们来思考一下这个函数结构:

fn first_word(s: &amp;String) -&gt; ?   // 这里应该返回什么

在这个函数中,字符串引用作参数,函数没有字符串的所有权,那我们应该返回什么呢?我们不能返回字符串的一部分,那么,我们可以返回第一个单词结束位置的索引。看实现:

fn first_word(s: &amp;String) -&gt; usize { // 返回一个无符号整型,因为索引不会小于 0

    let bytes = s.as_bytes(); // 把字符串转换化字节类型的数组

    // iter 方法用于遍历字节数组,enumerate 方法用于返回一个元组,元组的第 0 个元素是索引,第 1 个元素是字节数组的元素
    for (i, &amp;item) in bytes.iter().enumerate() {

        if item == b' ' { // 如果找到了空格,就返回对应的索引
            return i;
        }
    }

    s.len() // 如果没找到空格,就返回字符串的长度
}

现在,我们找到了返回字符串第一个单词的末尾索引,但是还有一个问题:函数返回的是一个无符号整型,返回值只是字符串中的一个有意义的数字。换句话说,返回值和字符串是分开的值,不能保证它永远有意义,比如:

fn main() {
    let mut s = String::from("hello world"); // 创建字符串

    let word = first_word(&amp;s); // word 被赋值为 5

    s.clear(); // 清空字符串,现在字符串的值是 ""

    // word 仍是5,但是我们不能得到单词 hello 了,这里使用 word,编译器也不会报错,但是这真的是一个 bug
}

还有一个问题,如果我们想得到第二个单词,应该怎么办?函数声明应该是:

fn second_word(s: &amp;String) -&gt; (usize, usize) {

如果想得到很多个单词,又应该怎么办?

字符串切片

字符串切片就是字符串一部分的引用,如下:

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

let hello = &amp;s[0..5];
let world = &amp;s[6..11];

就是取字符串 s 中的一部分组成一个新的变量,取值区间左闭右开,就是说,包括左边的索引,不包括右边的索引。

<br>

如果左边索引是0,可省略:

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

let slice = &amp;s[0..2];
let slice = &amp;s[..2]; // 和上一行等价

如果右边索引是字符串末尾,可省略:

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

let len = s.len();

let slice = &amp;s[3..len];
let slice = &amp;s[3..]; // 和上一行等价

如果取整个字符串,可以把两边都省略:

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

let len = s.len();

let slice = &amp;s[0..len];
let slice = &amp;s[..]; // 和上一行等价

我们现在看一下一开始讨论的题目应该怎么做:

fn first_word(s: &amp;String) -&gt; &amp;str {
    let bytes = s.as_bytes();

    for (i, &amp;item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &amp;s[0..i];
        }
    }

    &amp;s[..]
}

这样就直接返回了第一个单词的内容。如果要返回第二个单词,可写成:

fn second_word(s: &amp;String) -&gt; &amp;str {

我们再来看一下字符串清空的问题是否还存在:

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

    let word = first_word(&amp;s); // 不可变借用在这里声明

    s.clear(); // 这里会报错,因为这里在修改 s 的内容

    println!("the first word is: {}", word); // 不可变借用在这里使用
}

不可变借用的声明和使用之间是不能使用可变借用的。

字符串文字是切片

前面我们讨论过字符串文字的存储问题,现在我们学习了切片,我们可以理解字符串文字了:

let s = "Hello, world!";

s 的类型是 &str,这是一个指向了二进制程序特殊的位置的切片,这就是字符串文字不可变的原是,&str 是一个不可变引用

字符串切片作为参数

前面学习了字符串文字切片和字符串类型切片,我们来提高 first_word 函数的质量。有经验的 rust 开发者会把函数参数类型写成 &str,因为这样可以使得 &String 和 &str 使用相同的函数。好像不太好理解,直接上例子:

fn main() {
    let my_string = String::from("hello world"); // 创建字符串

    // first_word 使用 &amp;String切片
    let word = first_word(&amp;my_string[..]);

    let my_string_literal = "hello world"; // 创建字符串

    // first_word 使用 &amp;str切片
    let word = first_word(&amp;my_string_literal[..]);

    // 因为字符串文字已经是字符串切片了,可以不使用切片语法
    let word = first_word(my_string_literal);
}

其它切片

我们只举一个 i32 类型切片的例子吧:

let a = [1, 2, 3, 4, 5];

let slice = &amp;a[1..3];  // 值是: [2, 3]

rust 使用了所有权、借用、切片,在编译期确保程序的内存安全。rust 语言提供了和其他编程语言相同的方式来控制内存,而不需要我们编写额外代码来手动管理内存,当数据超出所有者的作用域就会被自动清理。

欢迎阅读单鹏飞的学习笔记

关注公众号【好便宜】( ID:haopianyi222 ),领红包啦~
阿里云,国内最大的云服务商,注册就送数千元优惠券:https://t.cn/AiQe5A0g
腾讯云,良心云,价格优惠: https://t.cn/AieHwwKl
搬瓦工,CN2 GIA 优质线路,搭梯子、海外建站推荐: https://t.cn/AieHwfX9
扫一扫关注公众号添加购物返利助手,领红包
Comments are closed.

推荐使用阿里云服务器

超多优惠券

服务器最低一折,一年不到100!

朕已阅去看看