Question

This example编译并返回“预期”输出。但这不是一个悬空的指针方案吗？如果是这样，那么rust编译器为何允许这样做？

use serde_json::{Value, json};
use std::io::Result;

fn main(){
    println!("{:#?}", test_json_lifetime());
}

fn test_json_lifetime() -> Result<(Value)> {                            
    let j = json!({ "name" : "test" }); 
    Ok(j)
}

Answer 1

听起来您好像在想j被分配在test_json_lifetime()的堆栈帧上（当堆栈展开时，该内存在函数的末尾被释放），并且我们返回对j（这将导致指针悬空）。

在这种情况下，您正确地在堆栈上分配了j，但是当我们返回Ok(j)时，我们没有返回对j的引用，而是复制了{{1 }}到在j函数调用之前在Result<(Value)>的堆栈帧上分配的main()的空间。

Answer 2

我在this section中找到了答案。

fn main() {
let s1 = gives_ownership();         // gives_ownership moves its return
                                    // value into s1

let s2 = String::from("hello");     // s2 comes into scope

let s3 = takes_and_gives_back(s2);  // s2 is moved into
                                    // takes_and_gives_back, which also
                                    // moves its return value into s3
} 

// Here, s3 goes out of scope and is dropped. s2 goes out of scope but was
// moved, so nothing happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {             // gives_ownership will move its
                                             // return value into the function
                                             // that calls it

    let some_string = String::from("hello"); // some_string comes into scope

    some_string                              // some_string is returned and
                                             // moves out to the calling
                                             // function
}

如何在rust中允许的函数内返回变量“ let”？

2 个答案: