一起学Rust-理解所有权
一起学Rust-理解所有权
微信关注公众号 [可回收BUG]
上期学习：一起学Rust-结构体
上期学习回顾：上期学习的结构体的结尾留了一个小的问题，这一期的开始来学习一下。
原问题是这样的： &str 类型通过mem::size_of::<&str>()进行打印内存，始终为16字节。（这里不严谨了，应该是在64位机器上是16字节）
为啥呢？其实答案就藏在rustdoc中，位于 std/primitive.str.html#representation.
原文：A &str is made up of two components: a pointer to some bytes, and a length. You can look at these with the as_ptr and len methods
use std::slice;
use std::str;
let story = "Once upon a time...";
let ptr = story.as_ptr();
let len = story.len();
// story has nineteen bytes
assert_eq!(19, len);
// We can re-build a str out of ptr and len. This is all unsafe because
// we are responsible for making sure the two components are valid:
let s = unsafe {
// First, we build a &[u8]...
let slice = slice::from_raw_parts(ptr, len);
// ... and then convert that slice into a string slice
str::from_utf8(slice)
};
assert_eq!(s, Ok(story));这个原文中的例子就是证明 &str 组成的两部分，下面进行简单解析：
ptr通过as_ptr方法获取，是 *const u8 类型，占用8字节，len变量是usize类型在64位机器中是8字节。slice变量从from_raw_parts中获取，主要返回的是Repr结构中的rust成员，T指代类型是u8：
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T] {
debug_assert!(data as usize % mem::align_of::<T>() == 0, "attempt to create unaligned slice");
debug_assert!(mem::size_of::<T>().saturating_mul(len) <= isize::MAX as usize,
"attempt to create slice covering half the address space");
Repr { raw: FatPtr { data, len } }.rust
}下面是union Repr结构，其中rust、rust_mut、raw共用同一块内存空间。
#[repr(C)]
union Repr<'a, T: 'a> {
rust: &'a [T],
rust_mut: &'a mut [T],
raw: FatPtr<T>,
}下面是FatPtr结构
#[repr(C)]
struct FatPtr<T> {
data: *const T,
len: usize,
}实际的FatPtr则是一个8 + 8 = 16字节的结构体，那么Repr的union就是16字节。同时由于ptr变量是* const u8类型，所以T为u8，因此from_raw_parts方法返回类型为* const [u8]，大小为16字节。而接下来的方法内仅做来utf8的检查以及类型转换的工作，大小未发生变化，所以在64位的机器上 &str 类型是16字节。
本期正题
所有权的概念，是在Rust初学时需要面对的一个难题，总是在编写代码的过程中出现各种的问题
error[E0382]: use of moved value: `s`
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable所有权规则：
- Each value in Rust has a variable that’s called its owner.
- There can only be one owner at a time.
- When the owner goes out of scope, the value will be dropped.
所有权规则解释：
- 在Rust中，每一个值都会对应一个叫做所有者的变量。
- 一次运行中的值只能存在一个所有者
- 当所有者离开作用域，它的值会被释放掉。
fn main() {
let arr = vec![1,2];
if arr.len() > 0 {
let arr1 = arr;
println!("{:?}", arr1); //打印 [1,2]
}
println!("{:?}", arr); //编译报错
println!("{:?}", arr1); //编译报错
}在上面的例子中，可知以下几条信息
arr是vec![1,2]的所有者。
main函数的代码块是一个作用域，if 的语句块也是一个单独的作用域。
在if 代码块中 vec![1,2]的所有者变成了arr1。
所以如果注释掉底部的两个错误语句，第5行是可以打印arr1的值。而下面打印arr失败的原因就是arr变量已经从内存释放，无法访问。而打印arr1出现错误的原因就是arr1是属于if代码块的，当离开if 的作用域后，内存释放。
移动和复制
当创建一个不定长的值的情况下会在堆内存中申请空间，此类值的变量在重新赋值给另外一个变量时会发生所有权的移动 move ，移动的结果就是原有的变量释放，新变量指向值的堆内存地址，成为此值的唯一所有者，将来在离开作用域后释放此变量以及其值的内存空间。（由于Rust内无垃圾回收机制，如果不是移动所有权，那么会有两个或多个变量指向值的堆内存，则在离开作用域释放内存时可能会出现多次释放，可能存在内存安全的问题，所以为了防止出现内存安全的问题，使用了唯一对应的所有者，释放内存时也仅一次性完成）
let string = String::new();
let new_string = string; //会发生所有权转移，string变量释放。对于原则1有一点是需要关注的，看以下例子：
let num1 = 5; //以下均可以正常编译运行。
// let num1 = "abc";
// let num1 = (2,3);
// let num1 = [23,54];
// let num1 = ("sdk", 3);
// let num1 = true;
// let num2 = num1;
println!("{},{}", num1, num2); //正常打印可以正常运行的原因是因为num2赋值时发生了值的复制，观察可发现num1变量的值均是标量值，固定大小，是存储在栈内存中的，所以复制相对容易很多，所以Rust提供了复制的功能，在离开作用域时分别释放各自的内存，不会出现多次释放的内存安全问题，而且也同样满足所有权第一条的规则。
如果变量中包含有需要申请堆内存的值就会进行发生所有权移动，而不是复制，因为堆内的数据大小无法确定，复制可能会造成大量资源的消耗：
let var1 = (3, String::from("s"));
let var2 = var1; //这里会发生所有权移动。
------------
struct Demo {
a:char,
b:i32
}
let var1 = Demo{a: '3', b:3};
let var2 = var1; // 所有权移动克隆
克隆可用于对堆内存的值的拷贝，堆内存数据在Rust内不存在深浅拷贝的说法，可以认为克隆就是深拷贝，完全拷贝堆内存数据，比如String类型就实现了Clone trait，可以通过调用clone方法拷贝一份数据：
let var1 = String::from("sd");
let var2 = var1.clone(); //克隆，
println!("{},{}", var1, var2); //编译成功
-------
#[derive(Debug,Clone)] //必须定义Clone才能调用clone方法，
struct Demo {
a:char,
b:i32
}
let var1 = Demo{a: '3', b:3};
let var2 = var1.clone(); //克隆堆内存
println!("{},{}", var1, var2); //编译成功
------
#[derive(Debug,Copy,Clone)] //实现Copy和Clone，在赋值时会发生赋值
struct Demo {
a:char,
b:i32
}
let var1 = Demo{a: '3', b:3};
let var2 = var1; //克隆堆内存
println!("{},{}", var1, var2); //编译成功
-----** but **----
//这里是编译不通过的，
//因为Demo中的b类型实现了Drop trait
#[derive(Debug, Copy, Clone)]
struct Demo {
a:char,
b:Vec<i32>
}
如上例中，通过对全部是标量类型成员的结构体，实现Copy和Clone trait是可以在赋值时直接发生克隆操作的，不必要显示调用clone方法。但是对于成员中含有如Vec<T>类型的结构体，则无法实现Copy，因为其本身实现了Drop，与Copy trait互斥。
栈中的数据调用clone和不调用clone的效果是一样的，因为在重新赋值时就是完全拷贝的，所以可以省略clone的调用。
对于所有权的规则可以通过各种的变量组合进行测试，总结规律，才能印象深刻。
函数作用域
不仅仅是变量重新赋值，当值在不同作用域间传递时，也会发生所有权转移，下面的示例无法成功编译。
fn main() {
let s = String::from("sd");
test(s);// s的所有权转移至test函数内
println!("{}",s);
}
fn test(s:String) {
println!("{}", s);
}由于第三条规则的原因，离开作用域会释放内存，所以发生所有权的转移同样是为了防止发生内存安全问题。
fn main() {
let s = String::from("sd");
let a = test(s); //s所有权转移，原s失效，a接受test内转移的数据。
println!("{}", a);
}
fn test(s:String) -> String {
println!("{}", s);
s // s作为返回值返回，所有权转移出此方法
}//离开，作用域内变量释放上面的例子说明了所有权转移的变量，只是变量失效，但并不影响值，将值转移给其他变量，函数的返回值也是同样可以转移所有权。
完