Rust学习笔记004：Rust的所有权机制
内存相关的基础知识
不同语言的内存管理系统
栈和堆
堆和栈的使用
引出所有权方案
String类型
Rust 的所有权机制
- Rust 的所有权机制是一种内存管理系统，它允许在编译时通过所有权、借用和生命周期来确保内存安全，同时避免了垃圾回收的运行时开销。这些概念共同构成了 Rust 强大的所有权系统，通过编译时的检查来防止一类内存错误，如空悬指针和双重释放等。这种系统使得 Rust 具有内存安全性、线程安全性和零成本抽象等特性。
1. 所有权规则：
- 每个值都有一个所有者： 在任意时刻，一个值只能有一个所有者。
- 所有者离开作用域时，值会被销毁： 当拥有某个值的变量离开其作用域时，Rust 会自动调用该值的
Droptrait 中的drop方法来释放其占用的资源。
2. 移动（Move）：
- 当将一个值赋值给另一个变量时，所有权会从一个变量移动到另一个变量。这会导致原来的变量无法再使用该值。
let s1 = String::from("Hello");// 可以使用 from 函数从字符串字面值创建出 String 类型
let s2 = s1; // 所有权移动到变量 y
// println!("{}", x); // 这里编译器会报错，因为 x 不再拥有值的所有权
- 隐含的一个设计原则: Rust 不会自动创建数据的深拷贝,就运行时性能而言，任何自动赋值的操作都是廉价的
相关：C++中，移动构造函数
-
在C++中，移动构造函数（Move Constructor）是一种特殊的构造函数，用于在对象的所有权被转移（移动）时创建新对象。移动构造函数通常用于提高性能，特别是在涉及资源管理的情况下，比如使用动态内存分配的对象。
-
移动构造函数是通过右值引用（Rvalue Reference）来实现的。在C++11及以后的标准中，可以通过定义移动构造函数来支持右值引用。移动构造函数的目标是在没有不必要的资源复制的情况下，将资源从一个对象“移动”到另一个对象，以提高效率。
-
以下是一个简单的示例，演示了移动构造函数的用法：
#include 在上述例子中，MyString 类具有移动构造函数。在 main 函数中，通过 std::move 将 str1 的所有权移动给了 str2。移动构造函数被调用后，str1 的资源被移动到 str2，同时 str1 的数据成员被置为 nullptr。
注意：在移动构造函数中，我们通常将被移动对象的数据成员设置为安全状态，以避免资源重复释放。此外，通常需要在移动构造函数中使用 noexcept 来指定该函数不会抛出异常，以便在一些情况下提供更好的性能。
移动构造函数对于提高性能和避免不必要的资源复制是非常有用的，特别是在处理大型数据结构、动态分配内存等情况下。
3. 克隆（Clone，Copy）：感觉类似c++的深拷贝构造
如果需要拷贝堆上数据而不是移动所有权，可以使用 clone 方法。但这会增加内存开销。
let x = String::from("Hello");
let y = x.clone(); // 创建了一个新的 String 对象，所有权移动到变量 y
println!("x: {}, y: {}", x, y); // 这样是合法的，因为 x 仍然有效
4. 借用（Borrowing）：
通过借用，可以暂时获取对值的引用而不移动所有权。借用分为可变借用和不可变借用。
fn main() {
let s1 = String::from("Hello");
let len = calculate_length(&s1); // 通过引用借用 s1
println!("Length of '{}' is: {}", s1, len); // 这里依然可以使用 s1，因为只是借用了引用
// 可变借用
let mut s2 = String::from("Rust");
modify_string(&mut s2); // 通过可变引用借用 s2
println!("Modified string: {}", s2);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
fn modify_string(s: &mut String) {
s.push_str(" is awesome!");
}
5. 生命周期（Lifetime）：
生命周期是用于描述引用有效范围的标记。Rust 的生命周期系统确保引用在其所引用的值有效的情况下才能被使用。
fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
if s1.len() > s2.len() {
s1
} else {
s2
}
}
fn main() {
let s1 = String::from("Rust");
let s2 = String::from("C");
let result;
{
let s3 = String::from("Java");
result = longest(s1.as_str(), s3.as_str());
} // s3 的生命周期结束，result 引用的值仍然是有效的
println!("The longest string is: {}", result);
}
在上述例子中，longest 函数使用了生命周期参数 'a，它表示返回的引用的生命周期与输入参数的生命周期一致。
所有权与函数
在 Rust 中，所有权系统与函数的参数传递和返回密切相关，它确保在函数调用过程中对所有权的正确管理。
1. 所有权传递：
当你将一个值传递给函数时，它的所有权会被转移给函数。这意味着在函数中你可以使用该值，但在函数返回后，调用者将无法再使用它。
fn take_ownership(s: String) {
println!("Received: {}", s);
// s 的所有权在这里结束，s 的内存将被释放
}
fn main() {
let my_string = String::from("Hello");
take_ownership(my_string); // my_string 的所有权被传递给 take_ownership 函数
// println!("Value: {}", my_string); // 这里编译器会报错，因为 my_string 已经失去了所有权
}
2. 返回所有权：
函数也可以返回所有权，将所有权还给调用者。这可以通过在函数签名中指定返回类型为 -> 加上类型名。
fn return_ownership() -> String {
let s = String::from("Returned");
s // 所有权被返回给调用者
}
fn main() {
let result = return_ownership(); // 调用 return_ownership 后，result 拥有了返回的所有权
println!("Result: {}", result);
}
3. 引用传递：
-
在所有权用完后，再返回回来？
-
如果你想在函数中使用值但不获取其所有权，可以使用引用传递。引用允许你在不移动所有权的情况下访问值。
fn borrow_value(s: &String) {
println!("Borrowed: {}", s);
// s 是引用，所有权不会在这里转移
}
fn main() {
let my_string = String::from("Hello");
borrow_value(&my_string); // 传递了 my_string 的引用
println!("Value: {}", my_string); // 这是合法的，因为并未传递所有权
}
可变引用
字符串切片
