在链接列表节点之间复制数据

Question

我正在编写一台虚拟机，目前正在使用链接列表来实现其内存。我已经实施了Malloc，该Malloc在列表中添加了一个新节点，该节点是Malloc要重复使用的节点，现在我正在研究Realloc。我遇到的问题是，由于有两个可变的参考，我无法在链接列表的两个节点之间复制数据，这是一个最小的示例：

use std::collections::LinkedList;

struct MemoryBlock {
    address: u64,
    size: u64,
    data: Vec<u8>
}

struct Memory {
    blocks: LinkedList<MemoryBlock>,
}

impl Memory {
    fn malloc(&mut self, alloc_size: u64) -> u64 {
        self.blocks.push_back(MemoryBlock {
            address: 1,
            size: alloc_size,
            data: vec![0x00]
        });
        
        1
    }

    fn realloc(&mut self, address: u64, new_size: u64) -> u64 {
        let new_address = self.malloc(new_size);
        
        let mut old_block = self.blocks.iter_mut().find(|b| b.address == address).unwrap();
        let mut new_block = self.blocks.iter_mut().find(|b| b.address == new_address).unwrap();
        
        new_block.data[0] = old_block.data[0];
        
        new_address
    }
}

fn main() {
    let mut memory = Memory {
        blocks: LinkedList::new()
    };
    
    memory.blocks.push_back(MemoryBlock {
        address: 0,
        size: 1,
        data: vec![0x00]
    });
    
    memory.realloc(0, 2);
}

我试图使“ old_block”不可分割，但后来我无法有一个可变的和一个不可变的可变的同时借。是否有任何方法可以以不同的方式构造我的代码或任何其他方法（不安全除外）可以使其正常工作？我知道我可以使用矢量，然后将切片用作“黑客”来完成它，但是如果可能的话，我更喜欢使用链接列表。

Answer 1

您可以重组代码，以便Rust编译器知道old_block和new_block指向不同的位置。这也将更加有效，因为linkedlist仅经过一次。

fn realloc(&mut self, address: u64, new_size: u64) -> u64 {
    let new_address = self.malloc(new_size);

    let mut old_block = None;
    let mut new_block = None;

    for block in &mut self.blocks {
        if block.address == address {
            old_block = Some(block);
        } else if block.address == new_address {
            new_block = Some(block);
        }
    }

    new_block.unwrap().data[0] = old_block.unwrap().data[0];

    new_address
}