Question

有时我想从std::io::Read读取一个字节。如果我尝试这样做：

use std::io::{self, Read};

fn main() {
    let mut byte: u8 = 0;
    io::stdin().read(&mut byte).unwrap();
    println!("byte: {}", byte);
}

我收到以下错误（很清楚，因为byte不是切片）：

error[E0308]: mismatched types
 --> src/main.rs:6:22
  |
6 |     io::stdin().read(&mut byte).unwrap();
  |                      ^^^^^^^^^ expected slice, found u8
  |
  = note: expected type `&mut [u8]`
             found type `&mut u8`

有没有办法让byte保持为简单的u8而只需要一片，我可以将其传递给read()？使这段代码工作的显而易见的方法是使用长度为1的数组：

use std::io::{self, Read};

fn main() {
    let mut byte: [u8; 1] = [0];
    io::stdin().read(&mut byte).unwrap();
    println!("byte: {}", byte[0]);
}

但是，在整个代码中，这种感觉有点奇怪，使用单个u8而不是[u8; 1]进行索引会更自然。< / p>

如果无法从简单的u8创建一个切片，但我不知道它是否可能并且想要知道。

Answer 1

Rust 1.28 +

slice::from_mut回来了，它很稳定！

use std::{
    io::{self, Read},
    slice,
};

fn main() {
    let mut byte = 0;
    let bytes_read = io::stdin().read(slice::from_mut(&mut byte)).unwrap();
    if bytes_read == 1 {
        println!("read byte: {:?}", byte);
    }
}

Rust 1.0 +

但是在整个代码中，这种感觉有点奇怪，使用单个u8而不是[u8; 1]进行索引会更自然。

创建长度为1的数组将是最自然的方式：

use std::io::{self, Read};

fn main() {
    let mut bytes = [0];
    let bytes_read = io::stdin().read(&mut bytes).unwrap();
    let valid_bytes = &bytes[..bytes_read];
    println!("read bytes: {:?}", valid_bytes);
}

但是，可能从参考单个值不安全地创建切片：

use std::io::{self, Read};
use std::slice;

fn mut_ref_slice<T>(x: &mut T) -> &mut [T] {
    // It's important to wrap this in its own function because this is
    // the only way to tell the borrow checker what the resulting slice
    // will refer to. Otherwise you might get mutable aliasing or a
    // dangling pointer which is what Rust is trying to avoid.
    unsafe { slice::from_raw_parts_mut(x, 1) }
}

fn main() {
    let mut byte = 0u8;
    let bytes_read = io::stdin().read(mut_ref_slice(&mut byte)).unwrap();
    if bytes_read != 0 {
        println!("byte: {}", byte);
    }
}

请记住，切片基本上是两件事：指向内存区域和长度的指针。使用一个长度为1的片段，您只需要为可变参考和bam添加长度！你得到了一分。

早期版本的Rust有ref_slice and mut_ref_slice functions。它们被删除了，因为它们的实用程序尚未得到证实（这不是常见问题），但它们可以安全地调用。函数已移至ref_slice crate，因此如果您想继续使用它们，那就是一种可能性。

Answer 2

回答你的实际问题：不，你不能这样做，而且几乎从来没有任何需要。即使你无法获得可读的迭代，你也可以将int final_score = 0; for(int i = 0; i < h; i++) { score_result = pArray[i] - hArray[i]; final_score += score_result; } System.out.println(final_score);放入另一个变量并使用它。

相反，您可以使用the Bytes iterator：

byte[0]

我可以从单个字节（u8）创建一个可变切片＆amp; mut [u8]吗？

2 个答案:

Rust 1.28 +

Rust 1.0 +