关于rust:rust学习所属权基本概念

所属权是 rust 最有特色的性能，该性能使得 rust 无需垃圾回收机制即可保障内存平安。那么所属权是啥以及有啥用呢？

首先，rust 中的所属权含意：
1、所属权规定：

（1）、Rust 中的每个值都有一个变量，称为其所有者。（2）、一次只能是一个所有者。（3）、当所有者超出作用范畴时，该值将被删除。

2、什么是作用范畴：作用范畴相似于：{let s = "hello";}

3、内存和调配：
在 rust 中，当领有内存的变量超出范围后，内存将主动开释，例如：

fn main() {
    {
        // 从当初开始，s 是无效的
        let s = String::from("hello"); 

        // 用 s 做一些操作
    }
    // 此作用域现已完结，并且 s 不再无效
}

**: 当变量超出范围时，Rust 为咱们调用一个非凡函数。此函数称为 drop，它是 String 的创建者 (以上例进行阐明) 能够在其中搁置代码以返回内存的中央。Rust 会主动在右大括号敞开除调用。

* 变量和数据交互的形式：挪动
多个变量能够在 Rust 中以不同的形式与同一数据交互。例如：

fn main() {
    let x = 5;
    let y = x;
}
//“将值 5 绑定到 x；而后在 x 中复制值并将其绑定到 y。”当初，咱们有两个变量 x 和 y，它们都等于 5。这种状况是确确实实存在的，因为整数是具备已知固定大小的简略值，并且这 5 个值被压入堆栈。

再来看看 String 类型的:

fn main() {let s1 = String::from("hello");
    let s2 = s1;
}
// 这看起来与先前的代码十分类似，因而咱们能够假如它的工作形式是雷同的：也就是说，第二行将在 s1 中复制该值并将其绑定到 s2。但这不是齐全会产生的事件。// 字符串由三局部组成：指向内存的指针，用于保留字符串的内容，长度和容量。这组数据存储在堆栈中。// 长度是 String 以后正在应用的内存量（以字节为单位）。容量是 String 从分配器接管的内存总量（以字节为单位）。长度和容量之间的差别很重要，但在这种状况下并不重要，因而，临时能够疏忽容量。// 当咱们将 s1 调配给 s2 时，将复制 String 数据，这意味着咱们将复制堆栈上的指针，长度和容量。咱们不将数据复制到指针援用的堆上。// 如果 Rust 代替复制了堆数据，那么如果堆上的数据很大，则运行时性能 s2 = s1 可能会十分低廉。// 当变量超出范围时，Rust 主动调用 drop 函数并革除该变量的堆内存。然而如果存在两个指向雷同地位的数据指针。这是一个问题：当 s2 和 s1 超出范围时，它们都将尝试开释雷同的内存。这被称为双重开释谬误，是内存平安谬误之一。两次开释内存可能导致内存损坏，从而可能导致安全漏洞。

确保数据安全：
为了确保内存平安，Rust 中呈现了这种状况的详细信息。Rust 不会尝试复制调配的内存，而是认为 s1 不再无效，因而，当 s1 超出范围时，Rust 不须要开释任何内容。查看创立 s2 之后尝试应用 s1 会产生什么状况；它不起作用：

fn main() {let s1 = String::from("hello");
    let s2 = s1;

    println!("{}, world!", s1);
}
//let s1 = String::from("hello"); 
               | -- `move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait`
 //`let s2 = s1;`
          `-- value moved here`
 //` println!("{}, world!", s1);`
                           `^^ value borrowed here after move`

在 js 中有浅复制与深复制的概念。然而因为 Rust 也使第一个变量有效，而不是被称为浅表正本，因而被称为挪动。在此示例中，咱们说 s1 已移入 s2。这也就是 rust 中挪动的概念

这就阐明了下面呈现的问题！只有 s2 无效，当它超出范围时，仅凭它就能够开释内存，咱们就功败垂成了。

此外，这暗示了一种设计抉择：Rust 永远不会主动创立数据的“深层”正本。因而，就运行时性能而言，任何主动复制都能够被认为是便宜的。

