Ownership

Rust 中的每一个值都有一个被称为其 所有者（owner）的变量。

值在任一时刻有且只有一个所有者。

当所有者（变量）离开作用域，这个值将被丢弃。

变量做用域

{
    //当 s 进入作用域 时，它就是有效的。
    // 这一直持续到它 离开作用域 为止。
    let s = "apple";
    println!("s = {}", s);

    let s1 = String::from("Tom");
    log(s1);
    // error value borrowed here after move 被借用无法输出
    // println!("s1 = {}", s1);
} //离开作用域自动释放
    // println!("s = {}", s);

fn log(name: String) {
    println!("{}", name);
}

---

内存与分配

mut string 由于可变， 分配在堆上：
必须在运行时向操作系统请求内存。

需要一个当我们处理完 String 时将内存返回给操作系统的方法。

let mut s = String::from("hello");
s.push_str(", world!");
println!("s = {}", s);

---

变量与数据交互的方式（一）：移动

let x = 5; // 给 x 赋值 5，由于 5 的大小是已知的， 被分配到栈上
let y = x;
println!("x = {}, y = {}", x, y);

// string 版本
let s1 = String::from("hello");
let s2 = s1;
println!("s2 = {}", s2);
// println!("s1 = {}, s2 = {}", s1, s2);

String 由三部分组成，如图左侧所示：一个指向存放字符串内容内存的指针，一个长度，和一个容量。这一组数据存储在栈上。右侧则是堆上存放内容的内存部分。

Xnip2021-05-26_15-57-45.jpg

当我们将 s1 赋值给 s2，String 的数据被复制了，这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制指针指向的堆上数据。

Xnip2021-05-26_15-58-43.jpg

操作 s2 = s1 在堆上数据比较大的时候会对运行时性能造成非常大的影响。

Xnip2021-05-26_16-01-07.jpg

如果你在其他语言中听说过术语 浅拷贝（shallow copy）和 深拷贝（deep copy），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效了，这个操作被称为 移动（move），而不是浅拷贝。上面的例子可以解读为 s1 被 移动 到了 s2 中。那么具体发生了什么，如图 4-4 所示。

【借用】

Xnip2021-05-26_16-01-47.jpg

另外，这里还隐含了一个设计选择：Rust 永远也不会自动创建数据的 “深拷贝”。因此，任何 自动 的复制可以被认为对运行时性能影响较小。

克隆 确实需要的拷贝的场景使用

let s1 = String::from("hello");
let s2 = s1.clone(); //clone 堆上的数据被复制了
println!("s1 = {}, s2 = {}", s1, s2);

为什么整形不需要clone?

let x = 5;
let y = x;
println!("x = {}, y = {}", x, y);

原因： 整型这样的在编译时已知大小的类型被整个存储在栈上，所以拷贝其实际的值是快速的。
Rust 有一个叫做 Copy trait 的特殊注解，可以用在类似整型这样的存储在栈上的类型上。如果一个类型拥有 Copy trait，一个旧的变量在将其赋值给其他变量后仍然可用。Rust 不允许自身或其任何部分实现了 Drop trait 的类型使用 Copy trait。如果我们对其值离开作用域时需要特殊处理的类型使用 Copy 注解，将会出现一个编译时错误。要学习如何为你的类型增加 Copy 注解，请阅读附录 C 中的 “可派生的 trait”。

那么什么类型是 Copy 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则，任何简单标量值的组合可以是 Copy 的，不需要分配内存或某种形式资源的类型是 Copy 的。如下是一些 Copy 的类型：

所有整数类型，比如 u32。

布尔类型，bool，它的值是 true 和 false。

所有浮点数类型，比如 f64。

字符类型，char。

元组，当且仅当其包含的类型也都是 Copy 的时候。比如，(i32, i32) 是 Copy 的，但 (i32, String) 就不是。

所有权和函数

将值传递给函数在语义上与给变量赋值相似。向函数传递值可能会移动或者复制，就像赋值语句一样

let s = String::from("hello"); // s 进入作用域
takes_ownership(s); // s 的值移动到函数里 【移动】
                    // ... 所以这里不再有效
let x = 5; // x 进入作用域
makes_copy(x); // 但 i32 是 copy 的 【copy】
                // ...所以能继续使用

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
}

返回值和作用域

返回值也能转移所有权

let s1 = gives_ownership(); // gives_ownership 将返回值移给 s1
let s2 = String::from("hello"); // s2进入作用域
let s3 = take_and_gives_back(s2);
println!("s1= {}", s1);
// println!("s2 = {}", s2);
println!("s3 = {}", s3);
// s2被移动到  take_and_gives_back ， take_and_gives_back 返回值给s3

fn take_and_gives_back(str: String) -> String {
    str
}

fn gives_ownership() -> String {
    let a = String::from("hello");
    a
}

转移返回值的所有权

{
let s1 = String::from("hello");
let (s2, len) = calculate_length(s1);
println!("{} length is {}", s2, len);
}
// s3 移出作用域并被丢弃，s2 移出作用域并但被移走

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)
}