详解Rust中的所有权机制

pub struct String {
    vec: Vec<u8>,
}

let s = String::from("hello");

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

fn main() {
    let mut s = String::from("hello");
    s = s + ",";	//这里是双引号
    s = s + " world!";
    println!("s = {}", s);
}

 {
        let s = String::from("hello"); // 从此处起，s 是有效的

        // 使用 s
    }                                  // 此作用域已结束，
                                       // s 不再有效

let x = 5;
let y = x;

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

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

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

println!("s1 = {}, s2 = {}", s1, s2);

fn main() {
    let i = 9;
    fun(i);
    //程序走到这里时i依然有效
    let s = String::from("hello");
    fun2(s);
    //程序走到这里时s不再有效
}
//在参数传进来的时候实际上是发生了 形参 = 实参 的事情
fn fun(x: i32) {	
    ...
}
fn fun2(y: String) {
    ...
}

let i = 9;
let x = i;	//这里是发生了Copy，不会发生所有权的转移
let s = String::from("hello");
let y = s;	//这里因为String类型是在堆上申请内存，所以发生了所有权的转移

fn main() {
    let mut s = String::from("hello");
    s = show_string(s);
}
fn show_string(x: String) -> String{
    println!("{}", x);
    x
}

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

    let len = calculate_length(&s1);

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

fn calculate_length(s: &String) -> usize {
    s.len()
}

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

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s;

println!("{}, {}", r1, r2);

$ carGo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 | 
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

For more infORMation about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error

 let mut s = String::from("hello");
    {
        let r1 = &mut s;
    } // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用

    let r2 = &mut s;

fn main() {
    let mut s = String::from("hello");
    test(&mut s);

    let r2 = &mut s;
    println!("r2 = {}", r2);
}

fn test(x: &mut String) {
    x.push_str("world");
}

r2 = helloworld

 let mut s = String::from("hello");

    let r1 = &s; // 没问题
    let r2 = &s; // 没问题
    let r3 = &mut s; // 大问题

    println!("{}, {}, and {}", r1, r2, r3);

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &s; // no problem
  |              -- immutable borrow occurs here
5 |     let r2 = &s; // no problem
6 |     let r3 = &mut s; // BIG PROBLEM
  |              ^^^^^^ mutable borrow occurs here
7 | 
8 |     println!("{}, {}, and {}", r1, r2, r3);
  |                                -- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error

fn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s; //有问题，因为下面还在使用r1,r2
    println!("{},{}", r1, r2); 
    println!("{}", r3);
}

fn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    println!("{},{}", r1, r2);
    // 此位置之后 r1 和 r2 不再使用
    let r3 = &mut s;	//没问题，因为后面不再使用r1,r2
    println!("{}", r3);
}

fn main() {
    let reference_to_nothing = dangle();	//访问到了已经被释放内存的地址，野指针
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s	//返回s所指向的地址
}	//s离开其作用域，则s所指向的内存被释放

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
  |
5 | fn dangle() -> &'static String {
  |                ~~~~~~~~

For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

    let s = String::from("hello world");
	//0..5 左闭右开 [0,5)	左闭右闭 0..=5 [0,5]
    let hello = &s[0..5];	//hello
    let world = &s[6..11];	//world

let s = String::from("hello");
let slice = &s[0..2];	//he
let slice = &s[..2];	//he
let len = s.len();

let slice = &s[3..len];	//lo
let slice = &s[3..];	//lo

let s = "Hello, world!";

let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];	//[2, 3]

assert_eq!(slice, &[2, 3]);