在 rust 中从 HashMap 中删除一个随机条目

Question

我想从HashMap删除一个随机元素。 但是，我一直收到此错误。

error[E0502]: cannot borrow `self.map` as mutable because it is also borrowed as immutable
  --> src/main.rs:23:9
   |
21 |         let key_to_delete = self.map.keys().skip(x).next().unwrap();
   |                             -------- immutable borrow occurs here
22 |         println!("key_to_delete: {:?}", key_to_delete);
23 |         self.map.remove(&key_to_delete);
   |         ^^^^^^^^^------^^^^^^^^^^^^^^^^
   |         |        |
   |         |        immutable borrow later used by call
   |         mutable borrow occurs here

error: aborting due to previous error

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

但是，如果我在该行的末尾添加.clone() ，则错误消失了。 虽然我解决了这个问题（主要是通过反复试验），但我仍然不明白它为什么会起作用。 具体来说，为什么首先出现这个错误？ 不应该在该行之后删除对self.map的不可变引用

let key_to_delete = self.map.keys().skip(x).next().unwrap()

执行完毕？ 在这个例子中，密钥是i32类型，它只需要 4 个字节。 因此，克隆是可以的。 但是，如果密钥是某个大的结构体，或者由于其他原因不需要clone怎么办？ 那我该如何解决这个问题呢？

另一个观察结果是我的 IDE（带有 rust 插件的 Intellij）显示key_to_delete的类型是&i32如果我没有.clone()和i32如果我有。 我不确定这是否重要。

任何澄清表示赞赏。

这是我的代码。

use std::collections::HashMap;
use rand::{Rng, thread_rng};

#[derive(Debug)]
struct MyStruct {
    map: HashMap<i32, i32>,
}

impl MyStruct {
    fn new() -> Self {
        MyStruct { map: HashMap::new() }
    }

    fn add(&mut self, key: i32, value: i32) {
        self.map.insert(key, value);
        println!("after add: {:?}", self.map);
    }

    fn delete(&mut self) {
        let x: usize = thread_rng().gen_range(0..self.map.len());
        let key_to_delete = self.map.keys().skip(x).next().unwrap().clone(); // this "clone" is critical
        println!("key_to_delete: {:?}", key_to_delete);
        self.map.remove(&key_to_delete);
        println!("map after delete: {:?}", self.map);
    }
}

fn main() {
    let mut c = MyStruct::new();
    c.add(1, 2);
    c.add(3, 4);
    c.add(5, 6);
    c.delete();
}

Answer 1

当您调用self.map.keys().skip(x).next().unwrap()您不会得到键 - 您会得到对键的引用。

Rust 保证这个引用在它存在的时候一直有效——这就是 Rust 借用检查器和内存安全背后的整个想法。 在我们的例子中，这意味着 Rust 保证映射中的键（连同关联的值）将存在于映射中，只要您对键的引用有效。

但是 Rust 编译器强制执行它的方式相当残酷——它只是不允许你以任何方式改变地图的状态，只要你对关键的引用有效。 不幸的是，因此，您无法使用您的参考从地图中删除其相应的条目。

为了说明这一点，让我们看一个稍微修改过的代码版本：

fn delete(&mut self) { //not really a delete at this point
    let x: usize = thread_rng().gen_range(0..self.map.len());
    let key_to_delete = self.map.keys().skip(x).next().unwrap(); // this "clone" is gone
    self.map.insert(123, 456); // <- this will cause a compiler error
    println!("key_to_delete: {:?}", key_to_delete);
    // self.map.insert(123, 456);  // <- this will not cause a compiler error as the reference to the key no longer exists
    println!("map after delete: {:?}", self.map);
}

在这里，我已将remove更改为insert以便我们知道我们不会冒密钥可能被删除的风险。 然而，代码无法编译的原因与您最初报告的原因完全相同。

Answer 2

至少可以在当前 Nightly 上使用实验性hash_raw_entry功能hash_raw_entry键未实现Clone的HashMap删除任意条目，以某种迂回的方式：

#![feature(build_hasher_simple_hash_one)]
#![feature(hash_raw_entry)]

use std::collections::hash_map::{HashMap, RawEntryMut};
use std::hash::{BuildHasher, Hash};

fn pop<K: Hash, V>(m: &mut HashMap<K, V>) -> Option<(K, V)> {
    let hash = m.hasher().hash_one(m.keys().next()?);

    match m.raw_entry_mut().from_hash(hash, |_| true) {
        RawEntryMut::Occupied(entry) => Some(entry.remove_entry()),
        RawEntryMut::Vacant(_) => unreachable!("no entry with hash of first key"),
    }
}