如何解决 Rust 中的 "返回引用当前函数所拥有数据" 错误？

Question

我正在尝试编写一个生成随机表达式的二叉树。我需要随机数和一组函数。我接收一个包含函数和表达式深度的向量用于生成树。在操作符向量中，我还包括一个“ELEM”字符串，这用于从向量中选择一个随机元素，然后将其更改为一个浮点数。

似乎我仍然不理解借用、移动和所有权的确切用法，因为它是一个递归函数，它显示错误说值已被借用，不能返回局部变量。

use rand::Rng;

struct Expression_Node<'a> {
    val: &'a str,
    left: Option<Box<Expression_Node<'a>>>,
    right: Option<Box<Expression_Node<'a>>>,
}

fn Create_Expression(
    operators: Vec<&str>,
    p: i32,
) -> std::option::Option<std::boxed::Box<Expression_Node<'_>>> {
    if p == 0 {
        let value = String::from(rand::thread_rng().gen::<f64>().to_string());
        let value2: &str = value.as_ref();
        //println!("{:?}", value);
        let new_node = Expression_Node {
            val: value2,
            left: None,
            right: None,
        };
        return Some(Box::new(new_node));
    }
    let value: &str = *rand::thread_rng().choose(&operators).unwrap();
    println!("VAL: {:?}", value);
    if value == "ELEM" {
        let value = rand::thread_rng().gen::<f64>().to_string();
    }

    let new_node = Expression_Node {
        val: value,
        left: Create_Expression(operators.clone(), p - 1),
        right: Create_Expression(operators.clone(), p - 1),
    };
    return Some(Box::new(new_node));
}

错误：

error[E0515]: cannot return value referencing local variable `value`
  --> src/lib.rs:22:16
   |
15 |         let value2: &str = value.as_ref();
   |                            ----- `value` is borrowed here
...
22 |         return Some(Box::new(new_node));
   |                ^^^^^^^^^^^^^^^^^^^^^^^^ returns a value referencing data owned by the current function

- MMagueta

---

随机生成的值需要在函数体外存活。可以在表达式中存储拥有的字符串，而不是切片吗？ - Gurwinder Singh

惯用的 Rust 语法使用 snake_case 命名变量、方法、宏和字段；使用 UpperCamelCase 命名类型和枚举变体；使用 SCREAMING_SNAKE_CASE 命名静态变量和常量。请使用 ExpressionNode 和 create_expression。 - Shepmaster

没有理由使用 std::option::Option 或 std::boxed::Box —— 这些都在预导入中，不需要完全限定（实际上你并没有在所有地方都限定它们）。在块的末尾使用显式的 return 也是非惯用的。 - Shepmaster

Answer 1

代码中最大的问题是在ExpressionNode中使用&str。

最简单的解决方法是将其更改为String。您可以查看以下修复程序。
这也允许删除所有生命周期注释。

此代码中还有第二个重要的修复。

let value: &str = *rand::thread_rng().choose(&operators).unwrap();
if value == "ELEM"{
    let value = rand::thread_rng().gen::<f64>().to_string();
}

应该更新value，因此if语句中的赋值不应包含let，第一个赋值应为let mut value。

如果切换到String时对所有赋值都不满意，您有两个其他选项 - 使用Cow字符串或使用枚举来包含值类型，以便它可以包含字符串或浮点数，例如- val: Either<&str, f64>（本答案末尾有使用此方法的版本）。

基于字符串的版本：

use rand::Rng;

#[derive(Debug)]
struct ExpressionNode {
    val: String,
    left: Option<Box<ExpressionNode>>,
    right: Option<Box<ExpressionNode>>,
}

fn create_expression(operators: &[&str], p: i32) -> Option<Box<ExpressionNode>> {
    if p == 0 {
        let value = String::from(rand::thread_rng().gen::<f64>().to_string());
        let new_node = ExpressionNode {
            val: value,
            left: None,
            right: None,
        };
        return Some(Box::new(new_node));
    }
    let mut value = rand::thread_rng().choose(&operators).unwrap().to_string();
    if value == "ELEM" {
        value = rand::thread_rng().gen::<f64>().to_string();
    }

    let new_node = ExpressionNode {
        val: value,
        left: create_expression(operators.clone(), p - 1),
        right: create_expression(operators.clone(), p - 1),
    };
    Some(Box::new(new_node))
}

fn main() {
    let v = vec!["a", "b", "c", "ELEM"];
    let tree = create_expression(&v, 3);
    println!("tree = {:?}", tree)
}

作为比较，这里是使用 Either<&str, f64> 的版本：

use either::Either;
use rand::Rng;

#[derive(Debug)]
struct ExpressionNode<'a> {
    val: Either<&'a str, f64>,
    left: Option<Box<ExpressionNode<'a>>>,
    right: Option<Box<ExpressionNode<'a>>>,
}

fn create_expression<'a>(operators: &[&'a str], p: i32) -> Option<Box<ExpressionNode<'a>>> {
    if p == 0 {
        let value = rand::thread_rng().gen::<f64>();
        let new_node = ExpressionNode {
            val: Either::Right(value),
            left: None,
            right: None,
        };
        return Some(Box::new(new_node));
    }
    let v = *rand::thread_rng().choose(&operators).unwrap();
    let value = if v == "ELEM" {
        Either::Right(rand::thread_rng().gen::<f64>())
    } else {
        Either::Left(v)
    };

    let new_node = ExpressionNode {
        val: value,
        left: create_expression(operators.clone(), p - 1),
        right: create_expression(operators.clone(), p - 1),
    };
    Some(Box::new(new_node))
}

fn main() {
    let v = vec!["a", "b", "c", "ELEM"];
    let tree = create_expression(&v, 3);
    println!("tree = {:?}", tree)
}

- Michael Anderson