标签: vec

我有很多 4KiB 缓冲区，它们有 50% 的机会只包含零值。非零缓冲区通常在缓冲区的早期有一个非零字节。

fn is_zero(buf: &Vec<u8>) -> bool {
    for byte in buf.into_iter() {
        if *byte != 0 {
            return false;
        }
    }
    return true;
}

这是检查 Rust 的一种高效方式--release吗？（我正在处理许多 GB 的数据。）

（在 C 版本中，我unsigned long long在检查之前将缓冲区强制转换为。考虑到 SSE 等，这可能不是我能做的最好的事情。）

我对i下面的变量做错了什么？为什么编译器说我不能Vec用 a索引 a ，u32我该如何解决？

fn main() {
    let a: Vec<u32> = vec![1, 2, 3, 4];
    let number: u32 = 4;
    let mut count = 0;
    
    for i in 0..number {
        if a[i] % 2 != 0 {
            count += 1;
        } else {
            continue;
        }
    }
    println!("{}", count);
}

错误：

fn main() {
    let a: Vec<u32> = vec![1, 2, 3, 4];
    let number: u32 = 4;
    let mut count = 0;
    
    for i in …

当你Vec::splice()用来替换 a 的一部分时Vec，它是否足够聪明来专门处理替换与它正在替换的块长度相同的情况，还是我应该自己处理？

这样做有什么意义，还是array.splice()足够聪明来这样做？

fn example(array: Vec<u64>, replacement: Vec<u64>, range: std::ops::Range<usize>) {
    if (replacement.len() == range.len()) {
        for i in range {
            array[i] = replacement[i];
        }
    } else {
        array.splice(range, replacement);
    }
}

如果我有一个，即使我可以转换为using ，Vec<T>我也无法将其转换为Vec<U>直接using 。例如，此代码无法编译：.into()TU.into()

use std::convert::From;

struct A {
    x: i32,
}

struct B {
    y: u64,
}

impl From<A> for B {
    fn from(a: A) -> Self {
        Self {
            y: a.x as u64,
        }
    }
}

fn main() {
    let avec: Vec<A> = vec![A{x: 1}, A{x: 2}];
    let bvec: Vec<B> = avec.into(); // Error!
}

我觉得应该可以有一个像这样的全面实现：

impl<T, U> From<Vec<T>> for Vec<U> where T: From<U> {
    fn from(t: Vec<T>) -> Self { …

我有以下代码：

use std::io::{Cursor, BufReader, Read};

fn main() {
    let string = String::from("Cello");
    let bytes = string.as_bytes();
    let cursor = Cursor::new(bytes);
    let mut reader = BufReader::new(cursor);
    let mut buf: Vec<u8> = Vec::with_capacity(4);
    assert_eq!(4, buf.capacity());
    reader.read_exact(&mut buf);
    assert_eq!(4, buf.len()); //thread 'main' panicked at 'assertion failed: `(left == right)`
                              //left: `4`, right: `0`'
}

根据std::io::read_exact的文档，它将“读取填充 buf 所需的确切字节数”。但在这种情况下，尽管有 4 个字节的容量，但没有字节被读入 vec。这是怎么回事？

我有一个很大的Vec<u8>代表灰度图像的原始像素值。由于像素格式实际上是 16 位宽度，因此两个u8像素组成一个像素。

现在我想使用图像，就好像它是 8 位宽度一样，所以我只采用像素的较高 8 位部分。

举个例子，给定一个原始 vec v = vec![0,1,2,3,4,5]，我如何通过2引用的步骤来查看它view : &[u8]（无需将它们复制到新的 Vec 中以提高性能），这样就view可以等效于&[0,2,4]. 非常感谢。

我是 Rust 的初学者。我看到pop()向量返回<Option>类型的方法。获取pop()变量值的正确方法是什么？

    let mut queue: Vec<[usize; 2]> = Vec::new();
    queue.push([1, 2]);
    queue.push([3, 4]);

    let coords = queue.pop();
    println!("{}, {}", coords[0], coords[1]);

error[E0608]: cannot index into a value of type `std::option::Option<[usize; 2]>`
  --> src/main.rs:99:24
   |
99 |     println!("{}, {}", coords[0], coords[1]);
   |