5

我正在编写一个简单的基于 TCP 的回显服务器。当我尝试使用BufReaderandBufWriter读取和写入 aTcpStream时,我发现按值传递 aTcpStreamBufReader::new()移动它的所有权,因此我无法将它传递给 a BufWriter。然后,我在这个线程中找到了解决问题的答案:

fn handle_client(stream: TcpStream) {
    let mut reader = BufReader::new(&stream);
    let mut writer = BufWriter::new(&stream);

    // Receive a message
    let mut message = String::new();
    reader.read_line(&mut message).unwrap();

    // ingored
}

这很简单并且有效。但是,我不太明白为什么这段代码有效。为什么我可以只传递不可变引用BufReader::new()而不是可变引用?

整个程序可以在这里找到。

更多细节

在上面的代码中,我使用了reader.read_line(&mut message). BufRead于是我打开了Rust 标准库中的源代码,看到了这个:

fn read_line(&mut self, buf: &mut String) -> Result<usize> {
    // ignored
    append_to_string(buf, |b| read_until(self, b'\n', b))
}

在这里我们可以看到它将 self (&mut BufReader在我的情况下可能是 a )传递给read_until(). 接下来,我在同一个文件中找到了以下代码:

fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
                                   -> Result<usize> {
    let mut read = 0;
    loop {
        let (done, used) = {
            let available = match r.fill_buf() {
                Ok(n) => n,
                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
                Err(e) => return Err(e)
            };
            match memchr::memchr(delim, available) {
                Some(i) => {
                    buf.extend_from_slice(&available[..i + 1]);
                    (true, i + 1)
                }
                None => {
                    buf.extend_from_slice(available);
                    (false, available.len())
                }
            }
        };
        r.consume(used);
        read += used;
        if done || used == 0 {
            return Ok(read);
        }
    }
}

在这一部分中,有两个地方使用了BufReader:r.fill_buf()r.consume(used). 我以为r.fill_buf()是我想看到的。因此,我去了BufReaderRust 标准库中的代码,发现了这个:

fn fill_buf(&mut self) -> io::Result<&[u8]> {
    // ignored
    if self.pos == self.cap {
        self.cap = try!(self.inner.read(&mut self.buf));
        self.pos = 0;
    }
    Ok(&self.buf[self.pos..self.cap])
}

它似乎用于self.inner.read(&mut self.buf)self.inner. 然后,我们看一下 和 的BufReader结构BufReader::new()

pub struct BufReader<R> {
    inner: R,
    buf: Vec<u8>,
    pos: usize,
    cap: usize,
}

// ignored
impl<R: Read> BufReader<R> {
    // ignored
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn new(inner: R) -> BufReader<R> {
        BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
    }

    // ignored
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
        BufReader {
            inner: inner,
            buf: vec![0; cap],
            pos: 0,
            cap: 0,
        }
    }

    // ignored
}

从上面的代码中,我们可以知道这inner是一个实现Read. 就我而言,inner可能是&TcpStream.

我知道的签名Read.read()是:

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

它在这里需要一个可变引用,但我只借给它一个不可变引用。self.inner.read()当程序到达时,这应该是一个问题fill_buf()吗?

4

1 回答 1

2

快速回答:我们传递一个&TcpStreamas R: Read,而不是TcpStream。因此selfRead::read&mut & TcpStream,不是&mut TcpStream。如您在文档Read中看到的那样实施。&TcpStream

看看这个工作代码:

let stream = TcpStream::connect("...").unwrap();
let mut buf = [0; 100];
Read::read(&mut (&stream), &mut buf);

请注意,stream它甚至没有绑定为mut,因为我们不可变地使用它,只是对不可变引用具有可变引用。


接下来,您可能会问为什么Read可以实现 for &TcpStream,因为在读取操作期间需要更改某些内容。

这是美好的 Rust 世界 ☮ 结束的地方,邪恶的 C-/操作系统世界开始了。例如,在 Linux 上,您有一个简单的整数作为流的“文件描述符”。您可以将其用于流上的所有操作,包括读取和写入。由于您按值传递整数(它也是一个Copy-type),因此您是否有对整数的可变或不可变引用并不重要,因为您可以复制它。

因此,操作系统或 Rust 实现必须完成最少量的同步std,因为通过不可变引用进行变异通常是奇怪和危险的。这种行为称为“内部可变性”,您可以阅读更多关于它的信息......

于 2016-03-26T10:12:58.627 回答