在 Rust 语言中，字符串处理是每个开发者必须掌握的核心技能。然而，初学者常常对 String 和 &str 的区别感到困惑：为何有两种字符串类型？何时该用哪一个？它们在性能上有何差异？更进一步地，它们的底层实现机制如何支撑 Rust 的所有权与生命周期系统？

本文将从内存模型、内部结构、性能特征、使用场景及编译器优化五个维度，深入剖析 String 与 &str 的本质差异，帮助你构建对 Rust 字符串系统的专业级理解。

---

一、基本定义与语义差异

String：堆分配的、可变的、拥有的字符串

• 类型：String（结构体）
• 所有权：拥有其数据
• 可变性：可通过 push_str、push 等方法修改
• 存储位置：内容存储在堆上，栈上保存指针、长度和容量
• 生命周期：遵循标准的所有权规则，可被移动或借用

&str：字符串切片，不可变的字符串视图

• 类型：&str（字符串切片，本质是 &[u8] 的特化）
• 所有权：不拥有数据，仅为引用
• 可变性：不可变
• 存储位置：指向任意内存中的 UTF-8 字节序列（如字面量、String 的一部分）
• 生命周期：必须带有生命周期标注（如 'a），确保引用安全

let owned: String = String::from("hello");     // 堆上分配
let slice: &str = "world";                     // 字面量，存储在二进制段
let slice_from_string: &str = &owned[..];     // 借用 String 的一部分

---

二、内部实现：从源码看内存布局

String 的底层结构

String 本质上是对 Vec<u8> 的封装，其内部结构如下（简化）：

struct String {
    ptr: *mut u8,      // 指向堆上数据的指针
    len: usize,        // 当前使用的字节数（UTF-8 编码）
    cap: usize,        // 堆分配的总容量（字节）
}

• 堆分配：调用 String::from 或 push_str 时，Rust 使用系统分配器（如 jemalloc 或 mimalloc）在堆上分配内存。
• 动态扩容：当容量不足时，自动重新分配更大内存块，并复制数据（类似 Vec）。
• UTF-8 保证：String 始终保证其内容是合法的 UTF-8 编码，这是编译器强制的。

&str 的底层结构

&str 是一个胖指针（fat pointer），其内部表示为：

struct StrSlice {
    data: *const u8,   // 指向字节序列的指针
    len: usize,        // 字节长度
}

• 无所有权：它不管理内存，仅提供对已有数据的只读视图。
• 来源多样：
  • 字符串字面量：存储在程序的 .rodata 段，生命周期为 'static
  • String 的切片：如 &s[3..5]，指向堆上某段
  • 文件映射、网络缓冲区等任意内存区域

---

三、性能对比：栈、堆与缓存局部性

特性	String	&str
分配开销	高（堆分配 + 初始化）	零（仅创建指针）
复制开销	高（默认移动，clone 为深拷贝）	低（仅复制指针和长度，8 或 16 字节）
内存局部性	堆上，可能缓存未命中	取决于所指内存位置
访问速度	O(1) 索引，但受堆访问延迟影响	O(1) 索引，若指向栈或 .rodata 则更快

关键洞察：

• &str 的创建几乎是零成本的，适合高频使用的只读场景（如函数参数）。
• String 的 clone() 是深拷贝，代价高昂，应避免在热路径中频繁调用。

---

四、工程实践：如何选择 String 与 &str？

1. 函数参数：优先使用 &str

// ✅ 推荐：接受任何字符串来源
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

// 调用方式灵活：
greet("Alice");           // 字面量
greet(&my_string);        // String 借用
greet(&my_string[0..3]);  // 切片

使用 &str 提升了函数的通用性，避免强制调用者拥有 String。

2. 数据结构字段：根据所有权需求选择

struct User {
    name: String,     // ✅ 拥有名字，可持久化存储
    temp_note: &'static str, // ❌ 仅适用于常量
}

// 若需存储动态切片，必须引入生命周期：
struct LogEntry<'a> {
    message: &'a str, // 指向外部数据，生命周期绑定
}

原则：若结构体需独立存在，字段应使用 String；若仅为临时视图，用 &str 并标注生命周期。

3. 返回值：避免返回局部 &str

// ❌ 错误：返回指向局部变量的引用
fn get_name() -> &str {
    let s = String::from("Bob");
    &s  // s 被释放，悬垂引用！
}

// ✅ 正确：返回拥有权
fn get_name() -> String {
    String::from("Bob")
}

// 或返回静态字面量
fn get_default() -> &'static str {
    "Unknown"
}

---

五、编译器优化与零成本抽象

Rust 编译器对字符串切片进行了深度优化：

• 字面量去重：相同字面量共享内存。
• 切片常量折叠：&"hello world"[0..5] 在编译期计算为 "hello"。
• Deref ** coercion**：String 可自动解引用为 &str，实现无缝转换：

let s: String = String::from("test");
let slice: &str = &s; // 自动调用 Deref::deref

这体现了 Rust 的“零成本抽象”理念：高层抽象（如自动解引用）不带来运行时开销。

---

六、高级话题：CString、OsString 与国际化

• CString：C 兼容的空终止字符串，用于 FFI。
• OsString：操作系统原生字符串（如 Windows 的 UTF-16），用于路径处理。
• &str 仅保证 UTF-8，若需处理非 UTF-8 输入，应使用 Vec<u8> 或 CStr。

---

结语：理解本质，写出高效安全的 Rust 代码

String 与 &str 的设计，深刻体现了 Rust 的核心哲学：

• 内存安全：通过所有权与生命周期防止悬垂指针。
• 性能优先：&str 的零分配特性支持高性能文本处理。
• 抽象优雅：Deref 强制与模式匹配实现无缝集成。

掌握它们的内部机制，不仅能避免常见陷阱，更能写出既安全又高效的系统级代码。记住：

“用 &str 接受，用 String 拥有” —— 这是 Rust 字符串使用的黄金法则。