Rust By Practice 实战:掌握动态数组 Vec 的增删、转换、切片与容量管理

原创2026-09-21 12:13:311,812 阅读
文章标签:文档教程教育

Rust By Practice 实战:掌握动态数组 Vec 的增删、转换、切片与容量管理

Vec<T> 是 Rust 标准库中最常用的堆上动态数组,与定长数组 <a href="https://link.gitcode.com/i/a31b06d52ee52c09bf4d29ae06f86a92" target="_blank">T; N] 相比,它最大的特点是长度可以在运行时动态调整。本篇基于 [Rust By Practice 集合类型章节的 Vector 练习单元,通过 8 道分级练习题系统讲解 Vec 的创建与增删元素、From/Into 类型转换、索引访问、切片借用、容量(capacity)与内存分配策略,以及如何在同一个 Vec 中存储不同类型的元素。学完本篇,你将能够写出高性能、零多余内存分配且类型安全的动态数组代码。

认识 Vector:可动态调整长度的数组

Rust 中用于承载同类型元素的连续序列有两种核心形式:

  • 定长数组 [T; N]:长度在编译期固定,无法在运行时增删元素;
  • 动态数组 Vec<T>:长度在运行时可变,元素连续存储在堆上,可以随时 push 或 pop。

Vec 与切片、字符串之间存在紧密的对应关系:&<a href="https://link.gitcode.com/i/065a89333fc52b53f36a91eeb70b7486" target="_blank">T] 之于 Vec<T>,正如 &str 之于 String。String 的底层正是 Vec<u8>。若想系统回顾定长数组与切片,可参考仓库中的 [数组章节 与 切片章节;而 Vec 在集合类型章节中的位置,可见 SUMMARY.md 中"集合类型"一节。

创建 Vec 的三种基本方式

练习 1 展示了 Vec 的三种常用创建方式:

fn main() {
    let arr: [u8; 3] = [1, 2, 3];

    // 方式一:由数组通过 From 转换而来
    let v = Vec::from(arr);
    is_vec(&v);

    // 方式二:使用 vec! 宏,方括号形式
    let v = vec![1, 2, 3];
    is_vec(&v);

    // 方式三:vec! 宏的花括号形式,与方括号完全等价
    let v = vec!(1, 2, 3);
    is_vec(&v);

    println!("Success!")
}

fn is_vec(v: &Vec<u8>) {}

需要特别注意的是:vec!(arr) 中的 arr 是 <a href="https://link.gitcode.com/i/67caf4b6423e9984462255c59a41c383" target="_blank">u8; 3] 类型的数组,因此 v1 的类型是 Vec<[u8; 3]> 而不是 Vec<u8>。官方题解(见 [Vector.md 题解)要求用 Vec::new 配合 for 循环重写 v1 的构造,将数组中的元素逐个取出压入新的 Vec:

// 题解:用 Vec::new + for 循环逐元素构造 Vec<u8>
let mut v1 = Vec::new();
for i in &v {
    v1.push(*i);
}

这道题同时揭示了 vec! 宏的语法细节:宏可以使用 []、()、{} 三种定界符,它们只是书写形式不同,语义完全一致。

用 pop 与 push 增删元素

pop 从尾部移除并返回最后一个元素,push 从尾部追加一个元素。练习 2 先用这两者将 v1 调整为 [1, 2, 3],再要求你用 extend 方法批量扩展 v2:

// 填空
fn main() {
    let mut v1 = Vec::from([1, 2, 4]);
    v1.pop();      // 移除 4,v1 变为 [1, 2]
    v1.push(3);    // 追加 3,v1 变为 [1, 2, 3]

    let mut v2 = Vec::new();
    v2.extend([1, 2, 3]);   // 批量追加可迭代序列

    assert_eq!(v1, v2);
    println!("Success!")
}

extend 接收任何实现了 IntoIterator 的类型(数组、切片、迭代器等),可以一次性把多个元素追加到 Vec 尾部,比逐个 push 更高效、更简洁。

将其他类型转换为 Vec:From / Into 特征

Vec 的另一个强大之处在于,标准库为它实现了多个 From<T> 特征。只要某类型 T 为 Vec 实现了 From<T>,那么 T 就能被转换成 Vec。关于 From/Into 特征的通用机制,可参考仓库中的 From/Into 章节:实现了 impl From<T> for U 之后,U::from(T) 与 T.into() 两种写法均可使用,后者由 Into 自动派生。

练习 3 集中考察了四类常见转换:

// 填空
fn main() {
    // array -> Vec:impl From<[T; N]> for Vec
    let arr = [1, 2, 3];
    let v1 = Vec::from(arr);
    let v2: Vec<i32> = arr.into();
    assert_eq!(v1, v2);

    // String -> Vec:impl From<String> for Vec(按字节取出)
    let s = "hello".to_string();
    let v1: Vec<u8> = s.into();

    let s = "hello".to_string();
    let v2 = s.into_bytes();
    assert_eq!(v1, v2);

    // &str -> Vec:impl<'_> From<&'_ str> for Vec
    let s = "hello";
    let v3 = Vec::from(s);
    assert_eq!(v2, v3);

    // 迭代器 -> Vec:通过 collect 收集
    let v4: Vec<i32> = [0; 10].into_iter().collect();
    assert_eq!(v4, vec![0; 10]);

    println!("Success!")
}

四种转换的关键点:

源类型 转换方式 结果类型 说明
[T; N] 数组 Vec::from(arr) 或 arr.into() Vec<T> 基于 impl From<[T; N]> for Vec
String s.into() 或 s.into_bytes() Vec<u8> 字符串按字节序列取出
&str Vec::from(s) Vec<u8> 借用字符串的字节
迭代器 iterator.collect() Vec<T> 配合类型标注使用

注意:使用 into() 时通常需要显式标注目标类型(如 let v2: Vec<i32> = arr.into()),因为编译器无法自动推断转换目标。而 String::into_bytes() 返回 Vec<u8>,这是字符串转字节最直白的途径。

索引访问与越界问题

Vec 支持通过下标 v[i] 直接访问元素,但下标越界会直接触发 panic。练习 4 的第一段循环 for i in 0..5 访问只有 3 个元素的 v[i],正是为了让你亲身体验越界:

fn main() {
    let mut v = Vec::from([1, 2, 3]);
    for i in 0..5 {
        println!("{:?}", v[i])   // i 达到 3、4 时越界 panic
    }
    // ...
}

官方题解给出了两种修复思路:

思路一:改用 get(i) 返回 Option<&T>,并配合 if let 安全兜底

let mut v = Vec::from([1, 2, 3]);
for i in 0..5 {
    println!("{:?}", v.get(i))   // 越界时返回 None,不 panic
}

for i in 0..5 {
    if let Some(x) = v.get(i) {
        v[i] = x + 1;            // 已有元素则 +1
    } else {
        v.push(i + 2);           // 越界位置则扩容补元素
    }
}
assert_eq!(v, vec![2, 3, 4, 5, 6]);

思路二:保证循环范围不超过元素数量

let mut v = Vec::from([1, 2, 3, 4, 5]);
for i in 0..5 {
    v[i] += 1;                   // 5 个元素恰好对应 0..5
}
assert_eq!(v, vec![2, 3, 4, 5, 6]);

这组对比说明了索引访问的取舍:直接下标访问 v[i] 性能最佳但越界即 panic;get(i) 返回 Option<&T> 更安全,适合不确定下标是否合法、需要优雅兜底的场景。

切片(Slicing):只读借用的最佳实践

与 String 的切片类似,Vec 也可以通过 & 获取切片。Vec 是可变的,而它的切片是不可变(只读)借用;当然也可以获取可变切片 &mut [T]。

在 Rust 中,当函数只需要读取数据时,优先传递切片 &[T] 而不是 Vec<T>:切片的借用不会发生所有权转移(no move),也不会产生拷贝(no copy),更加灵活高效。这正对应 &str 与 String 的关系——&[T] 之于 Vec<T>,如同 &str 之于 String。

练习 5 集中考察了切片的使用与误区:

// 修复错误
fn main() {
    let mut v = vec![1, 2, 3];

    let slice1 = &v[..];        // 全切片,等价于 &v[0..v.len()]
    // 越界访问将导致 panic,修改时必须使用 v.len
    let slice2 = &v[0..3];      // 原题的 &v[0..4] 越界,需改为 v.len 范围内的值

    assert_eq!(slice1, slice2);

    // 注意:切片和 &Vec 是不同的类型
    // &Vec 仅仅是 Vec 的引用,可通过解引用获取 Vec 并调用其方法
    let vec_ref: &mut Vec<i32> = &mut v;
    (*vec_ref).push(4);         // 通过 &mut Vec 修改底层数组

    // 可变切片:对切片的修改会同步影响底层 Vec
    let slice3 = &mut v[0..4];
    slice3[3] = 42;             // 切片没有 push 方法,只能按下标写入

    assert_eq!(slice3, &[1, 2, 3, 42]);
    assert_eq!(v, &[1, 2, 3, 42]);

    println!("Success!")
}

该练习中的两个关键修正点(对照 题解):

  1. 切片越界:&v[0..4] 对只有 3 个元素的 v 越界,必须用 v.len() 作为上限。
  2. 切片没有 push:原题中的 slice3.push(4) 无法编译——切片 [T] 是定长视图,不支持扩容,只能通过下标写入既有位置。可变切片写入会直接反映到其底层的 Vec 上。

同时注意 &mut Vec<i32> 与 &mut [i32] 是两个不同的类型:前者是对 Vec 结构本身的引用,可以解引用后调用 push 等方法;后者是对底层连续内存区的可变视图。

容量(Capacity)与内存分配策略

容量(capacity)是 Vec 已经分配好的内存空间,用于存储未来追加的元素;长度(len)是当前 Vec 中实际存储的元素数量。二者是理解 Vec 性能的核心概念。

当新元素加入使 len 将要超过 capacity 时,Vec 会自动扩容:Rust 会重新分配一块更大的内存,并把旧元素整体拷贝过去。目前 Rust 的容量调整策略是加倍增长(例如 2 → 4 → 8 → 16 …)。如果扩容频繁发生,反复的内存分配与拷贝会显著拖慢系统性能,因此最好的做法是在创建时用 Vec::with_capacity 提前分配足够的容量,尽量减少分配次数。

练习 6 通过一个完整的观察实验验证了上述机制:

// 修复错误
fn main() {
    let mut vec = Vec::with_capacity(10);

    // 提前分配了 10 的容量,但还没有元素
    assert_eq!(vec.len(), 0);
    assert_eq!(vec.capacity(), 10);

    // 由于提前设置了足够的容量,前 10 次 push 不触发任何内存分配
    for i in 0..10 {
        vec.push(i);
    }
    assert_eq!(vec.len(), 10);
    assert_eq!(vec.capacity(), 10);

    // 第 11 个元素超出容量,触发重新分配
    vec.push(11);
    assert_eq!(vec.len(), 11);
    assert!(vec.capacity() >= 11);

    // 填写合适的值,让下面的 for 循环全程不发生内存分配
    let mut vec = Vec::with_capacity(100);
    for i in 0..100 {
        vec.push(i);
    }
    assert_eq!(vec.len(), 100);
    assert_eq!(vec.capacity(), 100);

    println!("Success!")
}

关键结论(均可用 题解 中的断言验证):

  • len() 与 capacity() 是两个独立的概念:容量 10、长度 0 表示"空数组但已预留 10 个元素的空间";
  • 只要 push 数量不超过容量,capacity 保持不变、不发生内存分配;
  • 当 len 即将超过 capacity 时触发重新分配,capacity 至少翻倍,这也是最后一道填空必须填 100 的原因——恰好与循环的 100 次 push 匹配,从而做到零分配。

在同一个 Vec 中存储不同类型的元素

Vec 要求元素类型完全一致,vec![1, 2.0, 3] 这类混合 i32 与 f64 的写法会直接编译报错。要在一个 Vec 中容纳不同类型,标准做法有两种:枚举 与 特征对象。

方案一:使用枚举包装

练习 7 用枚举把 V4(String) 与 V6(String) 两种变体统一为 IpAddr 类型:

#[derive(Debug, PartialEq)]
enum IpAddr {
    V4(String),
    V6(String),
}

fn main() {
    // 填空
    let v: Vec<IpAddr> = vec![
        IpAddr::V4("127.0.0.1".to_string()),
        IpAddr::V6("::1".to_string()),
    ];

    // 枚举的比较需要派生 PartialEq 特征
    assert_eq!(v[0], IpAddr::V4("127.0.0.1".to_string()));
    assert_eq!(v[1], IpAddr::V6("::1".to_string()));

    println!("Success!")
}

注意:原题的 #[derive(Debug)] 不足以支撑 assert_eq! 比较,题解中补充了 PartialEq 派生——枚举之间进行 == 比较必须实现 PartialEq 特征。

方案二:使用特征对象(Box + dyn Trait)

练习 8 改用特征对象:为两个结构体实现同一个 IpAddr 特征,再用 Box<dyn IpAddr> 装箱后存入 Vec:

trait IpAddr {
    fn display(&self);
}

struct V4(String);
impl IpAddr for V4 {
    fn display(&self) {
        println!("ipv4: {:?}", self.0)
    }
}

struct V6(String);
impl IpAddr for V6 {
    fn display(&self) {
        println!("ipv6: {:?}", self.0)
    }
}

fn main() {
    // 填空:Vec<Box<dyn IpAddr>>
    let v: Vec<Box<dyn IpAddr>> = vec![
        Box::new(V4("127.0.0.1".to_string())),
        Box::new(V6("::1".to_string())),
    ];

    for ip in v {
        ip.display();
    }
}

两种方案的取舍:

  • 枚举:变体集合封闭、编译期可知,类型安全且无动态分发开销,但每增加一种类型都要修改枚举定义;
  • 特征对象 Box<dyn Trait>:变体开放、运行时多态,新增类型无需改动既有代码,但会引入一次指针间接寻址与动态分发的开销。

若想深入了解特征对象与 Box 的机制,可进一步阅读仓库中的 特征对象章节 与 Box 章节。

练习答案获取

本篇所有练习的官方参考答案均存放在仓库的 solutions/collections/Vector.md 中,完成练习后可对照题解核对自己的实现;同时,仓库提供了 link_solution 脚本,可以快速建立练习与题解之间的关联,便于逐个题目校验。建议先独立完成练习题,再对照题解,效果最佳。

登录后查看全文
rust-by-practice