Question

说我有以下内容，

use std::io;
use std::io::Read;

#[derive(Debug)]
enum FooReadError {
    UnexpectedEof,
    IoError(io::Error),
}

impl From<io::Error> for FooReadError {
    fn from(err: io::Error) -> FooReadError {
        FooReadError::IoError(err)
    }
}

fn read_n_bytes_to_vector<R: Read>(reader: &mut R, length: usize)
        -> Result<Vec<u8>, FooReadError> {
    let mut bytes = Vec::<u8>::with_capacity(length);
    unsafe { bytes.set_len(length); }
    let bytes_read = try!(reader.read(&mut bytes[..]));
    if bytes_read != length {
        Err(FooReadError::UnexpectedEof)
    } else {
        Ok(bytes)
    }
}

fn do_some_read(reader: &mut Read) -> Vec<u8> {
    read_n_bytes_to_vector(reader, 16).unwrap()
}

fn main() {
    let v = vec![0, 1, 2, 3, 4, 5];
    let mut cur = io::Cursor::<Vec<u8>>::new(v);
    do_some_read(&mut cur);
}

read_n_bytes_to_vector应该采取任何实现特征io::Read的任何内容，从中读取length个字节，然后将它们放入一个向量中并返回该向量。

函数do_some_read有一个io::Read特征对象。那么，为什么呢：

% rustc ./vec_read.rs
./vec_read.rs:29:5: 29:27 error: the trait `core::marker::Sized` is not implemented for the type `std::io::Read` [E0277]
./vec_read.rs:29     read_n_bytes_to_vector(reader, 16).unwrap()
                     ^~~~~~~~~~~~~~~~~~~~~~
./vec_read.rs:29:5: 29:27 note: `std::io::Read` does not have a constant size known at compile-time
./vec_read.rs:29     read_n_bytes_to_vector(reader, 16).unwrap()
                     ^~~~~~~~~~~~~~~~~~~~~~

我同意io::Read无法实现Sized的编译器;但是我传递了一个特征对象 - 这些是不变大小的，所以这里应该没问题; **那么为什么会出错？*等等，为什么它甚至重要？该函数不是io::Read为arg（对吗？），它也是一个特征对象，因为arg是通用的，应该采用什么类型的传递。

Answer 1

泛型包含默认绑定的Sized;如果您不希望这样做，则必须添加?Sized边界。

特征对象是不是的常量大小; u16 as Trait是两个字节，u32 as Trait是四个字节，＆amp; c。;只有盒装特征对象（Box<Trait>）和特征对象引用（&Trait，&mut Trait）之类的内容具有恒定的大小，已知在编译时（引用的例子中有两个字）。

由于您只使用R可变引用，因此您可以成功添加?Sized绑定：

fn read_n_bytes_to_vector<R: ?Sized + Read>(reader: &mut R, length: usize)
        -> Result<Vec<u8>, FooReadError> {

特征对象，并将n个字节读入矢量

1 个答案: