13.5 避免不必要的克隆与内存分配

在追求高性能的 Rust 程序中，减少不必要的内存分配和数据复制是关键优化方向。尽管 Rust 的所有权模型已避免了隐式拷贝（如 C++ 的拷贝构造），但显式的 .clone() 调用或不当的数据结构选择仍可能引入显著开销，尤其在热路径上。本节将探讨常见陷阱及替代方案。

识别不必要的 clone()

.clone() 是性能问题的常见来源。例如：

fn process_name(name: String) {
    println!("Processing: {}", name);
}

// 调用处
let user = "Alice".to_string();
process_name(user.clone()); // 不必要：函数仅读取内容

此处 clone() 完全多余。更优做法是接受 &str：

fn process_name(name: &str) {
    println!("Processing: {}", name);
}

process_name(&user); // 零成本借用

原则：若函数仅需读取数据，优先使用引用（&T、&[T]、&str）而非拥有权类型（T、Vec<T>、String）。

字符串与集合的高效处理

字符串

• 使用 &str 作为参数类型，除非确实需要转移所有权；
• 避免在循环中反复拼接 String，可预分配或使用 String::with_capacity；
• 对于只读场景，考虑 Cow<str>（写时克隆）平衡灵活性与性能：

use std::borrow::Cow;

fn normalize(input: Cow<str>) -> Cow<str> {
    if input.contains(' ') {
        Cow::Owned(input.replace(' ', "_"))
    } else {
        input // 无修改，直接返回借用
    }
}

向量与切片

• 函数参数优先使用 &[T] 而非 Vec<T>；
• 若需返回集合，考虑让调用者提供缓冲区（如 fn fill_buffer(buf: &mut Vec<u8>)）；
• 避免在循环内 push 未预分配的 Vec，可调用 reserve() 预留空间。

迭代器优于中间集合

链式迭代器通常比创建中间 Vec 更高效：

// 低效：两次分配
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
let evens: Vec<i32> = doubled.into_iter().filter(|x| x % 2 == 0).collect();

// 高效：零分配，单次遍历
let result: Vec<i32> = nums
    .iter()
    .map(|x| x * 2)
    .filter(|x| x % 2 == 0)
    .collect();

编译器通常能将整个迭代器链优化为紧凑循环。

结构体与大对象的传递

对于大型结构体，按值传递会触发 memcpy。应优先通过引用来访问：

struct LargeData {
    buffer: [u8; 1024],
}

fn inspect(data: &LargeData) { /* ... */ } // 推荐
// 而非 fn inspect(data: LargeData)

若必须转移所有权，考虑是否可通过 Box<T> 或引用计数（Arc<T>）共享，而非深拷贝。

内存分配器的影响

Rust 默认使用系统分配器（如 glibc 的 malloc）。在高并发或高频分配场景下，可替换为更高效的分配器：

• mimalloc、tcmalloc、jemalloc（通过 #[global_allocator] 设置）；
• 对于固定大小对象，可使用对象池（如 bumpalo 或自定义 slab allocator）。

但需注意：分配器优化属于高级手段，应在剖析确认分配是瓶颈后再引入。

小结

避免不必要的克隆和分配，核心在于最小化数据移动，最大化借用和零拷贝操作。通过合理选择参数类型、利用迭代器、预分配缓冲区以及审慎使用 clone()，你可以在保持代码安全的同时，显著提升性能。记住：每一次 .clone() 都应有明确理由；若无，很可能就是优化机会。结合性能剖析工具（见 13.4 节），你可以精准定位并消除这些隐藏开销。