Rust By Practice 实战:掌握动态数组 Vec 的增删、转换、切片与容量管理
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!")
}
该练习中的两个关键修正点(对照 题解):
- 切片越界:
&v[0..4]对只有 3 个元素的v越界,必须用v.len()作为上限。 - 切片没有
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 脚本,可以快速建立练习与题解之间的关联,便于逐个题目校验。建议先独立完成练习题,再对照题解,效果最佳。