如何递归传递可变引用？

Question

我正在尝试用 Rust解决这个问题。

这是我的非编译 Rust 代码：

use std::collections::HashMap;

fn main() {
    // initialize HashMap
    let mut fibs: HashMap<u32, u32> = HashMap::new();
    fibs.insert(0, 1);
    fibs.insert(1, 1);
    let mut n = 1;
    let mut sum = 0;
    while fib(n, &mut fibs) < 4000000 {
        sum += if fib(n, &mut fibs) % 2 == 0 {
            fib(n, &mut fibs)
        } else {
            0
        };
        n += 1;
    }
    println!("{}", sum);
}

fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {
    if !fibs.contains_key(&n) {
        fibs.insert(n, fib(n - 1, &mut fibs) + fib(n - 2, &mut fibs));
    }
    *fibs.get(&n).unwrap()
}

use std::collections::HashMap;

fn main() {
    // initialize HashMap
    let mut fibs: HashMap<u32, u32> = HashMap::new();
    fibs.insert(0, 1);
    fibs.insert(1, 1);
    let mut n = 1;
    let mut sum = 0;
    while fib(n, &mut fibs) < 4000000 {
        sum += if fib(n, &mut fibs) % 2 == 0 {
            fib(n, &mut fibs)
        } else {
            0
        };
        n += 1;
    }
    println!("{}", sum);
}

fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {
    if !fibs.contains_key(&n) {
        fibs.insert(n, fib(n - 1, &mut fibs) + fib(n - 2, &mut fibs));
    }
    *fibs.get(&n).unwrap()
}

Rust 到 Python3 的翻译如下：

error[E0596]: cannot borrow `fibs` as mutable, as it is not declared as mutable
  --> src/main.rs:22:35
   |
20 | fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {
   |                ---- help: consider changing this to be mutable: `mut fibs`
21 |     if !fibs.contains_key(&n) {
22 |         fibs.insert(n, fib(n - 1, &mut fibs) + fib(n - 2, &mut fibs));
   |                                   ^^^^^^^^^ cannot borrow as mutable

error[E0499]: cannot borrow `fibs` as mutable more than once at a time
  --> src/main.rs:22:35
   |
22 |         fibs.insert(n, fib(n - 1, &mut fibs) + fib(n - 2, &mut fibs));
   |         ---- ------               ^^^^^^^^^ second mutable borrow occurs here
   |         |    |
   |         |    first borrow later used by call
   |         first mutable borrow occurs here

error[E0596]: cannot borrow `fibs` as mutable, as it is not declared as mutable
  --> src/main.rs:22:59
   |
20 | fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {
   |                ---- help: consider changing this to be mutable: `mut fibs`
21 |     if !fibs.contains_key(&n) {
22 |         fibs.insert(n, fib(n - 1, &mut fibs) + fib(n - 2, &mut fibs));
   |                                                           ^^^^^^^^^ cannot borrow as mutable

error[E0499]: cannot borrow `fibs` as mutable more than once at a time
  --> src/main.rs:22:59
   |
22 |         fibs.insert(n, fib(n - 1, &mut fibs) + fib(n - 2, &mut fibs));
   |         ---- ------ first borrow later used by call       ^^^^^^^^^ second mutable borrow occurs here
   |         |
   |         first mutable borrow occurs here

我知道这个特定的实现并不理想，但我只是想学习该语言。我试图仅将哈希图的引用传递给该函数。HashMap在不改变解决此问题的方法的情况下，如果可能的话，如何使用可变引用？

Answer 1

\n

fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {\n

\n

\n

fibs已经是一个可变引用。在函数中，您说&mut fibs，这将获得对可变引用的可变引用。这没有用，并且与正确的类型不匹配。而是fibs直接通过。

\n

然后你必须拆分两个子调用：

\n

fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {\n    if !fibs.contains_key(&n) {\n        let a = fib(n - 1, fibs);\n        let b = fib(n - 2, fibs);\n        fibs.insert(n, a + b);\n    }\n    *fibs.get(&n).unwrap()\n}\n

\n

最后一点是借用检查器 \xe2\x80\x94 的限制，&mut接收者的嵌套方法调用会导致借用错误，但将它们分成单独的语句可以解决该问题。

\n\n

正如德尔南指出的：

\n

\n

虽然对可变引用进行可变引用没有用，并且会造成一些混乱，但它通常不是类型错误，因为 deref 强制转换可以变成&mut &mut T，&mut T至少当编译器知道这&mut T是预期的情况时。

\n

\n

这反映在编译器错误消息中：

\n

fn fib(n: u32, fibs: &mut HashMap<u32, u32>) -> u32 {\n

\n

事实上，进行建议的更改可以让代码继续处理下一个错误。但是，像这样的嵌套引用会使事情变得过于复杂，因此最好保留适当数量的引用。

\n