Rust: String vs &str


Rust: String vs &str

首发于：简书

funny_rust.jpg

当你开始第一次学习Rust的时候，不知不觉中就会开始对string类型感到困惑，并与编译器斗智斗勇:)，通常你会认为那应该是一个string吧，然后编译器就说: Shut the fu*k up。 （努力保持微笑??

为了帮读者弄清楚Rust中String, &String, str 和 &str的区别和联系，花了一点时间帮你们翻译了一篇文章并努力让它看起来不那么无聊 ??。（不用谢我??，觉得有用的话点个赞叭，谢谢啦～

首先，我们来看一个炒鸡简单的函数：向老铁问好！

1
2
3
4
5
6
7
8
fn main() {
  let friend_name = "laotie";
  greet(friend_name);
}

fn greet(name: String) {
  println!("{}!, what's up", name);
}

如果你尝试编译这段代码，编译器就会教你做人（大雾

来看看错误信息叭

1
2
3
4
5
6
7
8
9
10
11
12
error[E0308]: mismatched types
 --> src/main.rs:3:9
  |
3 |   greet(friend_name);
  |         ^^^^^^^^^^^
  |         |
  |         expected struct `std::string::String`, found `&str`
  |         help: try using a conversion method: `friend_name.to_string()`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.

你可以在Rust-playground中运行这段代码，点"Run"就可以啦。

这里的错误信息还是很容易看懂的，greet函数本来想要一个std::string::String类型，但是你却给了它一个&str类型，所以出错啦，并且编译器还给出了可能的修正方法。所以按照编译器说的，把第三行改为let friend_name = "laotie".to_string()就可以了。

同时，它也引出了下面几个问题：

  • 这段代码的背后发生了什么？
  • 什么是&str？
  • 为什么使用函数to_string()来进行显式转换？

理解String类型

要想回答这些问题，最好还是要理解Rust是如何将数据存储在内存中的，可以先去看看官方出品的Rust-Book。

如果你已经安装了Rust，可以在终端或者Powershell中输入: rustup doc --book，然后浏览器就会自动打开那本书了，俗称Rust中的"圣经"。

继续沿用前面的例子，我们来研究一下friend_name在内存中的布局，假设我们接受了编译器的建议：用to_string()将类型转换成了String。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
                    缓冲区(buffer)
                   /   容量(capacity)
                 /   /  长度(length)
               /   /   /
            +–––+–––+–––+
    堆栈框架   │ ? │ 8 │ 6 │ <- friend_name: String
            +–│–+–––+–––+
              │
            [–│–––––––––– 容量 ––––––––––––––]
              │
            +–V–+–––+–––+–––+–––+–––+–––+–––+
       堆   │ l │ a │ o │ t │ i │ e │   │   │
            +–––+–––+–––+–––+–––+–––+–––+–––+

            [–––––––– 长度 –––––––––]

Rust会将friend_name这个String对象存储在栈上，这个栈由一个指向缓冲区的堆分配指针，缓冲区的容量和数据的长度组成。有了这些玩意儿，这个String对象的大小(size)就总是保持确定并且为3个字长。

看到这里你可能会有疑惑，String中的容量和长度有什么不一样的吗？答案是区别很大，容量是指缓冲区的大小，而长度指的缓冲区里存放着的数据的长度。但更值得注意的是，当我们要改变这个String对象里所存储的内容时，它会重新申请缓冲区大小。比如，我们可以用push_str()方法在后面加一些内容(注意要在friend_name前加mut使其可变)。

1
2
let mut friend_name = "laotie"
friend_name.push_str(" shuang ji 666");

事实上，如果你已经非常了解Rust的Vec类型，你早就知道String是啥了，当然如果这样你也不会在看这篇文章了hhh…

总结一下：String就是三个玩意组成的：指向缓冲区的堆分配指针，容量，长度。就这么简单～

理解字符串切片(str)

字符串切片(str)是我们引用别人拥有的字符串文本或者字符串字面量。

如果我们只对名字最后的“双击666”感兴趣，我们可以用如下方法得到部分字符串：

1
2
3
4
let mut friend_name = "laotie".to_string();
my_name.push_str( " shuang ji 666");

let last_text = &my_name[7..];

last_text现在是一个__引用__了friend_name文本的字符串切片（注意，不是字符串切片str, 而是字符串切片的__引用__），它在内存中的布局如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
         friend_name: String   last_text: &str
            [––––––––––––]    [–––––––]
            +–––+––––+––––+–––+–––+–––+
