1

我想在结构中存储对io::Write特征对象的引用，Option但我不知道如何。我可以像这样直接放入参考：

pub struct Parameters<'a> {
    pub log: &'a (io::Write + 'a),
    // Other elements removed
}

然后从（例如）BufWriter这样分配它：

let logstream = &BufWriter::new(f);
let parameters = Parameters {
    log: logstream, // Other elements removed
};

这可行，但我希望它logstream是可选的。如果我尝试：

pub struct Parameters<'a> {
    pub log: Option<&'a(io::Write + 'a)>,
    // Other elements removed
}

和

let logstream = match f {
    Some(f) => Some(&BufWriter::new(f)),
    None => None,
};

let parameters = Parameters {
    log: logstream,
    // Other elements removed
};

我得到：

error[E0308]: mismatched types
  --> src/main.rs:17:14
   |
17 |         log: logstream,
   |              ^^^^^^^^^ expected trait std::io::Write, found struct `std::io::BufWriter`
   |
   = note: expected type `std::option::Option<&dyn std::io::Write>`
              found type `std::option::Option<&std::io::BufWriter<std::vec::Vec<u8>>>`

这里有什么合适的方法？

4

3 回答 3

0

您必须以某种方式显式键入BufWritertrait 类型，并且您还必须更加小心生命周期。

这是它如何工作的草图：

use std::io;
use std::io::BufWriter;
use std::str::from_utf8;

pub struct Parameters<'a> {
    pub log: Option<&'a mut io::Write>,
    // Other elements removed
}

fn main() {
    let mut w = BufWriter::new(Vec::new());
    let rw: &mut std::io::Write = &mut w;
    let logstream = Some(rw);

    let parameters = Parameters {
        log: logstream,
        // Other elements removed
    };
    parameters.log.unwrap().write(b"hello world").ok();

    println!("{}", from_utf8(&w.into_inner().unwrap()).unwrap());
}
于 2019-04-20T09:26:05.257 回答
0 
use std::io;
use std::io::BufWriter;

pub struct P<'a> {
    pub log: Option<&'a mut io::Write>,
}

fn file() -> Option<Vec<u8>> {
    Some(Vec::new())
}

fn main() {
    let mut ow = file().map(|f| BufWriter::new(f));
    let p = P {
        log: ow.as_mut().map(|w| w as &mut io::Write),
    };

    p.log.unwrap().write(b"Hi!").ok();

    println!(
        "{}",
        String::from_utf8(ow.unwrap().into_inner().unwrap()).unwrap()
    );
}

与其采取一个Option<W>并尝试将其一次性转换为一个Option<&mut io::Write>，不如分三个步骤完成：

  • Option<W>->Option<io::BufWriter<W>>制作ow. 这是将拥有的东西BufWriter。正如另一个答案中所指出的，如果您尝试BufWriter在模式匹配中创建 a ，然后立即对其进行引用，则该引用的生命周期将在模式匹配的分支范围内，因此借用检查器会抱怨。
  • 下一步是从 转换Option<io::BufWriter<W>>为Option<&mut io::BufWriter<W>>using as_mut()。
  • 最后从对实现的引用转换为通用特征对象。在这种情况下，地图包含演员表。我曾尝试使用into，但似乎没有在对特征实现者的引用和对特征对象的引用之间进行转换的实现。

在这个例子中，file()返回 aVec<u8>作为底层作者，我这样做是为了让解决方案在 Rust 操场上是可测试的，但这也可以是一个File.

最后，我删除了 trait 对象的生命周期约束，类型系统/借用检查器似乎认为没有必要。

于 2019-04-20T09:50:42.703 回答
0

谢谢楼上的回答。在他们发布之前，我自己有一个想法并想出了这个（减少到一个最小的例子，或多或少地显示我正在尝试做的事情）：

use std::{env, process};
use std::fs::File;
use std::io::{self, BufWriter};

pub struct Parameters {
    pub log: Option<Box<dyn io::Write>>,
}


fn main() {
    let args: Vec<String> = env::args().collect();
    let logfile = if args.len() > 1 {
        Some(&args[1])
    } else {
        None
    };

    let logstream: Option<Box<dyn io::Write>> = match logfile {
        Some(logfile) => {
            let f = File::create(logfile).unwrap_or_else(|err| {
                eprintln!("ERROR opening logfile: {}", err);
                process::exit(1);
            });
            let logstream = BufWriter::new(f);
            Some(Box::new(logstream))
        }
        None => {
            None
        },
    };

    let parameters = Parameters {
        log: logstream,
    };
    play(parameters);
}

fn play(parameters: Parameters) {
    // Rest of code removed
    if let Some(mut stream) = parameters.log {
        stream.write("Testing\n".as_bytes()).unwrap_or_else(|err| {
            eprintln!("ERROR writing to logfile: {}", err);
            process::exit(1);
        });
    }
}

这是一个好的解决方案还是上面建议的一个更好？

于 2019-04-20T19:56:10.160 回答