首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >移动引用范围内的某物,当这些引用在移动后立即超出范围时

问移动引用范围内的某物,当这些引用在移动后立即超出范围时
EN

Stack Overflow用户
提问于 2022-11-12 12:48:46
回答 1查看 45关注 0票数 1

我正在学习来自C++背景的锈病。我正在编写一个解析器,它读取有效的公式,如12 x (y - 4),并将它们放在抽象语法树(AST)中。我使用枚举将可能的节点存储在AST中,正如您在(严重简化的)代码中所看到的那样。我遇到了一个问题。我想简化表达式-(-(12)),例如,通过移动 12,而不是复制。通常,12可以被深AST所取代。目前,我在函数simplify( .. )中识别了情况,但它不会编译。

我知道它为什么不编译:我试图移动的节点(即我的示例中的12 )仍然是match子句中引用的作用域,因此这完全是生锈的,防止了引用可能出现的问题。但是在我的例子中,我知道这是我想要的,而且我在行*node = **child;中移动之后就退出了函数,所以前面的引用就超出了范围。

有一种惯用的铁锈式的方法来解决这个问题吗?我真的不想复制双负子树。

代码语言:javascript
复制
#[derive(Debug)]
enum Node {
    Num(i32),
    UnaryMinus(Box<Node>),
}

use Node::*;

fn simplify(node: &mut Node) {
    match &node {
        Num(_) => (),
        UnaryMinus(inner) => match &**inner {
            Num(_) => (),
            UnaryMinus(child) => {
                // cannot move out of `**child` which is behind a shared reference
                *node = **child;
                return;
            }
        },
    }
}

fn main() {
    let double_minus = UnaryMinus(Box::new(UnaryMinus(Box::new(Num(12)))));
}
EN

回答 1

Stack Overflow用户

回答已采纳

发布于 2022-11-12 13:55:26

这里有两个问题:具体而言,您所遇到的错误是因为您正在与&**inner而不是&mut **inner进行匹配。从共享引用中移出是永远不可能的,但在某些情况下(我们会看到),从可变引用中移出是可以的。

有了这个修正,您将得到同样的错误--几乎是可变的引用。那是因为你不能离开一个可变的引用,仅仅因为你知道你是唯一持有它的人。移动使其源未初始化,而对未初始化内存的引用,无论是可变的还是共享的,都是不可接受的。你得在记忆里留下你要搬出去的东西。你可以用std::mem::swap做这件事。它接受两个可变的引用并交换内容。

现在,人们显然可以尝试调用std::mem::swap(node, &mut child),但这不能简单地发挥作用,因为node已经在match表达式中不断借用,而且您不能反复借用一些东西。

此外,这将泄漏内存,因为您现在有一个引用周期,其中有node -> inner -> node。这一点,虽然完全有效,在铁锈,通常不是你想要的。

相反,您需要某种可以放在child位置的假人。一些简单的枚举变体,一旦它被丢弃,就可以由inner安全地丢弃。在本例中,可以是Node::Num(0)。

代码语言:javascript
复制
#[derive(Debug)]
enum Node {
    Num(i32),
    UnaryMinus(Box<Node>),
}

// This is just to verify that everything gets dropped properly
// and we don't leak any memory
impl Drop for Node {
    fn drop(&mut self) {
        println!("dropping {:?}", self);
    }
}

use Node::*;

fn simplify(node: &mut Node) {
    // `placeholder` will be our dummy
    let (mut can_simplify, mut placeholder) = (false, Num(0));
    match node {
        Num(_) => (),
        // we'll need to borrow `child` mutably later, so we have to
        // match on `&mut **inner` not `&**inner`
        UnaryMinus(inner) => match &mut **inner {
            Num(_) => (),
            UnaryMinus(ref mut child) => {
                // move the contents of `child` into `placeholder` and vice versa
                std::mem::swap(&mut placeholder, child);
                can_simplify = true;
            }
        },
    }
    if can_simplify {
        // now we can safely move into `node`
        *node = placeholder;
        // you could skip the conditional if all other, non-simplifying
        // branches return before this statement
    }
}

fn main() {
    let mut double_minus = UnaryMinus(Box::new(UnaryMinus(Box::new(Num(12)))));
    simplify(&mut double_minus);
    println!("{:?}", double_minus);
}
票数 2
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/74413063

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档