Rust所有权探索

　　变量在函数调用过程中的传递fn main() {     let data = vec![5, 7, 3, 1];     let v = 7;      match find_pos(data, v) {         Some(pos) => println!(＂Found {} at {}＂, v, pos),         None => println!(＂{} Not found＂, v),     } }  fn find_pos(data: Vec, v: u32) -> Option {     for (pos, item) in data.iter().enumerate() {         if *item == v {             return Some(pos);         }     }      None }
　　在上面的示例代码中，main()函数定义了一个动态数组data和一个值v，然后将其传递给函数find_pos，在data中查找v是否存在，如果存在则返回v在data中的下标，如果不存在则返回None。
　　data 作为动态数组，因为大小在编译期无法确定，所以放在堆上，并且在栈上有一个包含了长度和容量的胖指针指向堆上的内存。
　　在调用find_pos函数时，main()函数中的局部变量data和v 作为参数传递给了find_pos()，因此，它们会被放在 find_pos()调用栈中的参数区：
　　参数引用
　　像Java等大多数编程语言的做饭，现在堆上的内存就有了两个引用，并且每次把data作为参数传递一次，堆上的内存就会多一次引用。
　　那么造成的问题就是，无法得知这些引用到底能做什么操作，堆上内存什么时候能够释放，也无法确认。如果有多个调用栈引用堆上的内存时，给内存管理带来很大挑战。同时，引用是可以隐式产生的，随意性太大，例如Java中随处可见的按引用传参，它们可读可写，有很大的权限。
　　对于这种堆内存多次引用的问题，传统语言有如下解决方案：C/C++要求开发者手动处理Java等语言使用追踪式GCObjective-C/Swift使用自动引用计数（ARC）
　　以上方案，都各有利弊，都是从管理引用的角度来考虑的。
　　但是，此问题本质上是因为堆上的内存会被随意引用。所有权和Move语义
　　Rust对于值的使用，给出了以下规则：一个值只能被一个变量所拥有，这个变量称为所有者。一个值同一时刻只能有一个所有者。也就是说，不能有两个变量拥有相同的值。所以在变量赋值、参数传递，函数返回等行为，旧的所有者会把值的所有权转移给（Move）新的所有者，保证单一所有者约束。当所有者离开作用域，其拥有的值被丢弃，内存得到释放。一旦所有权转移，之前的变量就不能访问。
　　在这三个所有权规则的约束下，上面示例的引用问题可以这样解决：
　　所有权和move
　　原先main()函数中的data,被移动到find_pos()后，就失效了，Rust编译器会保证main()函数随后的代码无法访问这个变量，就确保了堆上的内存依旧只有唯一的引用。解决了堆上数据的多重引用。
　　main()函数中在把data传递给find_pos()后，还想让main()函数能够访问的化，可以调用clone()方法，把data复制一份出来。
　　但是这种手动复制，会让代码变得复杂，一些只存储在栈上的简单类型数据，如果要避免所有权转移之后不能访问的情况，只能频繁的手动clone复制。
　　Rust给出了两种方案：如果不希望值的所有权被转移，可以让数据结构实现Copy trait,这样在赋值或传参的时候，值会自动按位拷贝（浅拷贝）。Rust在设计的时候，已经保证了无法为一个在堆上分配内存的结构实现Copy。例如String等结构时不能实现Copy的。在这种情况下，如果不希望值的所有权被转移，又无法使用Copy语义，那么可以使用＂借用＂数据。Copy语义和Copy trait
　　符合Copy语义的类型，在赋值或传参时，值会自动按位拷贝。
　　如果数据类型没有实现Copy trait,在赋值或者函数调用的时候无法Copy，那么就按默认的Move语义。
　　也就是说，要移动一个值，如果值的类型实现了Copy trait,就会自动使用Copy语义进行拷贝，否则使用Move语义进行移动。
　　但是Copy trait也有一定的限制，Copy trait和Drop trait 不能共存。一旦你实现了Copy trait,就无法实现Drop trait。反之亦然。实现了Copy trait 的数据结构fn is_copy() {}  fn types_impl_copy_trait() {     is_copy::();     is_copy::();      // 所有的整数类型都是 copy     is_copy::();     is_copy::();     is_copy::();     is_copy::();     is_copy::();     is_copy::();     is_copy::();     is_copy::();     is_copy::();      is_copy::();     is_copy::();      // 函数指针是copy     is_copy::();      // 裸指针是 copy     is_copy::<*const String>();     is_copy::<*mut String>();      // 不可变引用是 copy     is_copy::<&String>();     is_copy::<&[Vec]>();      //对于数组/元组，如果其内部类型是 copy，那么它们就是 copy     is_copy::<[u8; 4]>();     is_copy::<(&str, &str)>(); } fn types_not_impl_copy_trait() {     // DST 类型不是 copy     // is_copy::();     // is_copy::<[u8]>();      // 有堆内存的类型不是 copy     //is_copy::>();     //is_copy::();      //可变引用不是 copy     //is_copy::<&mut String>();      // 对于数组/元组，如果其内部类型不是 copy，那么它们也不是copy     //is_copy::<[Vec;4]>;     //is_copy::<(String,u23)>(); }原生类型（函数、不可变引用、裸指针）实现了Copy。数组和元组，如果其内部的数据结构实现了Copy，那么它们也实现了Copy。可变引用没有实现Copy。非固定大小的数据结构，没有实现Copy。Borrow语义
　　Borrow语义通过引用语法（&或者&mut）来实现。
　　在Rust中，＂借用＂和＂引用＂是一个概念。所有的引用都只是借用了＂临时使用权＂，它并不破坏值的单一所有权约束。
　　在默认的情况下，Rust的借用都是只读的。只读借用
　　本质上，引用是一个受控的指针，指向某个特定的类型。
　　其他传统语言，函数传参有两种方式：传值（pass-by-value）和 传引用（pass-by-reference）。
　　比如在Java，给函数传一个整数，这是传值，与Rust中的Copy语义一致。
　　给函数传一个对象，或者是任何堆上的数据结构，Java会自动隐式地传引用。
　　但是Java的引用是对象的别名，这也导致随着程序的运行，同一块内存的引用到处都是，不得不依赖GC进行内存回收。
　　Rust中没有传引用的概念，Rust所有的参数传递都是传值，不管是Copy还是Move。
　　所以，在Rust中，必须显式地把某个数据的引用，传给另一个函数。
　　Rust的引用实现了Copy trait,所以按照Copy语义，此引用会被复制一份交给要调用的函数。
　　对这个函数来说，它并不拥有数据本身，数据只是临时借给它使用。所有权还在原来的拥有者那里。
　　在Rust里，引用是一等公民，和其他数据类型地位相等。fn main() {     let data = vec![1, 2, 3, 4]; // data 的生命周期比sum()中对data的引用要长     let data1 = &data; // 借用不能超过值的生存期                        // 值的地址是什么？引用的地址又是什么？     println!(         ＂address of value: {:p}({:p}),address of data: {:p},data1: {:p}＂, //0x8aa19bf8a8(0x8aa19bf8a8),address of data: 0x8aa19bf948,data1: 0x8aa19bf8c0         &data,                                                            //0x8aa19bf8a8         data1,                                                            //0x8aa19bf8a8         &&data,                                                           //0x8aa19bf948         &data1                                                            //0x8aa19bf8c0     );      println!(＂sum of data1: {}＂, sum(&data)); // sum 函数处在 main() 函数下一层调用栈中，它结束后main函数还会继续执行      // 堆上数据的地址是什么     println!(         ＂address of items:[{:p},{:p},{:p},{:p}]＂, //address of items:[0x1cc59705670,0x1cc59705674,0x1cc59705678,0x1cc5970567c]         &data[0],                                 //0x1cc59705670         &data[1],                                 //0x1cc59705674         &data[2],                                 //0x1cc59705678         &data[3],                                 //0x1cc5970567c     ); }  fn sum(data: &[u32]) -> u32 {     //值的地址会改变吗，引用的地址会改变吗     println!(         ＂address of value: {:p},addr of ref: {:p}＂, //address of value: 0x1cc59705670,addr of ref: 0x8aa19bf6d0         data,                                       //0x1cc59705670         &data                                       //0x8aa19bf6d0     );     data.iter().sum() }  // 只读引用 实现了 Copy trait,也就意味着引用的赋值、传参都会产生新的浅拷贝 // 虽然data 有很多只读引用指向它，但是堆上的数据依旧只有data 一个所有者：值的任意多个引用并不影响所有权的唯一性。
　　借用
　　data1、&data和传到sum()里的data1＂ 都是指向data本身，这个值的地址是固定的。但是它们引用的地址都是不同的。这是因为 只读引用实现了Copy trait,也就是意味着引用的赋值、传参都会产生新的浅拷贝。堆上数据依旧只有data一个所有者。值的任意多个引用并不影响所有权的唯一性。借用的生命周期
　　借用（引用）不能超过（overlive）值的生存期。
　　堆变量的生命周期不具备任意长短的灵活性，因为堆上内存的生死存亡，跟栈上的所有者牢牢绑定。而栈上内存的生命周期，又跟栈的生命周期相关，所以，我们只需要关心调用栈的生命周期。可变借用/引用
　　为了保证内存安全，Rust对可变引用的使用做了严格的约束：在一个作用域内，仅允许一个活跃（真正被用来修改数据的）的可变引用。在一个作用域内，活跃的可变引用（写）和只读引用（读）是互斥的，不能同时存在。就像并发下数据的读写互斥。一个值可以有多个只读引用。引用的生命周期不能超出值的生命周期。