移动语义发生时机 ​

面试题 ​

请列举 Rust 中移动语义(move)发生的所有场景,并解释移动与拷贝的关系。

考察意图 ​

考察候选人能否全面列举移动发生的时机,理解移动的本质(所有权转移而非数据搬运),以及移动与 Copy 的关系。这直接影响日常编码中对变量有效性的判断。

答题要点 ​

移动发生的场景 ​

rust
fn main() {
    // === 1. 变量赋值 ===
    let s1 = String::from("hello");
    let s2 = s1;           // 移动:s1 无效
    // println!("{}", s1); // 编译错误

    // === 2. 函数传参 ===
    let s3 = String::from("world");
    takes_string(s3);      // 移动到函数参数
    // println!("{}", s3); // 编译错误

    // === 3. 函数返回值 ===
    let s4 = gives_string();  // 从函数中移出
    println!("{}", s4);

    // === 4. 模式匹配中的绑定 ===
    let opt = Some(String::from("data"));
    if let Some(s) = opt {     // 移动到 s
        println!("{}", s);
    }
    // println!("{:?}", opt);  // 编译错误:opt 已被移走

    // === 5. 闭包捕获(move 闭包)===
    let name = String::from("Alice");
    let closure = move || {
        println!("{}", name);  // name 被移动到闭包中
    };
    closure();
    // println!("{}", name);  // 编译错误

    // === 6. 结构体字段访问 ===
    let user = User {
        name: String::from("Bob"),
        age: 25,
    };
    let n = user.name;         // name 字段被移走
    // println!("{}", user.name); // 编译错误:部分移动
    println!("age: {}", user.age); // age 是 Copy,仍然有效

    // === 7. Vec/集合的元素移出 ===
    let mut v = vec![String::from("a"), String::from("b")];
    let first = v.remove(0);   // 移出第一个元素
    println!("移出: {}", first);
    // v[0] 已经被移走,Vec 已调整
}

fn takes_string(s: String) {
    println!("接收: {}", s);
}

fn gives_string() -> String {
    String::from("returned")
}

struct User {
    name: String,
    age: u32,
}

移动的本质 ​

rust
fn main() {
    // 移动的本质:
    // 1. 在内存层面,数据可能并没有"搬运"
    //    编译器只是将所有权标记从旧变量转移到新变量
    // 2. 旧变量在编译期被标记为无效,不能再使用
    // 3. 只有新变量负责最终的 drop

    let s = String::from("hello");
    // s 在栈上有 3 个字段:ptr, len, capacity
    // 移动时,这 3 个字段被复制到 s2 的栈位置
    // 堆上的数据 "hello" 没有被复制
    // s 被标记为无效

    let s2 = s;
    println!("{}", s2);

    // 对于 Copy 类型,赋值是按位复制,两个变量都有效
    let n = 42;
    let m = n;  // 按位复制,n 仍然有效
    println!("n={}, m={}", n, m);
}

部分移动 ​

rust
#[derive(Debug)]
struct Config {
    name: String,    // 不是 Copy
    port: u16,       // 是 Copy
    debug: bool,     // 是 Copy
}

fn main() {
    let config = Config {
        name: "server".to_string(),
        port: 8080,
        debug: true,
    };

    // 移走 name 字段
    let name = config.name;

    // config 整体不能再使用(部分移动)
    // println!("{:?}", config);     // 编译错误

    // 但 Copy 字段仍然可以访问
    println!("port: {}", config.port);
    println!("debug: {}", config.debug);
    println!("name: {}", name);
}

常见追问 ​

追问一:for 循环会移动吗?

for item in collection 会移动(消费)集合。for item in &collection 是借用。for item in &mut collection 是可变借用。into_iter() 消费集合,iter() 借用,iter_mut() 可变借用。

追问二:swap 和 replace 为什么不触发移动问题?

std::mem::swap 和 std::mem::replace 是安全的——它们在交换或替换时保证旧值不会被 drop 两次,也不会产生无效状态。replace 返回旧值的所有权。

追问三:解构赋值会移动吗?

会。let (a, b) = tuple; 如果元组中的元素不是 Copy 的,它们会被移动到 a 和 b。let Struct { field1, field2 } = s; 同理。

基本示例 ​

rust
fn main() {
    // 综合示例:各种移动场景

    // 赋值移动
    let data = vec![1, 2, 3];
    let data2 = data;
    println!("{:?}", data2);

    // for 循环消费
    for item in data2 {    // data2 被消费
        print!("{} ", item);
    }
    println!();
    // println!("{:?}", data2);  // 编译错误

    // 避免移动的方式
    let data3 = vec![4, 5, 6];
    for item in &data3 {   // 借用,不消费
        print!("{} ", item);
    }
    println!();
    println!("{:?}", data3);  // data3 仍然有效

    // match 中的移动与借用
    let opt: Option<String> = Some("hello".to_string());
    match &opt {               // 借用 opt
        Some(s) => println!("有值: {}", s),
        None => println!("无值"),
    }
    println!("{:?}", opt);     // opt 仍然有效

    // replace 安全替换
    let mut s = String::from("old");
    let old = std::mem::replace(&mut s, String::from("new"));
    println!("旧值: {}, 新值: {}", old, s);
}

常见问题 ​

问题一:移动之后内存发生了什么?

堆数据不动,栈上的指针/元数据被复制到新位置。旧变量的栈空间不会被立即回收(等待函数返回),但编译器禁止再使用旧变量。

问题二:编译器怎么追踪移动?

编译器在编译期维护每个变量的"初始化状态"。移动后标记为"未初始化",后续使用未初始化的变量会报错。这完全是编译期行为。

适用场景 ​

  • 所有权传递:将数据从一个上下文转移到另一个
  • 构建器模式:链式方法调用中传递所有权
  • 线程间传递:move 闭包将数据移入线程
  • 返回值:函数将内部创建的数据移出

注意事项 ​

  • 非 Copy 类型赋值即移动
  • 移动后原变量不可用
  • 部分移动后整体不可用但 Copy 字段仍可访问
  • for item in collection 消费集合
  • move 闭包强制移动所有捕获的变量
  • 用借用和 clone 避免不想要的移动

总结 ​

移动语义在以下场景发生:变量赋值、函数传参、函数返回、模式匹配绑定、move 闭包捕获、结构体字段提取、集合元素移出、for 循环消费。移动的本质是所有权转移——栈上的元数据被复制,堆上的数据不动,旧变量被标记为无效。Copy 类型赋值时按位复制而非移动。部分移动后整体不可用但 Copy 字段仍可访问。用借用(&T / &mut T)和 clone 可以避免不想要的移动。