所有权

先看一段代码

    let s3 = "hello";    let s4 = s3;    println!("{}", s3);    let s1 = String::from("hello");    let s2 = s1;    //println!("{}", s1); //Error:^^ value borrowed here after move    let array1 = [0,1,2,3,4,5];    let ap = &array1;    println!("{}", ap[3])    println!("{:p},{:p}", &array1, ap);

打印s3的能够失常执行，打印s1的却报错。这是什么起因？
<1>s3的内容是栈里调配的, s3 = s4这是copy操作，相似复制了一个字符类型的变量s4.
如下类型的会是copy类型的。因为这些类型都是在栈里调配的，所以应用copy操作会很快

  • 所有整数类型
  • 布尔
  • 浮点
  • 字符（是字符，不是string！！）
  • 元组 （元组内的元素也都是copy类型的， (i32, i32), (i32, 'aa')是copy类型。（i32，String)的不是copy类型

<2>s1是String,不是字符类型。的内容是在堆里调配的，s2 = s1的操作是将s1指向内存"hello"的所有权转移给s2. 所以s1就被开释了

<3>借用操作符 &,这与C/C++相似，就是应用&获取内存地址。 ap = &array1理论就是获取array1的内存地址，付给ap.

所有权与函数

  • 函数参数所有权
    函数会有参数传入，此时所有权是否会产生变更？
    测试代码如下

    U32FnGetOwner

        let v:u32 = 32;    println!("v address before fn:{:p}", &v);    getU32Owner(v);    println!("v address after fn:{:p}", &v);    println!("{}", v)    fn getU32Owner(v:u32) {        println!("v address in fn:{:p}", &v);        println!("v value:{}", v);    }

    失常执行
    栈上调配的copy类型的变量，在函数内copy出新的变量。输入后果如下：

    v address before fn:0x7ff7bbc7a30cv address in fn:0x7ff7bbc798e4v value:32v address after fn:0x7ff7bbc7a30c32

    能够看到，在函数外和函数内，地址不同

    StringFnGetOwner

        let str1 = String::from("String owner");    getOwner(str1);    println!("{}", str1); //Error:^^^^ value borrowed here after move    fn getStringOwner(s:String) {        println!("Show s:{}",s);    }

    会提醒错误信息，无奈编译通过
    堆上调配的变量，当在函数内产生所有权变更，传入函数变量的所有权也会变更

    str1曾经产生所有权变更，无奈再应用

    这就引起了一个问题，传入参数所有权都产生了变更，函数后就无奈应用了。如果想持续应用传入参数该如何做？答案是通过援用的形式，对于援用，学过C/C++的应该都很分明了

        let mut str4 = String::from("Beautiful ");    let (str5, l ) = refStr(&mut str4);    println!("{}", str4);    println!("{}, len:{}", str5, l);    fn refStr(s: &mut String) -> (String, usize) {        s.push_str("sky");        (s.to_string(), s.len())    }

    输入后果如下

    Beautiful skyBeautiful sky, len:13

    通过援用，在函数内可能操作str4的内容（变量定义时以及函数参数定义处的 mut很重要，否则无奈在函数内变更内容），同时函数返回str4的所有权没有产生变更。

援用

对于援用学过C/C++的应该都比拟相熟，对于rust来说对于援用有以下几点须要留神

<1>可变援用只能有一个，不可变援用能够有多个。可变援用只能有一个的起因就是为了防止数据竞争，当有多个可变援用就会有数据竞争的可能。

    let mut ss = String::from("FFFF");    let rr1 = &mut ss;    let rr2 = &mut ss; //Error:cannot borrow `ss` as mutable more than once at a time    println!("{}, {}", rr1, rr2)

<2>不能即存在可变援用又存在不可变援用

    let mut ss = String::from("FFFF");    let rr1 = &ss;    let rr2 = &mut ss; //Error：cannot borrow `ss` as mutable because it is also borrowed as immutable    println!("{}, {}", rr1, rr2)