【问题标题】:Apply some functions on a struct owning those functions在拥有这些函数的结构上应用一些函数
【发布时间】:2016-01-02 10:38:02
【问题描述】:

我想在拥有这些函数的结构上应用一些函数。

第一次尝试:

struct VM {
    buffer: Vec<fn(&mut VM)>,
    stack: Vec<isize>,
}

impl VM {
    fn new() -> VM {
        VM {
            buffer: vec![VM::op_zero, VM::op_drop],
            stack: vec![],
        }
    }
    fn op_zero(&mut self) { self.stack.push(0); }
    fn op_drop(&mut self) {
        match self.stack.pop() {
            Some(i) => println!("drop {}", i),
            None => println!("stack underflow!")
        }
    }
    fn evaluate(&mut self) {
        for op in self.buffer {
            op(self);
        }
    }
}

fn main() {
    let mut vm = VM::new();
    vm.evaluate();
}

这不起作用,因为要移出借用的内容。我在self.buffer 之前添加了一个&amp;,但它仍然不起作用,因为self.buffer 也被借用为不可变。

fn evaluate(&mut self) {
    for op in &self.buffer {
        op(self);
    }
}

第三次尝试有效,但有运行时边界检查数组索引的开销:

fn evaluate(&mut self) {
    let len = self.buffer.len();
    for i in 0..len {
        let op = self.buffer[i];
        op(self);
    }
}

有没有更好的方法来解决借用检查器问题?

【问题讨论】:

  • 如果他们不使用self,将self 传递给ops 是没有意义的,并且他们如何使用self 会改变这是否安全。我觉得你的例子不够。

标签: iterator rust lifetime


【解决方案1】:

您不应该真的试图“绕过借用检查器”。它会阻止您这样做,因为无法保证您调用的 ops 不会与您尝试迭代的缓冲区混淆。事实上,您的最终代码也有同样的问题:op 可能截断缓冲区,当您尝试读取向量末尾时会导致恐慌。

一种安全的方法是在评估时换掉buffer。假设您不打算多次评估相同的指令序列:

fn evaluate(&mut self) {
    use std::mem;
    for op in mem::replace(&mut self.buffer, vec![]) {
        op(self);
    }
}

在这种情况下,新缓冲区可以被调用的ops 修改,而不会干扰evaluate。

【讨论】:

  • 假设您不打算多次评估相同的指令序列 — 在完成迭代、恢复对象后,您始终可以replace 原始向量回到原来的状态。
  • @Shepmaster 是的,但是问题然后变成了:如果操作将操作添加到现在为空的缓冲区会发生什么?你附加这些吗?准备他们?丢弃它们?我当时不想混淆这个问题。 :P
  • 哦,当然。我知道你知道你可以把它放回去,我只是想确保未来的读者也能意识到这一点!
猜你喜欢
  • 1970-01-01
  • 2011-10-18
  • 2015-08-29
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多