Rust 编程语言的拥有权概念使它能不使用垃圾回收(Garbage Collection)机制就能保证内存的安全性,也是 Rust 的一大特点,因此了解拥有权的工作原理是很重要的。
什么是「拥有权」?
在开始了解「拥有权」之前,我们先来加深一下对于堆栈(stack)和堆积(heap)的认识。
堆栈和堆积分别是指程序在运行阶段所用的两个内存区块。在大部分的编程语言中,我们平常不太需要去思考数据到底是要存在堆栈还是堆积中。但是在像是 Rust 这样的系统编程语言,数据存在于堆栈或堆积中所产生的差异还是不容忽视的。
堆栈和堆积有着不一样的结构。存入堆栈中的数据和从堆栈中拿出的数据顺序是相反的,为先进后出(FILO, First-in-Last-out)的性质。将堆栈处理数据的方式想像成是在叠盘子:当我们要增加更多的盘子的时候,会将盘子放在这叠盘子的最上方;而当我们之后需要盘子的时候,就会从这叠盘子的最上方开始拿。将数据加入堆栈中的动作称作「push」,而将数据从堆栈中拿出的动作称为「pop」。
堆栈因为其访问数据的方式,所以处理速度很快。在加入数据的时候完全不需要去寻找可用的空间来存放,而取得数据的时候也完全不需要去进行搜索,因为其关注的位置永远是在那叠数据的最上方。存入堆栈中的数据大小必须是已知且是固定的。
若是要存的数据无法在编译阶段就决定好大小,或是这笔数据的大小之后可能会有变动,那我们可以将这笔数据放在堆积中。堆积的内存区块相对比较自由,当我们要加入数据的时候,操作系统会去寻找并配置足够的内存空间,然后回传这块内存空间位置的地址,也就是「指针」(pointer)来给 Rust 程序使用,这样的流程称为「allocating」。指针是一个大小已知且固定的值,可以存入堆栈,在使用时会先从堆栈中取得指针,再依照指针所对应的内存位置来访问堆积中实际的数据。
堆积的数据处理方式也可以想像成:我们现在正在一间餐厅里等待带位,我们必须要先告诉店家要用餐的人数,店家就会根据我们的人数来选择适当的桌子,即便我们可能有些人还没到场,但这个桌子的位置已经都预留给我们这群人使用了,所以后来才到的人,可以根据桌号来找到我们,并且有空位可以直接坐下。
访问堆积的数据会比访问堆栈数据的速度还要来得慢,因为堆积的数据必须要透过指针来取得实际数据存放的位置。试想一下,现在有个服务生要替许多桌的客人点餐,最快速的点餐方式就是各桌的客人一次就将所有的餐点好。如果 A 桌的人点了一样餐点,B 桌的人点一样餐点,然后 A 桌的人又要再点一样餐点,后来 B 桌的人也是又要再点一样,这样服务生就必须在这两桌之间跑来跑去,效率就会比较差。此外,「allocating」的堆积空间大小愈大,需要的搜索时间就会愈多。
当我们的代码调用函数时传进函数内的参数和在函数声明内的变量都会「push」进堆栈中,其中当然也可以有指向堆积内存空间用的指针。在函数结束运行后,这些值包括指针都会自动被「pop」出来。然而,在堆积中保存的数据都要另外使用别的方式进行追踪,还要将已经没有用到的数据清空。因为如果堆积中的数据没有进行特别维护的话,即便没有任何的指针指向该堆积中的数据,操作系统和程序也依然会继续在内存中保留这些无用的数据,运行时间愈久所占用的内存就会愈多,造成内存泄漏(memory leak)。所以有些编程语言提供了「垃圾回收机制」,能够定时检查堆积内存空间中,哪些数据是无用的,对其进行清理的动作。而 Rust 编程语言则没有垃圾回收机制,它是利用「拥有权」的概念,订定一些规则,让编译器能够在编译阶段就能够进行相关检查,避免内存泄漏、或是访问到已经被清除的堆积内存位置的情形发生,并且不会消耗任何运行阶段的运算资源。
拥有权的规则
首先,让我们先看以下有关于拥有权的规则:
2. 同一时间,每个值只能分别有一个「拥有者」。
3. 当离开 scope 时,属于该 scope 底下的「拥有者」所持有的值都会被消灭。
使用范围(scope)
「scope」就是在一个程序范围下能够使用的东西,举例来说:
fn main() { // into a new scope
// s is not valid here, it's not yet declared
let s = 1; // s is valid from this point forward
// do stuff with s
} // this scope is now over, and s is no longer valid
大括号 {} 可以创建出一个程序叙述区块,同时也会进入一个新的「scope」。程序第 1 行,遇到了左大括号 {,所以当程序运行到这里时,会进入一个新的「scope」。s 变量是在程序第 3 行才声明出来,因此程序第 2 行无法使用 s 变量。程序第 3 行声明了 s 变量,并且在堆栈中创建了 1 这个值,其「拥有者」为 s 变量。程序第 3 行之后,就可以透过 s 变量来取得堆栈中的 1 这个值。程序第 6 行,遇到了右大括号 },因此会离开目前的这个「scope」,在这个「scope」下声明出来的拥有者 s 变量所对应的值 1 会从堆栈中移除,其实也就是我们先前提到的函数在运行结束后自动「pop」堆栈的观念。
我们在前一章节所介绍的数据类型通通都是保存在堆栈中,所以在离开其拥有者所属的「scope」之后,这些值就会被自动消灭。接下来我们来看看当数据是保存在堆积时,Rust 是怎么处理的吧!
String 类型
String 是 Rust 内置的其中一种结构体,在制作猜数字程序的时候我们用过它来保存用户输入的文字。我们并不知道在程序运行阶段,用户输入的文字到底会有多长,在这数据长度不确定的情况下,可以知道 String 结构体的值,其文字部份是会保存在堆积中的。举个例子:
let s = String::from("hello");
以上程序,我们使用了 String 结构体提供的 from 关联函数来产生一个存着 hello 文字的 String 结构体的实体,hello 文字的部份是透过其它的结构体(Vec)存在于堆积中。这个先不管,总之,String 结构体有一部份的数据是保存在堆积中的。
如以下程序:
fn main() {
let mut s = String::from("hello");
s.push_str(", world!"); // push_str() appends a literal to a String
println!("{s}"); // This will print `hello, world!`
}
程序第 4 行使用了 String 结构实体的 push_str 方法来改变原先 String 结构实体所保存的文字。程序运行结果如下:
针对 String 结构体,可以先归纳出以下两点:
String 结构体所使用的内存必须要在程序运行阶段可进行配置。
2. 需要有个方式来让 String 结构体在运行阶段所使用的内存空间,能够在我们用完它之后还给操作系统。
第 1 点,我们在使用 String 结构体提供的 from 关联函数和 String 结构实体的 push_str 方法都会在堆积中配置新的内存空间,这个到目前已经没什么问题了。至于第 2 点,我们该如何撰写程序才能释放原本 String 结构实体所使用到的堆积空间呢?Rust 编程语言没有垃圾回收的机制的话,难道需要写 free 之类的函数吗?
嘿嘿,神奇的来了,事实上,Rust 还是一样会根据拥有权规则的第 3 点,不管是堆栈还是堆积的数据,都会进行消灭,完全不需要加入任何其它的代码。举例来说:
{
let s = String::from("hello"); // s is valid from this point forward
// do stuff with s
} // this scope is now over, and s is no
// longer valid
以上这段代码可以通过编译,而且是安全的,不会有内存泄漏的问题。
至于为什么 Rust 可以确定该堆积中的数据是可以清除的,就是根据拥有权的规则的第 2 点啦!所以不必担心还有什么其它变量也在使用相同堆积中的数据。
让我们继续延伸下去,先看一下底下的代码:
let x = 5;
let y = x;
以上这段程序先声明出变量 x,将其指派了 5 这个值。紧接着又声明了变量 y,将其指派了变量 x 所对应的值。这样将一个变量指派给另一个变量的方式称作「拷贝」(copy)。Rust 在进行数据「拷贝」时,预设会去拷贝变量所对应在堆栈中的值。所以此时堆栈空间会保存两个 5,它们的拥有者分别是变量 x 和变量 y。
如果代码是写成:
let s1 = String::from("hello");
let s2 = s1;
由于 String 属于结构体,不属于整数、浮点数、布尔、字符、元组、数组等基本数据类型,且 String 结构并未实作 Copy 这个特性,因此 Rust 会不知道怎么样对 s1 变量所对应的 String 结构实体进行拷贝,此时 Rust 的应对方式就不会是「拷贝」,而是「移动」(move)。因此 s1 变量的值会移动给 s2 变量,经过移动的 s1 变量自此就不能够再被使用,且 String 结构实体的拥有者也会变成 s2 变量。例如:
fn main() {
let s1 = String::from("hello");
let s2 = s1;
println!("{s1}");
}
以上程序第 5 行会编译错误。
虽然 String 结构体并未实作 Copy 特性,但它有实作 Clone 特性,因此若将以上程序改成以下的样子,就可以通过编译。
fn main() {
let s1 = String::from("hello");
let s2 = s1.clone();
println!("{s1}");
}
函数和拥有权
调用函数时传递参数的方式和以上介绍的「将一个变量指派给另一个变量」的方式一样,如果要传递的值属于基本数据类型,或是有实作 Copy 特性,就会使用「拷贝」的方式来传值;如果不是,就会使用「移动」的方式来传值。
举例来说:
fn main() {
let s = String::from("hello"); // s comes into scope.
takes_ownership(s); // s's value moves into the function...
// ... and so is no longer valid here.
// println!("{s}");
let x = 5; // x comes into scope.
makes_copy(x); // x would move into the function,
// but i32 is Copy, so it's okay to still
// use x afterward.
// println!("{x}");
} // Here, x goes out of scope, then s. But since s's value was moved, nothing
// special happens.
fn takes_ownership(some_string: String) { // some_string comes into scope.
println!("{some_string}");
} // Here, some_string goes out of scope and `drop` is called. The backing
// memory is freed.
fn makes_copy(some_integer: i32) { // some_integer comes into scope.
println!("{some_integer}");
} // Here, some_integer goes out of scope. Nothing special happens.
以上程序,若将第 6 行解除注解,程序会编译失败;若将第 13 行解除注解,程序依然可以编译成功。
再来看看以下这个函数:
fn gives_ownership() -> String {
let some_string = String::from("hello");
some_string
}
如果依照我们目前所知道的 Rust 观念来进行推论的话,这个函数似乎是有一些问题存在的。因为我们在函数的主体 scope 中声明 some_string 变量,又将 some_string 作为回传值,那么当离开这个函数主体的 scope 时,那个 hello 文字的 String 结构实体不是就会被消灭吗?回传出去的 some_string 变量所对应的值还能正常使用?
以上的推论是错的。事实上,函数的回传值也适用「拷贝」和「移动」的观念。以上函数在回传 some_string 变量所对应的值之后,some_string 变量就算是一个已经被「移动」过的变量了,此时 hello 文字的 String 结构实体的拥有者就不是 some_string 变量。所以当离开此函数的主体 scope 时,并不会把 hello 文字的 String 结构实体消灭掉。
虽然 Rust 编程语言这样的设计可以让程序变得很安全,不会去错误访问堆积中的数据,也可以保证不会有内存泄漏的情形发生。但如果每次使用「移动」的参数传递方式调用函数后,变量都会因为已经被「移动」而无法使用,好像也挺困扰的。举例来说:
fn main() {
let s = String::from("hello");
let len = calculate_length(s);
println!("The length of '{s}' is {len}.");
}
fn calculate_length(s: String) -> usize {
let length = s.len(); // len() returns the length of a String.
length
}
以上程序看起来很合理,但是在程序第 6 行会编译失败,因为 s 变量已经被「移动」而无法使用了。
嗯,或许我们可以把传进函数的 s 变量再借由该函数回传回来?
fn main() {
let s1 = String::from("hello");
let (s2, len) = calculate_length(s1);
println!("The length of '{s2}' is {len}.");
}
fn calculate_length(s: String) -> (String, usize) {
let length = s.len(); // len() returns the length of a String.
(s, length)
}
以上程序的确可以通过编译,但是这样的写法实在是太白痴了。别紧张,我们还有一个很重要的观念还没学到,那就是「参考」(reference)。
参考和借用
再次改写刚才的 calculate_length 程序:
fn main() {
let s = String::from("hello");
let len = calculate_length(&s);
println!("The length of '{s}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
程序第 9 行,我们将 calculate_length 函数的 s 参数改为 &String 类型。并且在程序第 4 行调用 calculate_length 函数时使用 &s 来代入参数。& 符号代表「参考」(reference)。在访问变量时如果在变量前方加上 &,表示要取得这个变量的「参考」,而参考的类型就是该值的类型名称前再加上 &。也就是说 &s 的类型为 &String,因此可以代入至 calculate_length 函数的第 1 个参数。
变量的「参考」其实就是一个指到该变量在内存中位置的指针,透过指派「参考」给其它变量,或是作为参数传进函数内,都不会导致原本的变量被「移动」。也因此改写之后的程序是可以正常编译和运行的。
在 Rust 编程语言中,参考类型和一般类型的变量都是使用 . 来访问其类型定义的字段或是方法。若在参考类型的变量前加上星号 *,则表示要对该参考进行「解参考」(dereferencing)。事实上,以上程序的第 10 行会等于:
(*s).len()
由于这种写法不好看,而且会让代码变得冗长,所以 Rust 直接允许像使用一般类型的变量访问其成员的方式来使用参考类型的变量,会自动进行「解参考」的动作。
我们将指派变量的参考给其它变量,或是以参考传递函数参数的方式称为「借用」(borrowing)。就像是在现实生活中,如果某人拥有某个东西,我们可以跟他借来使用一样,这个东西的拥有者并不会因此而改变。
接着来看一下这个程序:
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}
以上程序会编译错误,因为程序第 7 行,定义 some_string 参数的类型时,并没有使用 mut 关键字,因此这个参数是不可变的,自然就无法使用会改变自身值的 push_str 方法。
我们预期这个程序,在运行 change 函数之后,main 函数中声明的 s 变量所对应的 String 结构实体保存的文字会被改变。也就是说我们在程序第 2 行,声明 s 变量时,就应该要加上 mut 关键字了,当然程序第 7 行,定义 some_string 参数的类型时,也要加上 mut 关键字。
改写后的代码如下:
fn main() {
let mut s = String::from("hello");
change(&s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
实际编译程序,会发现程序第 4 行还是会错,这是因为 &String 和 &mut String 是不一样的类型。所以我们还要将程序第 4 行进行改写:
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
在变量前加上 &mut,可以取得其可变参考。
为了维持程序的安全性,使用可变参考有个很大的限制,那就是一个变量在一个 scope 下,同时只能够有一个可变参考。举例来说:
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{r1}, {r2}");
}
以上程序,第 5 行会出现编译错误,因为程序第 4 行已经有一个变量 s 可变的参考了,而且这个参考在第 7 行还会被使用。
Rust 编程语言这样的设计方式可以避免掉使用多个可变参考而可能造成的「数据竞争」(data race)问题。
数据竞争发生的条件如下:
2. 在访问数据的同时,有一个以上的指针正在被用来修改其所指的数据。
3. 没有加入同步的机制。
在程序运行阶段遇到数据竞争问题的话会非常麻烦,因为程序的运行结果每次都会不一样,以致于很难找出发生问题的源头。不过,Rust 编程语言透过限定可变参考数量的机制,在编译阶段就避免掉这个问题,省下很多麻烦。
在一个 scope 下,不可变参考和可变参考也不能同时使用。举例来说:
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM
println!("{r1}, {r2}, and {r3}");
要注意的是,参考的 scope 是从它被创建的地方开始,到它最后一次被使用的地方为止。所以如果以上程序没有最后的 println!,变量 r1、r2 在 r3 被创建之前就已经不会再被使用了,程序还是可以通过编译。
可变的变量被借给其它变量使用之后,在尚未归还前,都不能再被改变。举例来说:
fn main() {
let mut a = 1;
let b = &a;
// a = 1;
println!("a = {a}, b = {b}");
}
以上程序可以通过编译,但是如果将第 5 行取消注解,程序就会编译失败,因为变量 a 的值已经借给变量 b 使用,而变量 b 在第 6 行还会被使用。
变量被借给其它变量使用之后,在尚未归还前,都不能再被「移动」。举例来说:
fn main() {
let a = String::from("hi");
let b = &a;
let c = a;
println!("{b}");
}
以上程序,由于变量 a 借给变量 b 使用,且变量 b 在第 6 行还会被使用,所以第 4 行会编译错误。
切片(slice)
除了参考之外,还有另外一种数据类型没有拥有权,那就是「切片」。「切片」类型能够让我们参考到某个集合内连续的元素,而不是整个集合。
来写个程序练习看看吧!实作一个函数,这个函数可以取得传入这个函数的字符串值的第一个「字」(word)。
首先,我们要先定义这个函数的签名,也就是函数名称和函数的参数。
fn first_word(s: &String)
我们将这个函数取名为 first_word,并且让它有一个参数可以传入类型为 &String 的值,因为我们不想要拿走传进来的值的拥有权,所以在这里使用参考类型。签名定义好之后,我们该让这个函数回传什么东西呢?根据题目,我们应该要回传 s 参数的子字符串(substring),且这个子字符串是 s 参数字符串的第一个字,以我们现在学到的 Rust 基础,似乎还不能处理「取得子字符串」的问题。没关系,我们就先让函数回传这个子字符串的「长度」吧!
fn first_word(s: &String) -> usize
接着要来实作这个 first_word 函数的主体,为了要取得第一个字,我们需要去搜索输入的字符串第一个空格字符出现的位置,在这个空格之前的子字符串就是这个字符串的第一个字。如果这个字符串没有空格,那第一个字就是这个字符串本身。
可以撰写出以下程序:
fn first_word(s: &String) -> usize {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return i;
}
}
s.len()
}
程序第 2 行,使用了 String 结构实体的 as_bytes 方法,直接将内存中使用 UTF-8 编码的字符串数据,以不可变参考的方式回传出来,类型为 &[u8],也就是 8 比特的无号整数数组。
程序第 4 行,使用了 for 循环,且迭代器另外调用了 enumerate 方法,这个方法在上一章有稍微提到过,它可以使走访的值变成一个元组。元组内第一个值表示当下是第几次的迭代,应用在此即为目前走访到的数组的索引值,类型为 usize;元组内的第二个值为元素的值,类型为 &u8,为了避免元素在走访时被拷贝,迭代器都会以元素的参考类型来回传元素。但是在这里我们却使用 &item 来接收元素值,而不是直接使用 item,到底是怎么回事呢?
先看一下这个代码:
fn main() {
let a = 1; // i32
let b = &a; // &i32
let &c = b; // i32
let d = *b; // i32
println!("a = {a}, b = {b}, c = {c}, d = {d}");
}
以上程序,变量 a、b、c、d 的类型分别是 i32、&i32、i32、i32。第 3 进程式,将变量 a 的参考存到变量 b。第 4 进程式,let 关键字后面的 &c 会先将变量 b 的值,也就是变量 a 的参考「解参考」,再将得到的值「拷贝」之后,存到变量 c。第 5 进程式,将变量 b 的值,也就是变量 a 的参考「解参考」之后的值,「拷贝」之后,存到变量 d。也就是说,这段程序的变量 c 和变量 d 的作用其实是一样的,它们都是使用跟变量 a 不同的内存空间。在声明变量时,在变量名称前面接上 &,表示要先对指派给这个变量的参考进行「解参考」,再将得到的值存到这个变量中。
回到刚才的 first_word 函数,如果程序第 4 行的 &item 是写成 item 的话,那么它在第 5 行用来判断是否为空格字符的时候,就必须加上星号 * 进行「解参考」。如下:
for (i, item) in bytes.iter().enumerate() {
if *item == b' ' {
return i;
}
}
此外,也可以用单独一个变量来保存利用 enumerate 方法进行走访所回传的元组。如下:
for t in bytes.iter().enumerate() {
if *t.1 == b' ' {
return t.0;
}
}
不管我们用的方式是什么,借由目前 first_word 函数的逻辑,我们已经可以知道我们要找的子字符串位于原本字符串中的索引范围了,剩下的工作就是让 first_word 函数也能够回传这个索引范围中的子字符串。
字符串切片
「字符串切片」就是一个指到某个字符串的子字符串的参考。使用时的程序语法如下:
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
类似取得变量的参考的语法,先在变量前加上 & 后,再接中括号 [],并在中括号内决定要参考的索引范围 start..end,这里要注意的是,参考到的元素并不包括索引值为 end 的元素。
每次创建出一个切片的时候,Rust 程序并不会去拷贝新的值出来,取而代之的是它会产生出一个保存着内存起始地址和数据的长度的结构实体。像是以上程序的 hello 变量,其被指派的值会记录着 s[0] 的内存地址,和 5 这个长度。这样的作法可以避免在使用切片后会在内存中拷贝出同样的数据,减少内存的用量。
.. 为 Rust 的范围语法,我们在前面的章节介绍 for 循环也有使用过,不算陌生,只不过当它用在「切片」的时候,会有几个特殊的写法。
例如:
let s = String::from("hello");
let slice = &s[0..2];
let slice = &s[..2];
以上两行声明 slice 变量的叙述,都是使用相同的值。省略索引范围 start..end 中的 start 部份,会自动从索引 0 开始算起。
再举一个例子:
let s = String::from("hello");
let len = s.len();
let slice = &s[3..len];
let slice = &s[3..];
以上两行声明 slice 变量的叙述,都是使用相同的值。索引范围 start..end 的 start,除了直接在代码内写上数值之外,也可以用变量或是表达式代替。省略 end 部份的话,会自动算到集合中最后的元素。
当然,索引范围的 start 和 end 也可以都省略。例如:
let s = String::from("hello");
let len = s.len();
let slice = &s[0..len];
let slice = &s[..];
以上两行声明 slice 变量的叙述,都是使用相同的值。索引范围只写 .. 的话,代表要包含所有的元素。
字符串类型和数组类型不能混为一谈,虽然字符串类型可以使用切片的方式利用索引值来取得内存中使用 UTF-8 编码的字符串原始数据,也就是 u8 类型数组,但是它不能够直接像数组一样使用中括号 [] 加上一个索引值来指定要访问哪个字符。
例如:
let s = String::from("hello");
let h = s[0];
以上程序会编译失败,因为 Rust 的字符串基于安全考量,并不提供这样的用法。这个部份在之后的章节会详细介绍。
然而如果改用字符串切片的方式来取得子字符串,程序就可以通过编译了:
let s = String::from("hello");
let h = &s[0..1];
此外,也是基于安全考量,即便 Rust 替字符串加入了方便的切片功能,但因为 Rust 预设的字符串类型使用 UTF-8 编码,在取得原始数据后,必须要能够准确地将索引范围切在字符和字符之间。会这么说是因为,使用 UTF-8 编码字符,一个字符可能会以 1 个字节(byte,或是 u8)、2 个字节、3 个字节,甚至是 4 个字节来表示,如果进行字符串切片的时候正好把本应该用来一起表示为一个字符的数据切开,程序就会发生 panic,使用时要非常小心。
例如:
fn main() {
let s = String::from("中文");
let c = &s[0..1];
println!("{c}");
}
以上程序可以通过编译,但是会在运行到第 3 行的时候发生 panic,因为「中」这个字必须要用 3 个字节的数据来表示,而指派给 c 变量的字符串切片范围却只有切到数据的第 1 个字节。
fn main() {
let s = String::from("中文");
let c = &s[0..3];
println!("{c}");
}
以上程序才可以编译并运行成功。由于字符串类型跟数组等集合类型的类型不同,算是特别支持的,Rust 有替字符串切片订定了一个类型 &str,且直接写在代码内的字符串,类型就是使用 &str。
在了解切片和字符串切片的限制之后,我们来改写 first_word 函数吧!改写后代码如下:
fn first_word(s: &String) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[..i];
}
}
&s[..]
}
程序第 1 行,让 first_word 函数的回传类型为字符串切片,也就是 &str。程序第 6 行,当 for 循环找到空格字符的索引位置后,就直接回传这个索引位置之前范围的字符串切片。程序第 10 行,若都没有找到空格字符,则会将整个传入函数的字符串转成字符串切片来回传。
撰写 main 函数来调用 first_word 函数试试看,程序如下:
fn first_word(s: &String) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[..i];
}
}
&s[..]
}
fn main() {
let s = String::from("hello world");
let word = first_word(&s);
println!("{word}");
}
程序运行结果:
来小改一下 main 函数,让 first_word 函数直接传入写在代码的字符串值。
程序如下:
fn first_word(s: &String) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[..i];
}
}
&s[..]
}
fn main() {
let word = first_word("hello world");
println!("{word}");
}
以上程序第 14 行会编译错误,因为 first_word 函数的第一个参数必须传入 &String 类型的值,而不是 &str。咦,这个 first_word 函数好像不是很好用耶?别紧张,在习惯上,如果字符串不可变的话,都会使用 &str 类型来传递字符串值。修改后的程序如下:
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[..i];
}
}
&s[..]
}
fn main() {
let word = first_word("hello world");
println!("{word}");
}
程序第 1 行,将 first_word 函数的第一个参数类型改为 &str,可以成功编译并运行。同时,虽然 first_word 函数的第一个参数类型改为 &str 了,但依然可以传入 &String 类型的值,因为 &String 到 &str 可以自动转型。
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[..i];
}
}
&s[..]
}
fn main() {
let s = String::from("hello world");
let word = first_word(&s);
println!("{word}");
}
其它切片
除了字符串类型能够切片之外,还有其它属于集合类型的类型也可以转成切片类型。以数组来说,参考以下代码:
fn main() {
let a = [1, 2, 3, 4, 5]; // [i32; 5]
let slice = &a[1..3]; // &[i32]
println!("{:?}", a);
println!("{:?}", slice);
}
以上程序,a 变量的类型为 [i32; 5],是一种数组类型,而 slice 变量的类型为 &[i32],是一种切片类型。程序运行结果如下:
[2, 3]
println! 宏可以在大括号 {} 内加上 :? 来将不同类型的值格式化成字符串。如果要直接在括号内填入变量名称,要放在冒号 : 之前。如下:
fn main() {
let a = [1, 2, 3, 4, 5]; // [i32; 5]
let slice = &a[1..3]; // &[i32]
println!("{a:?}");
println!("{slice:?}");
}
这边还要注意的是,如果只是取得 a 变量的参考,也就是 &a 的话,其类型为 &[i32; 5],跟 &[i32] 并不相同。也就是说,在传递不可变的数组时,我们可以使用其切片类型,如此一来就不必事先知道数组的长度,也可以使用原本的数组参考类型。
举例来说:
fn main() {
let mut a = [1, 2, 3, 4, 5];
print_array(&a);
fill_array(&mut a[2..4], 0);
print_array(&a);
}
fn print_array(arr: &[i32]) {
println!("{arr:?}");
}
fn fill_array(arr: &mut [i32], value: i32) {
for i in arr.iter_mut() { // or for i in arr
*i = value;
}
}
运行结果为:
[1, 2, 0, 0, 5]
至于其它的集合类型和切片用法将会在之后的章节介绍。
总结
我们在这个章节中学会了 Rust 的拥有权概念还有切片的用法,也已经深刻体会 Rust 的严谨代码究竟是怎么样的风格了。在下一章节中,将会介绍结构体的用法。
下一章:使用结构体(struct)。
