移动 Move 语义 ​

什么是移动语义 ​

移动(Move)是 Rust 中所有权转移的过程。当一个非 Copy 类型的值从一个变量赋值给另一个变量时,所有权从旧变量转移到新变量,旧变量立即失效,不能再使用。移动在内存层面只是拷贝了栈上的元数据(指针、长度、容量),堆上的数据没有被复制,因此移动操作的开销很小。

rust
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
}

触发移动的场景 ​

变量赋值 ​

rust
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);
}

函数传参 ​

rust
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 已移动
}

函数返回值 ​

rust
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);
}

集合操作 ​

rust
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);
    }
}

模式匹配 ​

rust
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 已被移动,不可用
}

移动的内存原理 ​

rust
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);
}

部分移动 ​

结构体的字段可以被单独移动,但移动了部分字段后,整个结构体就不能再作为整体使用了。

rust
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);
}

避免移动的方法 ​

rust
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  // 返回所有权
}

基本示例 ​

用移动语义实现一个简单的消息传递系统:

rust
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(可变借用)。

rust
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 关键字会强制闭包获取捕获变量的所有权。

rust
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 类型在赋值、传参、返回值时会发生移动。移动后原变量失效,新变量成为唯一的所有者。在内存层面,移动只复制栈上的元数据,不复制堆上的数据,开销很小。移动语义是所有权系统的核心机制,它保证了同一时间只有一个变量拥有堆数据的所有权,从根源上杜绝了双重释放问题。当不需要转移所有权时,用引用(借用)来代替移动。