番外-rust基础move_semantics-移动语义

Rust 中的 move semantics（移动语义） 是其所有权系统的核心特性之一。它决定了数据的所有权如何在程序中转移以及如何在程序执行过程中确保内存安全。

1. 基本概念：所有权（Ownership）

Rust 的所有权系统要求每个值都有一个所有者，并且该值在同一时间只能有一个所有者。这就引入了 所有权的转移（move） 和 借用（borrow） 两个关键概念。

2. 移动语义（Move Semantics）

在 Rust 中，当你将一个变量赋值给另一个变量时，默认情况下是 移动（move） 数据的所有权，而不是复制数据。这意味着，原来的变量不再拥有该数据，且不能再访问它，直到它被重新赋值。

3. Move vs Clone

在默认情况下，Rust 会 移动 数据的所有权，而不是复制数据。如果你想要 复制 数据而不是移动，你需要显式调用 clone() 方法。clone() 会为数据分配新的内存并将数据复制过去。

示例：移动（Move）消费

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // s1 的所有权被移动到 s2
 
    // println!("{}", s1); // 错误！s1 已经不再拥有数据
    println!("{}", s2); // 输出: Hello
}

在这个例子中，s1 的所有权被移动到 s2，因此 s1 在移动后不再有效。如果你尝试使用 s1，会导致编译错误。

示例：克隆（Clone）-不想被消费，保留原来的使用权

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1.clone(); // 复制数据，而不是移动所有权
 
    println!("{}", s1); // 输出: Hello
    println!("{}", s2); // 输出: Hello
}

在这个例子中，clone() 方法被用来创建 s1 的一个深拷贝，因此 s1 仍然有效。

4. 函数中的移动

当你将一个变量作为函数的参数传递时，Rust 会根据该变量的类型决定是否移动所有权。

示例：在函数中移动所有权

fn take_ownership(s: String) {
    println!("{}", s);
}
 
fn main() {
    let s1 = String::from("Hello");
    take_ownership(s1); // 所有权被移动到函数参数 `s`
 
    // println!("{}", s1); // 错误！s1 不再有效
}

在上面的例子中，当 s1 被传递到 take_ownership 函数时，它的所有权被移动到函数中的参数 s。因此，在函数调用之后，s1 无法再访问 s1 中的数据。

5. 借用（Borrowing）

借用是 Rust 通过引用来实现的。在借用的情况下，数据的所有权不会发生转移，引用者只是对数据的“借用者”。

Rust 的借用有两种形式：

• 不可变借用：允许多个引用同时访问数据，但无法修改数据。
• 可变借用：允许只有一个引用可以修改数据。

示例：不可变借用

fn main() {
    let s = String::from("Hello");
    let s_ref = &s; // 不可变借用
 
    println!("{}", s_ref); // 输出: Hello
    // s_ref 可以继续使用，但无法修改 s
}

示例：可变借用

fn main() {
    let mut s = String::from("Hello");
    let s_ref = &mut s; // 可变借用
 
    s_ref.push_str(", World!");
    println!("{}", s_ref); // 输出: Hello, World!
}

在可变借用的情况下，只有一个引用能够修改数据。如果尝试同时拥有多个可变引用或混合可变和不可变引用，Rust 会在编译时进行检查并报错，确保数据的一致性和安全性。

6. 移动与复制的区别

在 Rust 中，实现 Copy trait 的类型会自动复制数据，而不是移动所有权。对于简单的类型如 i32、f64、char 和其他原始类型，Rust 会在传递这些类型的变量时进行 复制。

示例：Copy 类型

fn main() {
    let x = 5;
    let y = x; // 对于 `Copy` 类型，x 会被复制，而不是移动
 
    println!("{}", x); // 输出: 5
    println!("{}", y); // 输出: 5
}

i32 实现了 Copy trait，因此 x 在赋值给 y 时会被复制，而不是移动。

7. 结构体与移动语义

Rust 中的结构体如果包含非 Copy 类型字段（如 String、Vec），那么结构体的所有权也会被移动。

示例：结构体移动

struct Person {
    name: String,
}
 
fn take_ownership(person: Person) {
    println!("{}", person.name);
}
 
fn main() {
    let p = Person {
        name: String::from("Alice"),
    };
 
    take_ownership(p); // 所有权被移动到函数
 
    // println!("{}", p.name); // 错误！p 不再有效
}

在这个例子中，p 的所有权被移动到 take_ownership 函数中，因此在函数调用之后，p 无法再访问。

8. 总结：Rust 的移动语义

Rust 的移动语义通过所有权系统来确保内存安全和无数据竞争。数据的所有权在默认情况下会被移动，而不是复制，除非该类型实现了 Copy trait。借用则允许你引用数据而不转移所有权，从而使得你能够有效地管理资源的使用而不需要复制或移动数据。

• 移动（Move）：会将数据的所有权从一个变量转移到另一个变量，源变量不再有效。
• 克隆（Clone）：显式复制数据，分配新的内存空间，源变量和目标变量都有效。
• 借用（Borrowing）：通过引用传递数据，不涉及所有权的转移。