【Rust】所有权OwnerShip

什么是所有权

rust使用由编译器检查的一些规则构成的所有权系统来管理内存。且这不会影响程序的运行效率。

所有权规则

• rust中每一个每一个值都有一个owner。
• 在同一时刻，只能有一个owner。
• 当这个owner超过范围，则该值会被丢弃。

String类型

为什么需要String

• 已经有了字符串字面量了，为啥还需要String类型呢？字面量是硬编码在程序里面的，如果我们在编码的时候并不知道字符串是什么，那我们就不能用字符串字面量了。比如字符串来自用户输入，这时候就需要用String类型来存储了。
• 更多字符串基本用法参考【Rust】字符串String类型学习

内存及分配

简单的情况

在String::from的地方，会申请内存；在}之前rust会调用drop方法释放s的内存。

{
    let s = String::from("hello"); // s is valid from this point forward
    // do stuff with s
}                                  // this scope is now over, and s is no
                                   // longer valid

字符串赋值的情况

• 当将s1赋值给s2的时候，s1就会被废弃，字符串的堆内存就交给s2去管理了。如果赋值后，再使用s1就会出现编译错误。
• rust语言不会自动进行任何的拷贝，所以可以认为自动拷贝都是高性能的。
• let s2 = s1这个过程中相当于发生了move的动作，将字符串的所有权从s1移交给s2。

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

字符串克隆的情况

• 既然直接赋值，会导致所有权转移。那么如何做到赋值时进行拷贝呢？这就需要用到clone方法。

let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {s1}, s2 = {s2}");

• 因为clone方法会拷贝堆上的内存，所以其执行的代价是比较高的。

只在栈上的数据：拷贝

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

• 我们发现如果直接把整数类型x赋值给y，并且在使用x。编译并没有报错。
• 这是因为整形是固定大小的类型，存放在栈上。拷贝的代价很低，其深拷贝和浅拷贝并没有特别大的区别。所以我们可以直接拷贝，而不需要move。

所有权和函数

• 按照我们所有权的规则，如下代码就很容易理解。

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
                                    // ... and so is no longer valid here

    let x = 5;                      // x comes into scope

    makes_copy(x);                  // x would move into the function,
                                    // but i32 is Copy, so it's okay to still
                                    // use x afterward

} // Here, x goes out of scope, then s. But because s's value was moved, nothing
  // special happens.

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{some_string}");
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{some_integer}");
} // Here, some_integer goes out of scope. Nothing special happens.

返回值和有效范围

fn main() {
    let s1 = gives_ownership();         // gives_ownership moves its return
                                        // value into s1

    let s2 = String::from("hello");     // s2 comes into scope

    let s3 = takes_and_gives_back(s2);  // s2 is moved into
                                        // takes_and_gives_back, which also
                                        // moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing
  // happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {             // gives_ownership will move its
                                             // return value into the function
                                             // that calls it

    let some_string = String::from("yours"); // some_string comes into scope

    some_string                              // some_string is returned and
                                             // moves out to the calling
                                             // function
}

// This function takes a String and returns one
fn takes_and_gives_back(a_string: String) -> String { // a_string comes into
                                                      // scope

    a_string  // a_string is returned and moves out to the calling function
}

原文地址：https://blog.csdn.net/C2681595858/article/details/140622049

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！