移动 Move 语义
什么是移动语义
移动(Move)是 Rust 中所有权转移的过程。当一个非 Copy 类型的值从一个变量赋值给另一个变量时,所有权从旧变量转移到新变量,旧变量立即失效,不能再使用。移动在内存层面只是拷贝了栈上的元数据(指针、长度、容量),堆上的数据没有被复制,因此移动操作的开销很小。
fn main() {
let s1 = String::from("hello");
// 移动:s1 的所有权转移到 s2
// 栈上的 (ptr, len, cap) 被复制到 s2
// 堆上的 "hello" 数据没有被复制
// s1 被标记为无效
let s2 = s1;
println!("{}", s2); // s2 是新的所有者
// println!("{}", s1); // 编译错误:value borrowed here after move
}触发移动的场景
变量赋值
fn main() {
let v1 = vec![1, 2, 3];
let v2 = v1; // 移动
// v1 不再可用
println!("{:?}", v2);
// let 绑定也是移动
let a = String::from("data");
let b = a; // 移动
// a 不再可用
println!("{}", b);
}函数传参
fn take_string(s: String) {
// s 获得了所有权
println!("函数内:{}", s);
// 函数结束时 s 被销毁
}
fn take_vec(v: Vec<i32>) {
println!("函数内:{:?}", v);
}
fn main() {
let s = String::from("hello");
take_string(s); // s 的所有权移动到函数参数
// println!("{}", s); // 编译错误:s 已移动
let v = vec![1, 2, 3];
take_vec(v); // v 的所有权移动到函数参数
// println!("{:?}", v); // 编译错误:v 已移动
}函数返回值
fn create_string() -> String {
let s = String::from("从函数返回");
s // 所有权移动给调用者
}
fn transform(mut s: String) -> String {
// 接收所有权,处理后返回
s.push_str("_transformed");
s // 所有权移动回调用者
}
fn main() {
let s1 = create_string(); // 所有权从函数返回
println!("{}", s1);
let s2 = transform(s1); // s1 移入函数,结果移出
// s1 已移动,不可用
println!("{}", s2);
}集合操作
fn main() {
let mut names = vec![
String::from("Alice"),
String::from("Bob"),
String::from("Charlie"),
];
// remove 会移出元素的所有权
let removed = names.remove(1); // "Bob" 被移出
println!("移出:{}", removed);
println!("剩余:{:?}", names);
// pop 也会移出所有权
if let Some(last) = names.pop() {
println!("弹出:{}", last);
}
}模式匹配
fn main() {
let pair = (String::from("key"), String::from("value"));
// 解构会移动
let (k, v) = pair;
// pair 不再可用
println!("键:{},值:{}", k, v);
// match 也会移动
let data = Some(String::from("数据"));
match data {
Some(s) => println!("有值:{}", s),
None => println!("无值"),
}
// data 已被移动,不可用
}移动的内存原理
fn main() {
let s1 = String::from("hello");
// 移动前:
// s1 栈上:[ptr -> 堆, len=5, cap=5]
// 堆上: [h, e, l, l, o]
let s2 = s1;
// 移动后:
// s1 栈上:[已失效,不可访问]
// s2 栈上:[ptr -> 堆, len=5, cap=5] (和 s1 之前一样)
// 堆上: [h, e, l, l, o] (没有复制,还是同一块)
// 只有一个所有者(s2),所以只会释放一次
println!("{}", s2);
}部分移动
结构体的字段可以被单独移动,但移动了部分字段后,整个结构体就不能再作为整体使用了。
struct Person {
name: String,
age: u32, // Copy 类型
email: String,
}
fn main() {
let person = Person {
name: String::from("张三"),
age: 28,
email: String::from("z@test.com"),
};
// 部分移动:只移动 name 字段
let name = person.name;
// age 是 Copy 类型,不受影响
println!("年龄:{}", person.age);
// email 没有被移动,仍然可以使用
println!("邮箱:{}", person.email);
// 但不能使用整体的 person 了
// println!("{:?}", person); // 编译错误
// let p2 = person; // 编译错误
println!("名字:{}", name);
}避免移动的方法
fn main() {
// 方法一:使用引用(借用)
let s = String::from("hello");
print_ref(&s); // 传引用,不移动
println!("仍可用:{}", s); // s 仍然有效
// 方法二:使用 clone
let s2 = s.clone(); // 深拷贝
println!("原始:{},克隆:{}", s, s2);
// 方法三:函数返回所有权
let s3 = String::from("world");
let s3 = take_and_return(s3); // 移入再移出
println!("返回后:{}", s3);
}
fn print_ref(s: &String) {
println!("引用:{}", s);
}
fn take_and_return(s: String) -> String {
println!("处理:{}", s);
s // 返回所有权
}基本示例
用移动语义实现一个简单的消息传递系统:
struct Message {
sender: String,
content: String,
priority: u8,
}
impl Message {
fn new(sender: &str, content: &str, priority: u8) -> Message {
Message {
sender: sender.to_string(),
content: content.to_string(),
priority,
}
}
}
// 显示消息信息
impl std::fmt::Display for Message {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "[P{}] {}: {}", self.priority, self.sender, self.content)
}
}
struct MessageQueue {
messages: Vec<Message>,
}
impl MessageQueue {
fn new() -> MessageQueue {
MessageQueue {
messages: Vec::new(),
}
}
// send 接收 Message 的所有权
fn send(&mut self, msg: Message) {
println!("入队:{}", msg);
self.messages.push(msg); // msg 移入 Vec
}
// receive 返回 Message 的所有权
fn receive(&mut self) -> Option<Message> {
if self.messages.is_empty() {
None
} else {
// remove(0) 把元素移出 Vec
Some(self.messages.remove(0))
}
}
fn len(&self) -> usize {
self.messages.len()
}
}
fn main() {
let mut queue = MessageQueue::new();
// 创建消息并移入队列
let msg1 = Message::new("系统", "服务已启动", 1);
let msg2 = Message::new("用户A", "请求数据", 2);
let msg3 = Message::new("监控", "CPU 使用率 80%", 3);
queue.send(msg1); // msg1 所有权移入队列
queue.send(msg2);
queue.send(msg3);
// msg1, msg2, msg3 不再可用
println!("\n队列中有 {} 条消息\n", queue.len());
// 从队列中取出消息(所有权移出)
while let Some(msg) = queue.receive() {
println!("处理:{}", msg);
// msg 在循环体结束时被销毁
}
println!("\n队列剩余:{} 条", queue.len());
}常见问题
问题一:移动和浅拷贝有什么区别?
在内存操作层面几乎一样——都是复制栈上的数据。关键区别是语义:浅拷贝后两个变量都有效(C/C++),移动后原变量失效(Rust)。Rust 通过让原变量失效来保证只有一个所有者,避免双重释放。
问题二:移动有运行时开销吗?
移动只复制栈上的元数据(通常是 8-24 字节),不复制堆上的数据,开销非常小。编译器还可能优化掉移动操作(比如直接在目标位置构造)。
问题三:为什么 for 循环会移动集合?
for item in collection 消耗 collection 的所有权,每次迭代移出一个元素。如果不想移动,用 for item in &collection(借用)或 for item in &mut collection(可变借用)。
fn main() {
let names = vec![String::from("a"), String::from("b")];
// 移动语义的 for 循环
// for name in names { // names 被消耗
// println!("{}", name);
// }
// names 不再可用
// 借用语义的 for 循环
for name in &names { // 借用 names
println!("{}", name);
}
println!("names 仍可用:{:?}", names);
}问题四:闭包会移动捕获的变量吗?
默认情况下闭包会尽可能地借用。加 move 关键字会强制闭包获取捕获变量的所有权。
fn main() {
let s = String::from("hello");
// move 闭包:获取 s 的所有权
let closure = move || println!("{}", s);
// s 已移动到闭包中,不可用
closure();
}适用场景
- 所有权转移:把资源从一个地方传递到另一个地方
- 集合操作:往集合中添加元素、从集合中取出元素
- 函数传参:让函数拥有数据的所有权
- 线程传递:通过
move闭包把数据移入新线程
注意事项
- 移动只影响非 Copy 类型(
String、Vec、Box等) - 移动后原变量立即失效,使用会编译错误
- 移动只复制栈上的元数据,不复制堆数据,开销很小
- 部分移动后整个结构体不能作为整体使用
- 用引用避免不必要的移动
for item in collection会移动集合,用&collection避免move闭包会移动捕获的变量
总结
移动是 Rust 所有权转移的过程——非 Copy 类型在赋值、传参、返回值时会发生移动。移动后原变量失效,新变量成为唯一的所有者。在内存层面,移动只复制栈上的元数据,不复制堆上的数据,开销很小。移动语义是所有权系统的核心机制,它保证了同一时间只有一个变量拥有堆数据的所有权,从根源上杜绝了双重释放问题。当不需要转移所有权时,用引用(借用)来代替移动。