从Rust书中引用和借用的解释

Question

I'm reading the Rust book and References and Borrowing in Chapter 4 seems to be inconsistent to me. In Reference and Borrowing , figure 4-5 below shows that s points to s1 instead of the actual data on the heap.

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

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

But in String Slices , the diagram clearly shows that world references the actual data, though only part of it. It also says that the following code "is similar to taking a reference to the whole String but with the extra [0..5] bit. Rather than a reference to the entire String, it's a reference to a portion of the String."

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

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

And here is the diagram (figure4-6) that explains the above code:

Now I guess my question is why isn't world referring to s in the String Slices case? I understand that world can't just point to s because then it would not be able to get the last 5 letters. But these two diagrams seem completely different to me, yet they are all "references". Can someone please provide a logical way to understand it?

Thanks!

Answer 1

Well, what does a &[mut] String guarantee in a safe context?

• That there is a String behind the pointer, which therefore supports your first diagram.

Then, what does a &[mut] str guarantee in a safe context?

• The same idea as a String , that there is a str behind the pointer. But what does that mean? What really is an str ?

According to the docs page:

A &str is made up of two components: a pointer to some bytes, and a length.

Meaning, that the &str really is a pointer to some valid utf-8 and a length, so really, a str is the data itself, and not the String . The String can be regarded as a manipulable str . So the &my_string[..] is really a pointer/reference to the data under the String .

Answer 2

A reference to a string and a string slice are different things, so it is normal that they are represented differently.

Most of the time a string slice is more useful, because you can refer to substrings, which makes it more flexible. Generally a function parameter for reading some string data should be a string slice and not a reference to a string.

Also, you can use an actual parameter of type &String for a string slice :

Strings implement Deref, and so inherit all of str's methods. In addition, this means that you can pass a String to a function which takes a &str by using an ampersand (&)

One useful thing you can't do with a slice is increasing the size of a string, in that case you need a mutable reference to the string. An example is the read_line function, which appends string data to buf :

pub fn read_line(&self, buf: &mut String) -> Result<usize>