easy_io

提供两个结构体 InputReader 和 OutputWriter，用于在Rust中进行快速且方便的IO。

这些结构体的主要用途是竞技编程或 Kattis 风格的问题。通过 io::stdin() 读取数字特别不方便。在竞技编程中，由于事先知道输入的确切格式，所以希望能够轻松地获取流中的下一个数字或单词。而 InputReader 结构体使得这一过程变得简单，同时保证了IO不会成为解决方案的瓶颈。

通过Rust的 println!() 进行常规输出也可能有问题，因为它会进行行缓冲。这可能会导致输出速度出人意料地慢。而 OutputWriter 结构体会缓冲所有输出，直到刷新或丢弃，从而显著提高性能。

要在竞技编程中使用这些，只需下载 input_reader.rs 和/或 output_reader.rs。将它们放在与解决方案相同的文件夹中，并像下面这样导入。

这受到了 这个惊人的Java类 的启发，但完全独立编写。

InputReader

使用方法

// import it
mod input_reader;
use input_reader::InputReader;
// ... or if via crates.io
use easy_io::InputReader

fn main() {
  // Create a reader from stdin
  let mut input = InputReader::new();

  // ... or from a file
  let mut input = InputReader::from_file("input.txt");

  // ... or from any struct that implements the Read trait.
  let tcp_stream = TcpStream::connect("127.0.0.1:34254");
  let mut input = InputReader::from_reader(tcp_stream);

  // Read numbers and words from the input source simply like this.
  let x: usize = input.next();
  let y: i64 = input.next();
  let z = input.next::<f64>();
  let word: String = input.next();
  let line: String = input.next_line();
}

⚠️ 限制

此结构体为了性能和便利性牺牲了一些功能/正确性

• 结果在内部未包裹，从而使API更加简单。在竞技编程中，你将无法从任何IO错误中恢复。
• 不支持UTF8字符串。 InputReader 将将输入源中的每个字节视为一个单独的字符。这可以显著提高速度，而在竞技编程中，几乎总是使用ascii。
• 它不会在尝试将数字放入 u8 等类型之前对其进行任何大小验证。这对于竞技编程来说也是可以的，因为通常都会给出数字界限。
• 它只解析十进制表示的数字，例如不解析十六进制或科学记数法。
• 它不会解析特殊浮点值，例如 NaN 或 Infinity。

公共方法

构造函数

// Constructs an InputReader which reads from stdin.
InputReader::new() -> Self

// Constructs an InputReader which reads from the file at the given path.
InputReader::from_file(path: &str) -> Self

// Constructs an InputReader that reads from the given reader.
InputReader::from_reader(reader: R) -> Self

next() 方法

fn next<T: InputReadable>(&mut self) -> T;

// In many cases, the compiler can figure out the type for you.
// Other times you need to supply the type like so:
let a: u32 = input.next();
let b = input.next::<f64>();

这个方法是你从输入源读取大部分内容的方式。以下类型实现了 InputReadable 特性，因此可以使用此函数。

u64, u32, u16, u8, usize
i64, u32, i16, i8, isize
f64, f32
char, String

其他实例方法

// Returns the next line from the input source.
InputReader::next_line(&mut self) -> String

// Returns true if there is more data to be read from the input source.
InputReader::has_more(&mut self) -> bool

// Changes the internal buffer size. Default: 2^16 bytes
InputReader::set_buf_size(&mut self, buf_size: usize)

输出写入器

这个结构将简单地缓冲所有输出，直到写入器被丢弃（或手动调用 flush）。

使用方法

// import it
mod output_writer;
use output_writer::OutputWriter;
// ... or if via crates.io
use easy_io::OutputWriter

fn main() -> std::io::Result<()> {
  // Create a writer from stdout
  let mut output = OutputWriter::new();

  // ... or from a file
  let mut output = OutputWriter::from_file("output.txt");

  // ... or from any struct that implements the Write trait.
  let tcp_stream = TcpStream::connect("127.0.0.1:34254");
  let mut output = OutputWriter::from_writer(tcp_stream);

  // Write to the output source simply like this.
  // These methods accept any object that implements Display.
  output.println("Hello world!");
  output.prints(1337);
  output.println("is a cool number.");
  // or like this
  output.print(format!("{} is a cool number.\n", 1337));

  // It also implements the Write trait, so you can do this:
  write!(output, "{} formatted!\n", "This is")?;
  writeln!(output, "{} is the answer.", 42)?;

  // You can manually flush the writer. Note that this will
  // be done automatically when the writer is dropped.
  output.flush()?;
  Ok()
}

公共方法

这个类实现了 Write 特性。这样我们就可以利用 write! 和 writeln! 宏进行简单的格式化。这意味着结构上有更多方法可用。请参阅文档这里。

构造函数

// Constructs an OutputWriter which writes to stdout.
OutputWriter::new() -> Self

// Constructs an OutputWriter which writes to the file at the given path.
OutputWriter::from_file(path: &str) -> Self

// Constructs an OutputWriter that writes to the given writer.
OutputWriter::from_writer(writer: W) -> Self

实例方法

// Writes something to the output source.
OutputWriter::print<T: Display>(&mut self, t: T)

// Convenience method for writing something with a space appended.
OutputWriter::prints<T: Display>(&mut self, t: T)

// Convenience method for writing something with a newline appended.
OutputWriter::println<T: Display>(&mut self, t: T)