Rust面试题及详细答案120道（19-26）-- 所有权与借用

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux… 。

前后端面试题-专栏总目录

一、本文面试题目录

19. 简述Rust的所有权（Ownership）规则，它解决了什么问题？

Rust的所有权（Ownership）是管理内存的核心机制，无需垃圾回收或手动内存管理即可保证内存安全，其核心规则如下：

1. 每个值在Rust中都有一个所有者（Owner）：同一时间只能有一个所有者。
2. 当所有者离开作用域，值会被自动释放：内存通过“作用域结束时调用drop函数”回收。
3. 值的所有权可以转移（Move）：赋值或传递参数时，所有权从原变量转移到新变量，原变量不再可用。

解决的问题：

• 内存安全问题：避免双重释放（同一内存被释放两次）和悬垂指针（引用已释放的内存）。
• 数据竞争问题：通过单一所有者限制，避免多线程同时修改数据。
• 性能问题：无需垃圾回收的运行时开销，内存释放时机可预测。

示例：

{let s = String::from("hello");  // s是"hello"的所有者let s2 = s;                     // 所有权从s转移到s2，s不再可用// println!("{}", s);           // 编译错误：s已失去所有权
}  // s2离开作用域，"hello"被自动释放

20. 什么是移动（Move）语义？为什么Rust默认移动而非复制？

移动（Move）语义：当一个值被赋值给另一个变量（或传递给函数）时，所有权从原变量转移到新变量，原变量不再拥有该值的访问权（即“被移动”）。

示例：

let v1 = vec![1, 2, 3];  // v1拥有向量的所有权
let v2 = v1;             // 向量所有权移动到v2，v1失效
// println!("{:?}", v1); // 编译错误：v1已被移动

默认移动而非复制的原因：

1. 避免双重释放：堆上的数据（如String、Vec）若默认复制，会导致两个变量指向同一内存，离开作用域时双重释放。
2. 明确内存管理：移动语义强制开发者显式处理复制（通过Clone），避免意外的内存开销。
3. 性能优化：对于大型数据，复制操作成本高，移动仅转移所有权（类似指针传递），更高效。

注意：栈上的简单类型（如i32、bool）因实现Copy trait，会默认复制而非移动（见第21题）。

21. 哪些类型实现了Copy trait？Copy与Clone的区别是什么？

实现Copy trait的类型

Copy trait用于标记可通过位复制（bit-for-bit copy）安全复制的类型，通常是栈上存储的简单类型：

• 所有标量类型：i32、u64、f32、bool、char等。
• 包含Copy类型的元组：如(i32, bool)（若元组中所有元素都实现Copy）。
• 不可变引用&T（但可变引用&mut T不实现Copy）。

示例：

let x = 5;       // i32实现Copy
let y = x;       // 复制x的值给y，x仍可用
println!("x: {}, y: {}", x, y);  // 输出：x: 5, y: 5

Copy与Clone的区别

特性	Copy trait	Clone trait
复制方式	隐式的位复制（编译期自动完成）	显式的自定义复制（需调用clone()方法）
适用场景	简单类型（栈上数据）	复杂类型（堆上数据，如String、Vec）
安全性	必须是“无副作用”的复制	可包含自定义逻辑（如深拷贝）
继承关系	实现Copy必须先实现Clone	实现Clone无需Copy

示例：

let s1 = String::from("hello");
// let s2 = s1;  // String未实现Copy，此处为移动，s1失效
let s2 = s1.clone();  // 显式调用clone()复制，s1仍可用
println!("s1: {}, s2: {}", s1, s2);  // 输出：s1: hello, s2: hello

22. 解释借用（Borrowing）的概念，可变借用与不可变借用的规则是什么？

借用（Borrowing）：允许通过引用（&T或&mut T）临时访问值，而不获取所有权。引用离开作用域后，值的所有权仍归原变量。

不可变借用（&T）

• 通过&创建，允许读取值但不能修改。
• 规则：同一作用域内，可存在多个不可变引用（只读共享）。

示例：

let s = String::from("hello");
let r1 = &s;  // 不可变借用
let r2 = &s;  // 允许：多个不可变引用共存
println!("{} {}", r1, r2);  // 输出：hello hello

可变借用（&mut T）

• 通过&mut创建，允许读取和修改值。
• 规则：
  1. 同一作用域内，只能有一个可变引用（独占访问）。
  2. 可变引用与不可变引用不能同时存在（避免读写冲突）。

示例：

let mut s = String::from("hello");
let r1 = &mut s;  // 可变借用
// let r2 = &mut s; // 错误：同一作用域只能有一个可变引用
r1.push_str(" world");
println!("{}", r1);  // 输出：hello world// 可变引用与不可变引用不能共存
let r3 = &s;       // 不可变引用
// let r4 = &mut s; // 错误：已有不可变引用时不能创建可变引用

借用的核心目的：在保证内存安全的前提下，实现临时访问值，避免频繁的所有权转移。

23. 为什么会出现“借用检查器（Borrow Checker）”报错？如何避免？

借用检查器（Borrow Checker） 是Rust编译器的组件，用于在编译期验证引用的合法性，确保遵循借用规则（见第22题）。若违反规则，会产生编译错误。

常见报错原因

1. 可变引用与不可变引用共存：同一作用域内同时存在可变引用和不可变引用。
2. 多个可变引用共存：同一作用域内存在多个可变引用。
3. 引用生命周期长于被引用值：引用指向的值已被释放（悬垂引用）。

