相关疑难解决方法(0)

我正在尝试对生成随机表达式的二叉树进行编码。我需要随机数和一组函数。我收到一个向量，其中包含树中表达式的功能和深度。在运算符向量中，我还包括一个“ 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 { …

我是 Rust 的新手，我在使用借用检查器时遇到了一些麻烦。我不明白为什么这段代码不能编译。抱歉，如果这与之前回答的问题很接近，但我似乎无法在我看过的其他问题中找到解决方案。

我理解将本地字符串作为切片（&str）返回的相似性，但在这种情况下，它只是返回一个字符串，不足以让我对我试图返回向量的代码进行推理。据我所知，我试图返回对str将在功能块末尾超出范围的类型的引用，所以我应该将该向量映射&str为向量String吗？我不太关心转换&str为String. 首先，我只想让它工作。

这是代码，错误在lex函数中。

use std::io::prelude::*;
use std::fs::File;
use std::env;

fn open(mut s: &mut String, filename: &String) {
    let mut f = match File::open(&filename) {
        Err(_) => panic!("Couldn't open file"),
        Ok(file) => file,
    };
    match f.read_to_string(&mut s) {
        Err(_) => panic!("Couldn't read file"),
        Ok(_) => println!("File read successfully"),
    };

}

fn lex(s: &String) -> Vec<&str> {
    let token_string: String = s.replace("(", " ( ") …

如何在一个struct？中定义一个可变元素？如果我有以下示例:

struct User<'a> {
    reference: String,
    email: String,
    addresses: &'a mut Vec<Address>
}

struct Address {
    street: String,
    city: String
}

fn main() {

    let mut users = Vec::new();
    users.push(User {
        reference: "ref".to_string(),
        email: "test@test.com".to_string(),
        addresses: &mut Vec::new()
    });

}

...它会产生错误:

src/main.rs:18:19: 18:29 error: borrowed value does not live long enough
src/main.rs:18      addresses: &mut Vec::new()
                                    ^~~~~~~~~~
src/main.rs:14:29: 21:2 note: reference must be valid for the block suffix following statement 0 at 14:28...
src/main.rs:14  let mut users = Vec::new(); …

我想只用分隔符将字符串拆分一次并将其放入元组中.我试过了

fn splitOnce(in_string: &str) -> (&str, &str) {
    let mut splitter = in_string.split(':');
    let first = splitter.next().unwrap();
    let second = splitter.fold("".to_string(), |a, b| a + b); 
    (first, &second)
}

但我一直被告知,second活得不够久.我想这是因为splitter它只存在于功能块内部,但我不确定如何解决这个问题.如何强制second进入功能块之外的现有？或者是否有更好的方法只分裂一次字符串？

为什么会to_string()导致borrowed value does not live long enough错误？下面的例子：

use std::collections::HashMap;

struct Foo {
    id: Option<usize>,
    name: String
}

fn main() {

    let foos = getFoos();

    for foo in foos {
        let mut map = HashMap::new();
        map.insert("name", &foo.name);
        map.insert("id", &foo.id.unwrap().to_string());
    }

}

fn getFoos() -> Vec<Foo> {
    Vec::new()
}

错误：

src/main.rs:15:27: 15:54 error: borrowed value does not live long enough
src/main.rs:15         map.insert("id", &foo.id.unwrap().to_string());
                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~
src/main.rs:13:38: 16:6 note: reference must be valid for the block suffix following statement 0 …

此代码引发关于从函数返回引用的错误：

fn sha512_256_digest(str: &[u8]) -> &[u8] {
    let x = digest::digest(&digest::SHA512_256, str);
    x.as_ref()
}

在这里返回x的as_ref()值的正确方法是什么？