Rust教程<二>

所有权

先看一段代码

    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:0x7ff7bbc7a30c
  v address in fn:0x7ff7bbc798e4
  v value:32
  v address after fn:0x7ff7bbc7a30c
  32

  可以看到，在函数外和函数内，地址不同

  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 sky
  Beautiful 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)