有沒有一種方法可以在構造函數中使用標準輸入和輸出，只要你正在構造的結構體一直存在？

Question

我正在構建一個可以連續詢問一系列問題的PromptSet。出於測試原因，它允許您直接傳遞讀寫器，而不是直接使用stdin &標準輸出。

由於stdin和stdout是常見用例，我想創建一個默認的「構造函數」，允許用戶在不需要任何參數的情況下生成PromptSet<StdinLock, StdoutLock>。這裏是到目前爲止的代碼：

use std::io::{self, BufRead, StdinLock, StdoutLock, Write}; 

pub struct PromptSet<R, W> 
where 
    R: BufRead, 
    W: Write, 
{ 
    pub reader: R, 
    pub writer: W, 
} 

impl<R, W> PromptSet<R, W> 
where 
    R: BufRead, 
    W: Write, 
{ 
    pub fn new(reader: R, writer: W) -> PromptSet<R, W> { 
     return PromptSet { 
      reader: reader, 
      writer: writer, 
     }; 
    } 

    pub fn default<'a>() -> PromptSet<StdinLock<'a>, StdoutLock<'a>> { 
     let stdin = io::stdin(); 
     let stdout = io::stdout(); 

     return PromptSet { 
      reader: stdin.lock(), 
      writer: stdout.lock(), 
     }; 
    } 

    pub fn prompt(&mut self, question: &str) -> String { 
     let mut input = String::new(); 

     write!(self.writer, "{}: ", question).unwrap(); 
     self.writer.flush().unwrap(); 
     self.reader.read_line(&mut input).unwrap(); 

     return input.trim().to_string(); 
    } 
} 

fn main() {} 

StdinLock和StdoutLock都需要聲明的壽命。爲了使它複雜化，我認爲最初的stdin()/stdout()句柄需要至少與鎖一樣長。我希望參考StdinLock和StdoutLock只要我的PromptSet能夠生活，但無論我嘗試什麼，我都無法使其工作。這裏是我不斷收到錯誤：

error[E0597]: `stdin` does not live long enough 
    --> src/main.rs:30:21 
    | 
30 |    reader: stdin.lock(), 
    |      ^^^^^ borrowed value does not live long enough 
... 
33 |  } 
    |  - borrowed value only lives until here 
    | 
note: borrowed value must be valid for the lifetime 'a as defined on the method body at 25:5... 
    --> src/main.rs:25:5 
    | 
25 |/ pub fn default<'a>() -> PromptSet<StdinLock<'a>, StdoutLock<'a>> { 
26 | |   let stdin = io::stdin(); 
27 | |   let stdout = io::stdout(); 
28 | | 
... | 
32 | |   }; 
33 | |  } 
    | |_____^ 

error[E0597]: `stdout` does not live long enough 
    --> src/main.rs:31:21 
    | 
31 |    writer: stdout.lock(), 
    |      ^^^^^^ borrowed value does not live long enough 
32 |   }; 
33 |  } 
    |  - borrowed value only lives until here 
    | 
note: borrowed value must be valid for the lifetime 'a as defined on the method body at 25:5... 
    --> src/main.rs:25:5 
    | 
25 |/ pub fn default<'a>() -> PromptSet<StdinLock<'a>, StdoutLock<'a>> { 
26 | |   let stdin = io::stdin(); 
27 | |   let stdout = io::stdout(); 
28 | | 
... | 
32 | |   }; 
33 | |  } 
    | |_____^ 

這是完全有可能我就是不明白，壽命或別的超級基本的概念。

Answer 1

lock方法的簽名是fn lock(&self) -> StdinLock，當使用生命週期註釋完全展開時，其爲fn lock<'a>(&'a self) -> StdinLock<'a>。因此StdinLock只能在lock方法被調用時才能存活。由於您在此功能中定義了stdin，因此StdinLock無法運行。這與返回對本地值的引用相同。

你不能這樣做，你不能解決它。唯一的修復方法是使default方法以Stdin和Stdout對象作爲參數。

這就是說，你可以解決它。是的，我知道，我只是說了完全相反的事情，但它更像是一個「沒有人比我會使用標準輸入/標準輸出」（又名，println!將不再工作！）。您可以使用leak箱子將Stdin泄漏到&'static Stdin，這將產生StdinLock<'static>。

Answer 2

可能不是你的問題的答案，而是一個類似的問題。這是我的解決方案。

這裏的主要技巧是撥打stdin.lock()每一行。

use std::io; 
use std::io::prelude::*; 
use std::io::Stdin; 

struct StdinWrapper { 
    stdin: Stdin, 
} 

impl Iterator for StdinWrapper { 
    type Item = String; 

    fn next(&mut self) -> Option<Self::Item> { 
     let stdin = &self.stdin; 
     let mut lines = stdin.lock().lines(); 
     match lines.next() { 
      Some(result) => Some(result.expect("Cannot read line")), 
      None => None, 
     } 
    } 
} 

/** 
* Callers of this method should not know concrete source of the strings. 
* It could be Stdin, a file, DB, or even aliens from SETI. 
*/ 
fn read() -> Box<Iterator<Item = String>> { 
    let stdin = io::stdin(); 
    Box::new(StdinWrapper { stdin }) 
} 

fn main() { 
    let lines = read(); 

    for line in lines { 
     println!("{}", line); 
    } 
}