Question

I/O 核心特征定义，及辅助函数。

+------+           +-------+        +------+
| Read |           | Write |        | Seek |
+------+           +-------+        +------+
  |               |             |
  +-- Stdin           +-- Stdout        +-- File
  |               |             |
  +-- File            +-- Stderr        +-- BufReader<R>
  |               |             |
  +-- TcpStream         +-- File        +-- BufWriter<W>
  |               |             |
  |   +---------+         +-- TcpStream       +-- Cursor<T>
  +-- | BufRead |         |
    +---------+         +-- Vec<u8>
      |           |
      +-- BufReader<R>    +-- BufWriter<W>
      |           |
      +-- Cursor<T>     +-- Cursor<T>
      |
      +-- StdinLock

• Reader 和 Writer 没有 close 方法，通常以 Drop 自动关闭。
• BufReader 和 BufWriter 默认 8 KB 缓冲区，可用 with_capacity 指定。
• BufWriter.Drop 会写入剩余缓冲数据，但忽略错误，建议调用 flush 方法。

• write! 和 writeln! 向 Writer 写入格式化字符串。
• print! 和 eprint! 需要调用 flush ，确保行缓冲输出。

pub type Result<T> = Result<T, Error>;

用 Cursor<&[u8]> 、 Cursor<&mut [u8]> 、 Cursor<Vec[u8]> 读写内存字节数据。

[u8] 固定大小， Vec[u8] 按需扩张。

use std::io::prelude::*;
use std::io::{ self, Cursor };

fn main() {
  let src = [1, 2, 3, 4, 5, 6, 7];
  let mut buf = Cursor::new(&src[..]);

  (|| -> io::Result<()> {
    let mut dst = [0; 2];

    loop {
      let n = buf.read(&mut dst)?;
      if n == 0 { return Ok(()); }
      println!("{:?}:{:?}", n, &dst[..n]);
    }
  })().unwrap();
}

/*

2:[1, 2]
2:[3, 4]
2:[5, 6]
1:[7]

*/

use std::io::prelude::*;
use std::io::{ self, Cursor, SeekFrom };

fn main() {
  let mut src = [0u8; 100];
  let mut dst = [0u8; 5];  
  let mut buf = Cursor::new(&mut src[..]);

  (|| -> io::Result<()> {
    // write
    buf.seek(SeekFrom::Start(1))?;
    let n = buf.write(&[2, 3])?;

    assert_eq!(n, 2);
    assert_eq!(buf.get_ref()[..3], [0, 2, 3]);

    // read
    buf.seek(SeekFrom::Start(0))?;
    let n = buf.read(&mut dst)?;

    assert_eq!(n, dst.len());
    assert_eq!(dst, [0, 2, 3, 0, 0]);

    Ok(())
  })().unwrap();
}

错误处理。

use std::io::prelude::*;
use std::io::{ self, Cursor, ErrorKind };

fn main() {

  (|| -> io::Result<()> {
    let mut buf = Cursor::new(&[1, 2, 3, 4][..]);
    let mut dst = [0; 10];

    // 数据不足以填充 dst 时返回错误。
    buf.read_exact(&mut dst)?; 

    Ok(())
  })().unwrap_or_else(|e| {
    match e.kind() {
      ErrorKind::UnexpectedEof => eprintln!("eof"),
      _ => eprintln!("{e:?}"),
    }
  });
}