stack frame │ ? │ 32 │ 20 │   │ ? │13 │
            +–│–+––––+––––+–––+–│–+–––+
              │                 │
              │                 +–––––––––+
              │                           │
              │                           │
              │                         [–│––––––––––––––––––––– str –––––––––––––––––––––––]
            +–V–+–––+–––+–––+–––+–––+–––+–V–+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+
       heap │ l │ a │ o │ t │ i │ e │   │ s │ h │ u │ a │ n │ g │   │ j │ i │   │ 6 │ 6 │ 6 │
            +–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+–––+

注意到last_text没有在栈上存储容量信息。这是因为它只是另一个会自己管理容量的String对象的一个引用。重要的地方来了，字符串切片(str)，是unsized的，即大小不确定的。好了，奇怪的事情又出现了，怎么会是不确定的呢？你一个个数也能知道它是13个呀。这是因为str是在堆上存储的，不能直接通过堆获取它的大小信息，因为堆是动态分配的（随时准备重新申请缓冲区大小）。但是&str是fixed sized的，为什么？因为，它其实就是一个地址啊，引用本身就是我们常说的指针啊，它就是地址,比如0x8342e93ef..之类的。同样，在实际中，字符串切片永远是引用所以它们的类型是&str或者str。所以，如果我们以后谈到字符串切片，我们指的是&str而不是str，切记。

那么，&String又是个啥呢？，很好理解了呀，它是一个String对象的引用，就是一个地址: &String -> String(buffer, capcity, length) -> heap(buffer)

我想，这大概就解释清楚了String, &String, str和&str之间的区别。

理解字符串字面量

看完上面那些，我想你大概已经有个感觉了，现在，我们要回答最核心的问题，即"laotie shuang ji 666"这段字符串字面量在Rust中到底是指什么？

回顾上面所讲的，如果我们要使用字符串切片&str，我们要么引用“别人”的字符串，要么自己创建一个字符串字面量。它就是指被一对双引号括起来的玩意：

1
let text = "I love Rust" //这是&str，不是String

接下来的问题是，如果说&str别人的字符串的切片引用，那么字符串字面量是谁的切片引用呢？即这个字符串字面量在当前空间里属于谁呢？

结论是字符串字面量有一点特殊，它们是“预分配文本(preallocated text)”的字符串切片的引用，该文本作为可执行文件的一部分存储在只读(read-only)内存中。换句话说，它是我们程序中附带的“内存”，不依赖堆分配的缓冲区。

这就是说，在执行程序时，堆栈上仍然有一项指向该预分配的内存(preallocated memory)：

1
2
3
4
5
6
7
8
9
10
11
            my_name: &str
            [–––––––––––]
            +–––+–––+
stack frame │ ? │ 6 │
            +–│–+–––+
              │                
              +––+                
                 │
 preallocated  +–V–+–––+–––+–––+–––+–––+
 read-only     │ l │ a │ o │ t │ i │ e │
 memory        +–––+–––+–––+–––+–––+–––+

用白话解释就是，要是它不属于任何人，那我就直接把它放在内存里，然后引用它就完事了，我不关心你到底是谁的，我只知道我能读取你的内容就行了。

读完以上内容，我还希望你注意到一点，&str所指向的字符串切片是不可修改的，因为它是只读的。

用哪个？

显然，这取决于许多因素，但是总的来说，可以肯定的是，如果我们所写的API不依赖于拥有或者改变这个在使用的字符串，它应该是&str的而不是String。于是，可以写出一个改进版本的问好函数:

1
2
3
fn greet(name: &str) {
  println!("Hello, {}!", name);
}

但是，等一下！如果这个API的调用者真的只有String类型且因为不明原因不能将其转为&str类型，咋办？

对Rust来说，完全不是问题，因为有一个超级强大的特性：强制解引用(deref coercing)，允许你使用引用运算符&来转换任何传递的String引用，所以，在API被执行之前，&String转换为&str

1
2
3
4
5
6
7
8
9
10
11
fn main() {
  let name1 = "lao wang";
  let name2 = "zhang san".to_string();

  greet(name1);
  greet(&name2); // `name2`被通过引用传递
}

fn greet(name: &str) {
  println!("Hello, {}!", name);
}

代码

翻译完啦，其实这篇博客省去很多细节没讲，不过，该讲的重点，它们之间的区别，倒是讲清楚了，更多细节我会亲自写一篇博文专门介绍Rust中的字符串，有缘会再见，祝好！