reference - 有什么方法可以返回对在函数中创建的变量的引用？

Question

我想编写一个程序，该程序将分两个步骤写入文件。
在程序运行之前，该文件可能不存在。文件名是固定的。

问题是OpenOptions.new().write()可能失败。在这种情况下，我想调用自定义函数trycreate()。这个想法是创建文件而不是打开它并返回一个句柄。由于文件名是固定的，因此trycreate()没有参数，因此我无法设置返回值的生存期。

我该如何解决这个问题？

use std::io::Write;
use std::fs::OpenOptions;
use std::path::Path;

fn trycreate() -> &OpenOptions {
    let f = OpenOptions::new().write(true).open("foo.txt");
    let mut f = match f {
        Ok(file)  => file,
        Err(_)  => panic!("ERR"),
    };
    f
}

fn main() {
    {
        let f = OpenOptions::new().write(true).open(b"foo.txt");
        let mut f = match f {
            Ok(file)  => file,
            Err(_)  => trycreate("foo.txt"),
        };
        let buf = b"test1\n";
        let _ret = f.write(buf).unwrap();
    }
    println!("50%");
    {
        let f = OpenOptions::new().append(true).open("foo.txt");
        let mut f = match f {
            Ok(file)  => file,
            Err(_)  => panic!("append"),
        };
        let buf = b"test2\n";
        let _ret = f.write(buf).unwrap();
    }
    println!("Ok");
}

Answer 1

你问的问题
TL; DR:否，您不能返回对函数拥有的变量的引用。如果您创建了变量，或者将变量的所有权作为函数参数，则这适用。
解决方案
而不是尝试返回引用，而是返回一个拥有的对象。 String代替&str，Vec<T>代替&[T]，T代替&T，等等。
如果您通过参数获得了变量的所有权，请尝试改用(可变的)引用，然后返回具有相同生存期的引用。
在极少数情况下，您可以使用不安全的代码返回所拥有的值及其引用。您必须遵守许多微妙的要求，以确保不会引起不确定的行为或内存不安全。
也可以看看:

Proper way to return a new string in Rust

Return local String as a slice (&str)

Why can't I store a value and a reference to that value in the same struct?

更深入的答案
fjh is absolutely correct，但我想更深入地说明一下，并在代码中涉及其他一些错误。
让我们从返回引用的一个较小示例开始，看看错误:

fn try_create<'a>() -> &'a String {
    &String::new()
}

Rust 2015年

error[E0597]: borrowed value does not live long enough
 --> src/lib.rs:2:6
  |
2 |     &String::new()
  |      ^^^^^^^^^^^^^ temporary value does not live long enough
3 | }
  | - temporary value only lives until here
  |
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 1:15...
 --> src/lib.rs:1:15
  |
1 | fn try_create<'a>() -> &'a String {
  |               ^^

Rust的2018

error[E0515]: cannot return reference to temporary value
 --> src/lib.rs:2:5
  |
2 |     &String::new()
  |     ^-------------
  |     ||
  |     |temporary value created here
  |     returns a reference to data owned by the current function

Is there any way to return a reference from a function without arguments?

从技术上讲是"is"，但是对于您想要的是“否”。
引用指向现有的内存。在没有参数的函数中，唯一可以引用的是全局常量(具有生命周期 &'static)和局部变量。我现在将忽略全局变量。
在像C或C++这样的语言中，您实际上可以引用一个局部变量并将其返回。但是，一旦函数返回， 并不能保证所引用的内存仍然是您想要的。它可能会保持您期望的状态一段时间，但最终内存将被重用于其他用途。一旦您的代码查看了内存并尝试将用户名解释为用户银行帐户中剩余的金额，就会出现问题!
这就是Rust的生命周期所防止的-在超出引用值在其当前内存位置有效的时间范围内，不允许使用引用。
也可以看看:

Is it possible to return either a borrowed or owned type in Rust?

Why can I return a reference to a local literal but not a variable?

你的实际问题
查看 OpenOptions::open 的文档:

fn open<P: AsRef<Path>>(&self, path: P) -> Result<File>

它返回 Result<File>，所以我不知道您期望如何返回 OpenOptions或对它的引用。如果将其重写为:

fn trycreate() -> File {
    OpenOptions::new()
        .write(true)
        .open("foo.txt")
        .expect("Couldn't open")
}

这会使用 Result::expect 引发有用的错误消息，从而引起 panic 。当然，在程序的胆怯中 panic 并不是 super 有用，因此建议您将错误传播出去:

fn trycreate() -> io::Result<File> {
    OpenOptions::new().write(true).open("foo.txt")
}

Option和 Result有很多不错的方法来处理链式错误逻辑。在这里，您可以使用 or_else :

let f = OpenOptions::new().write(true).open("foo.txt");
let mut f = f.or_else(|_| trycreate()).expect("failed at creating");

我还要从 Result返回 main。所有这些，包括fjh的建议:

use std::{
    fs::OpenOptions,
    io::{self, Write},
};

fn main() -> io::Result<()> {
    let mut f = OpenOptions::new()
        .create(true)
        .write(true)
        .append(true)
        .open("foo.txt")?;

    f.write_all(b"test1\n")?;
    f.write_all(b"test2\n")?;

    Ok(())
}