示例：借用检查器报错

let r;
{let x = 5;r = &x;  // 错误：x的生命周期短于r，r会成为悬垂引用
}
// println!("{}", r);

避免方法

1. 缩小引用作用域：让引用在被引用值释放前失效。

   let x = 5;
   {let r = &x;  // r的作用域小于xprintln!("{}", r);
   }  // r失效，x仍有效
   

2. 避免混合借用：在需要修改值时，确保没有其他引用存在。

   let mut s = String::from("hello");
   {let r1 = &s;  // 不可变引用作用域受限
   }
   let r2 = &mut s;  // 此时无其他引用，允许创建可变引用
   

3. 显式转移所有权：若无法通过借用解决，可通过clone()复制值或转移所有权。

24. 什么是悬垂引用（Dangling Reference）？Rust如何防止这种情况？

悬垂引用（Dangling Reference）：指向已被释放内存的引用，访问此类引用会导致未定义行为（如读取无效数据）。

示例：其他语言可能出现的悬垂引用

// C语言示例（不安全）
int* dangling() {int x = 5;return &x;  // x离开作用域后被释放，返回的指针成为悬垂指针
}

Rust如何防止悬垂引用？

Rust的生命周期系统和借用检查器在编译期确保：

1. 引用的生命周期不能长于被引用值的生命周期：编译器会检查引用的作用域是否在被引用值的作用域内。
2. 值被释放前，所有引用必须失效：当值离开作用域时，其所有引用已不可访问。

Rust中的编译期阻止：

fn dangle() -> &String {  // 错误：缺少生命周期标注（实际编译会更详细）let s = String::from("hello");&s  // s的生命周期仅限于函数内，返回的引用会悬垂
}

正确做法：返回值的所有权而非引用，或确保被引用值的生命周期足够长。

fn no_dangle() -> String {  // 返回所有权let s = String::from("hello");s
}

25. 如何理解“引用的生命周期不能长于被引用值的生命周期”？

“引用的生命周期不能长于被引用值的生命周期”是Rust内存安全的核心原则，可理解为：引用必须在被引用值释放前失效，确保引用始终指向有效的内存。

原理说明

• 生命周期（Lifetime）：值在内存中存在的时间段（从创建到释放）。
• 若引用的生命周期长于被引用值，当值被释放后，引用会成为悬垂引用，导致访问无效内存。

示例：违反原则的情况

let r;                // r的生命周期开始
{let x = 5;        // x的生命周期开始r = &x;           // r引用x，但x的生命周期短于r
}                     // x的生命周期结束（被释放）
// println!("{}", r); // 错误：r的生命周期长于x，访问会导致悬垂引用

示例：遵循原则的情况

let x = 5;            // x的生命周期开始
let r = &x;           // r的生命周期开始，且短于x
println!("{}", r);    // 正确：r的生命周期在x的生命周期内
// x的生命周期结束，r的生命周期也已结束

编译器的保证：Rust通过生命周期推断和标注，在编译期确保所有引用都遵循此原则，避免运行时错误。

26. 举例说明同一作用域中，不可变引用与可变引用的共存限制。

Rust为避免数据竞争，严格限制同一作用域中不可变引用（&T）与可变引用（&mut T）的共存：不可变引用与可变引用不能同时存在，且同一时间只能有一个可变引用。

限制1：不可变引用存在时，不能创建可变引用

let mut s = String::from("hello");let r1 = &s;  // 不可变引用
let r2 = &s;  // 允许：多个不可变引用共存
// let r3 = &mut s; // 错误：已有不可变引用时，不能创建可变引用println!("{} and {}", r1, r2);  // 正确：使用不可变引用

限制2：可变引用存在时，不能创建不可变引用

let mut s = String::from("hello");let r1 = &mut s;  // 可变引用
// let r2 = &s;    // 错误：已有可变引用时，不能创建不可变引用
// let r3 = &mut s;// 错误：同一作用域只能有一个可变引用r1.push_str(" world");
println!("{}", r1);  // 正确：使用可变引用

允许的情况：引用作用域分离

若引用的作用域不重叠（通过代码块分隔），则可变引用和不可变引用可交替存在：

let mut s = String::from("hello");{let r1 = &mut s;  // 可变引用作用域限制在代码块内r1.push_str(" world");
}  // r1失效，不再有可变引用let r2 = &s;  // 此时可创建不可变引用
let r3 = &s;  // 多个不可变引用也允许
println!("{} and {}", r2, r3);  // 输出：hello world and hello world

设计目的：防止“读写冲突”和“写写冲突”，确保多线程环境下的数据安全，是Rust无数据竞争并发的基础。

二、120道Rust面试题目录列表

文章序号	Rust面试题120道
1	Rust面试题及详细答案120道（01-10）
2	Rust面试题及详细答案120道（11-18）
3	Rust面试题及详细答案120道（19-26）
4	Rust面试题及详细答案120道（27-32）
5	Rust面试题及详细答案120道（33-41）
6	Rust面试题及详细答案120道（42-50）
7	Rust面试题及详细答案120道（51-57）
8	Rust面试题及详细答案120道（58-65）
9	Rust面试题及详细答案120道（66-71）
10	Rust面试题及详细答案120道（72-80）
11	Rust面试题及详细答案120道（81-89）
12	Rust面试题及详细答案120道（90-98）
13	Rust面试题及详细答案120道（99-105）
14	Rust面试题及详细答案120道（106-114）
15	Rust面试题及详细答案120道（115-120）