变量与数据交互的形式：克隆
如果咱们的确想深刻复制 String 的堆数据，而不仅仅是堆栈数据，则能够应用一种称为 clone 的通用办法，例如：

fn main() {let s1 = String::from("hello");
    let s2 = s1.clone();

    println!("s1 = {}, s2 = {}", s1, s2);
}
// 此时 s1 仍旧是起作用的，它的值只不过是被复制了，然而其所指向的存储空间并没有被复制。

仅堆栈数据：复制
先来看一个例子：

fn main() {
    let x = 5;
    let y = x;

    println!("x = {}, y = {}", x, y);
}
// 这段代码所揭示的含意是：// 诸如在编译时具备已知大小的整数之类的类型齐全存储在堆栈中，因而能够疾速制作理论值的正本。这意味着在创立变量 y 之后咱们没有理由要阻止 x 失效。换句话说，这里的深层复制和浅层复制没有什么区别，因而调用克隆与通常的浅层复制没有什么不同，咱们能够省去克隆操作。

Rust 具备一个非凡的正文，称为复制特色，咱们能够将其搁置在存储在堆栈中的整数之类的类型上。如果类型具备“复制”特色，则调配后依然能够应用较旧的变量。如果该类型或其任何局部实现了 Drop 个性，Rust 将不容许咱们应用 Copy 个性对该类型进行正文。如果在值超出范围时该类型须要非凡解决，并向该类型增加 Copy 批注，则会呈现编译时谬误。

那么复制是什么类型？作为个别规定，任何一组简略的标量值都能够是 Copy，而不须要调配或某种模式的资源的任何内容都能够是 Copy。以下是一些“复制”类型：

* 所有整数类型，例如 u32。* 布尔型布尔值，值为 true 和 false。* 所有浮点类型，例如 f64。* 字符类型，`char`。* 元组（如果它们仅蕴含也是能够 Copy 的类型）。例如，`(i32, i32)` 是 Copy，然而 `(i32，String)` 不是。

所有权和函数:
用于将值传递给函数的语义相似于用于将值调配给变量的语义。就像赋值一样，将变量传递给函数将挪动或复制。上面是一个带有一些正文的示例，该正文显示了变量进入和超出作用域的地位：

fn main() {let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移入函数...
                                    // ... 因而在这里及其之后不再无效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 将移入函数，// 然而 i32 是 Copy，所以还能够在这之后应用 x

} // 在此，x 超出作用域，而后是 s。然而因为 s 的值被挪动了，所以没有什么特地的事件产生。fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 在这里，some_string 超出作用域并调用 `drop`。备份内存已开释。fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 在这里, some_integer 超出作用域。没什么特地的事件产生。

返回值和作用域

返回值也能够转移所有权，例如：

fn main() {let s1 = gives_ownership();         // gives_ownership 将其返回值挪动至 s1.

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移入 takes_and_gives_back，它的返回值也移入 s3
                                       
} // 在此，s3 超出作用域并被开释内存。s2 超出作用域但被挪动了，所以什么也没产生。s1 超出作用域并被开释内存。fn gives_ownership() -> String {             // gets_ownership 会将其返回值移至调用它的函数中

    let some_string = String::from("hello"); // some_string 进入作用域

    some_string                              // some_string 被返回并且移至调用 gives_ownership 的函数中
}

// take_and_gives_back 将获取一个 String 并返回一个
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域
    a_string  // a_string 被返回并且移至调用 takes_and_gives_back 的函数中
}

变量的所有权每次都遵循雷同的模式：将值调配给另一个变量将其挪动。当蕴含堆上数据的变量超出作用域时，将删除该值，除非该数据已被移交给另一个变量领有。

领有所有权而后返回所有性能的所有权有点乏味。如果咱们想让函数应用值而不是所有权怎么办？令人非常懊恼的是，除了咱们可能还想返回的函数主体所产生的任何数据之外，如果咱们想再次应用它们，还须要将其传递回去。

能够应用元组返回多个值，例如：

fn main() {let s1 = String::from("hello");

    let (s2, len) = calculate_length(s1);

    println!("The length of'{}'is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {let length = s.len(); // len() 返回一个字符串的长度

    (s, length)
}