为什么 \"&str\" 和 \"&String\" 被视为对相同值的引用？

Answer 1

我想你误会了。

String 是不是str 的可变版本。这是它自己的类型。

let mut x: String 是 let x: String 的可变版本。

String 是拥有并且可以修改。 str 是“切片”类型，它指的是字符串的内容，可以在String 内部，也可以在全局内存中以&'static str 的形式出现。

没有mut str，因为str 根据定义是对字符串不可变部分的引用。

---

让我们看看你的代码。 （将str 重命名为s，因为这太混乱了）

fn main() {
    // Your variable `s` is `mut String`. It is a mutable string.
    let mut s: String = String::from("hello");
    
    // Your variable `slice` is a `&str`.
    // It isn't mutable, it is a reference to a substring of `s`.
    let slice: &str = &s[0..2]; // #1
    
    // Here we already hold an immutable reference to `s` through the `slice` variable.
    // This prevents us from modifying `s`, because you cannot reference an object mutably while
    // it is borrowed immutably.
    s.clear(); // #2

    // This line is only important to force the variable `slice` to exist.
    // Otherwise the compiler would be allowed to drop it before the `s.clear()` call,
    // and everything would compile fine.
    println!("{}", slice);
}

那里没有&String。通过&s[0..2] 获取String 的一部分会自动创建&str，因为这就是specification of String says：

fn index(&self, index: Range) -> &str

---

为什么它违反了上面似乎只适用于相同类型的引用的原则？

这是不正确的。它们不必是同一类型。如果您持有一个引用了String 内容的&str，那么当&str 引用存在时，String 对象也会被阻止发生突变。您甚至可以将引用存储在其他对象中，然后这些对象的存在仍然会阻止原始String。

---

它们绝对是不同的对象

这并不意味着它们无法连接。

为了证明两个不同类型的对象可以具有连接的生命周期，请查看以下代码：

#[derive(Debug)]
struct A {
    pub value: u32,
}

#[derive(Debug)]
struct B<'a> {
    pub reference: &'a u32,
}

impl A {
    pub fn new(value: u32) -> Self {
        Self { value }
    }

    pub fn set(&mut self, value: u32) {
        self.value = value;
    }
}

impl<'a> B<'a> {
    pub fn new(a: &'a A) -> Self {
        Self {
            reference: &a.value,
        }
    }
}

fn main() {
    let mut a = A::new(69);
    println!("a: {:?}", a);

    // Can be modified
    a.set(42);
    println!("a: {:?}", a);

    // Create a B object that references the content of `a`
    let b = B::new(&a);
    println!("b: {:?}", b);

    // While `b exists, it borrows a part of `a` (indicated through the fact that it has a lifetime type attached)
    // That means, while `b` exists, `a` cannot be modified
    a.set(420); // FAILS

    // This ensures that `b` actually still exists
    println!("b: {:?}", b);
}

错误信息很清楚：

error[E0502]: cannot borrow `a` as mutable because it is also borrowed as immutable
  --> src/main.rs:43:5
   |
38 |     let b = B::new(&a);
   |                    -- immutable borrow occurs here
...
43 |     a.set(420); // FAILS
   |     ^^^^^^^^^^ mutable borrow occurs here
...
46 |     println!("b: {:?}", b);
   |                         - immutable borrow later used here

请注意，B 类型附加了一个生命周期 'a。此生命周期将由编译器在实例化时自动派生，并用于防止在 B 存在时对引用的 A 对象进行可变使用。

&str 还附加了一个生命周期，用于防止对引用的 String 对象进行可变访问。

---

我希望这能澄清一些事情。如果您还有其他问题，请随时提问。