rust - Rust:可变借款返回非可变借款

Question

This question already has an answer here:

function returns immutable references but borrow checker thinks otherwise

(1个答案)


9天前关闭。




如果在其他地方问过这个问题，我深表歉意，但是我不确定如何找到答案。
我有一段简化的代码，演示了我在更大的软件中遇到的问题。基本上，我(对我而言)似乎是一件物品的2个不可变借项，但是Rust似乎认为其中一项借项是可变的。

struct SomeStruct {
    val: i32
}

fn bor_mut(bor: &mut SomeStruct, new_val: i32) -> &i32 {
    bor.val = new_val;
    &bor.val
}

fn bor_nmut(bor: &SomeStruct) -> &i32 {
    &bor.val
}

fn main() {
    // get two non-mutable borrows,
    // but one originates from a mutable
    // borrow
    let mut s = SomeStruct{val: 1};
    let a = bor_mut(&mut s, 2);
    let b = bor_nmut(&s);
    println!("a = {}, b = {}", a, b);
}

编译此代码将产生以下错误:

error[E0502]: cannot borrow `s` as immutable because it is also borrowed as mutable
  --> src/main.rs:20:22
   |
19 |     let a = bor_mut(&mut s, 2);
   |                     ------ mutable borrow occurs here
20 |     let b = bor_nmut(&s);
   |                      ^^ immutable borrow occurs here
21 |     println!("a = {}, b = {}", a, b);
   |                                - mutable borrow later used here

这只是“可变借款与另一借款”错误代码。但是，在第20行存在的唯一借项是 a，它是不可变的。我知道Rust的来源，因为借用来自不可变的借用，但是当借用本身是不可变的时，我看不到这有什么关系？
我可以认为这样做的唯一原因是为了防止多线程代码破坏借用检查器，但是我似乎无法想到即使在这种情况下也可以提供帮助的情况。但是，如果不是这样，那么借阅检查器的工作方式似乎就被疏忽了。
我希望有人能够向我解释为什么借阅检查器会以这种方式工作？不知何故，这是我第一次遇到此问题。

最佳答案

让我们考虑这个简单的例子:

// We've a buffer with 4 numbers
let mut original_v = vec![0, 1, 2, 3];
// Let's open a scope like if this were the body of a funcion called on `original_v`
{
    let exclusive_borrow = &mut original_v;
    // Let's take a shared reference to the last element
    let shared_borrow_to_first_elem = &v[3];
    
    exclusive_borrow.pop(); // Deletes last element (pointed by the shared reference)
    let v2 = *v1; // This now access invalid memory
}

如果上面的代码可行，那么创建悬空指针将很容易，仅允许1个互斥引用(＆mut)或多个共享引用(＆)，此问题就会消失。我希望它能帮助您理解这个概念。
我知道在您的示例中您没有提交任何此类内容，但是编译器很难检查是否有那么深的悬空指针，因此它只是创建了一个花哨的规则来防止出现此问题。

关于rust - Rust:可变借款返回非可变借款，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/66501707/

上一篇：rust - 当poll_read的缓冲区大小不足以容纳我的缓冲区时该怎么办？

下一篇：rust - 如何正确使用特征对象，可变迭代可变特征对象容器，同时改变容器本身？

Answer 1

让我们考虑这个简单的例子:

// We've a buffer with 4 numbers
let mut original_v = vec![0, 1, 2, 3];
// Let's open a scope like if this were the body of a funcion called on `original_v`
{
    let exclusive_borrow = &mut original_v;
    // Let's take a shared reference to the last element
    let shared_borrow_to_first_elem = &v[3];
    
    exclusive_borrow.pop(); // Deletes last element (pointed by the shared reference)
    let v2 = *v1; // This now access invalid memory
}

如果上面的代码可行，那么创建悬空指针将很容易，仅允许1个互斥引用(＆mut)或多个共享引用(＆)，此问题就会消失。我希望它能帮助您理解这个概念。
我知道在您的示例中您没有提交任何此类内容，但是编译器很难检查是否有那么深的悬空指针，因此它只是创建了一个花哨的规则来防止出现此问题。