目录
一,clone、copy
1,基本类型
2,类型的clone特征
3,显式声明结构体的clone特征
4,类型的copy特征
5,显式声明结构体的clone特征
5,变量和字面量的特征
6,特征总结
二,变量绑定
1,clone拷贝场景
2,copy拷贝场景
3,所有权转移场景
4,转移的永久性
三,引用
1,对常量的引用
2,对变量的不可变引用
3,对变量的可变引用
5,函数调用
四,引用总结
1,引用的生命周期
2,对字面量的引用
3,对普通变量的引用
4,对引用变量的引用
5,对同一变量的引用
6,链式引用
一,clone、copy
1,基本类型
rust基本类型包括:
- 所有整数类型,比如
u32
- 布尔类型,
bool
,它的值是true
和false
- 所有浮点数类型,比如
f64
- 字符类型,
char
2,类型的clone特征
拥有clone特征的类型:
- 基本类型
- String
- 容器
- 显式声明clone特征的结构体
没有clone特征的类型:
- 没有显式声明clone特征的结构体(结构体默认)
递归决定是否有clone特征的类型:
- 元组,当且仅当其包含的类型都有clone特征的情况下,其自身有clone特征。
3,显式声明结构体的clone特征
前提条件:当且仅当结构体中的成员都具有clone特征的情况下,可以显式声明clone特征。
#[derive(Clone)]
struct S{}#[derive(Clone)]
struct P{a:i32,b:S,
}
4,类型的copy特征
拥有copy特征的类型:
- 基本类型
- 显式声明clone特征的结构体
没有copy特征的类型:
- String
- 容器
- 没有显式声明clone特征的结构体(结构体默认)
递归决定是否有copy特征的类型:
- 元组,当且仅当其包含的类型都有copy特征的情况下,其自身有copy特征。
5,显式声明结构体的clone特征
前提条件:结构体具有clone特征
#[derive(Clone,Copy)]
struct P{a:i32,
}fn main() {let x:P=P{a:5};let y=x;assert_eq!(x.a,5);
}
5,变量和字面量的特征
字面量会自动推导出类型,所以变量和字面量都有唯一确定的类型。
变量和字面量是否具有clone和copy特征,完全取决于其类型是否具有。
6,特征总结
所有类型可以分为3类:
没有clone和copy特征,有clone没有copy特征,有clone和copy特征。
二,变量绑定
1,clone拷贝场景
对于有clone特征的变量或字面量,可以调用clone函数进行拷贝而不转移所有权。
#[derive(Clone)]
struct P{a:i32,
}fn main() {let x:P=P{a:5};let y=x.clone();assert_eq!(x.a,5);
}
2,copy拷贝场景
如果let绑定语句的等号右边是一个有copy特征的变量或字面量,那么这是一个拷贝行为。
let x = 5;let xx = x;assert_eq!(5, x);assert_eq!(6, xx+1);
3,所有权转移场景
如果let绑定语句的等号右边是一个没有copy特征的变量或字面量,那么这是一个所有权转移的行为。
错误代码:
let x = vec![1,2,3];assert_eq!(x[0],1);let y=x;assert_eq!(x[0],1); // 错误
错误原因:y转移走了所有权,不能再使用x
4,转移的永久性
错误代码:
struct P{a:i32,
}
fn main() {let mut x:P=P{a:5};{let y= x;}x.a=6;println!("end");
}
错误原因:y转移了x的所有权之后,x就再也不能用了,即使y的生命周期结束了也一样。
三,引用
1,对常量的引用
fn main() {let x:P=P{a:6};let y= & x;assert_eq!(x.a,6);assert_eq!(y.a,6);assert_eq!((*y).a,6);println!("end");
}
常量只有可读性,原变量x和引用变量y都持有读的能力。
这里y可以直接用,也可以先解引用再用。
2,对变量的不可变引用
正确代码:
struct P{a:i32,
}
fn main() {let mut x:P=P{a:6};let y= &x;assert_eq!(x.a,6);assert_eq!(y.a,6);assert_eq!((*y).a,6);x.a=5;assert_eq!(x.a,5);println!("end");
}
变量x持有读写能力,不可变的引用y只有读能力。
错误代码:
struct P{a:i32,
}
fn main() {let mut x:P=P{a:6};let y= &x;x.a=5;assert_eq!(y.a,5);println!("end");
}
错误原因:在y的读行为结束之前,x不能执行写行为,否则会造成冲突。
同一个变量可以引用多次,也可以对引用变量再进行引用:
struct P{a:i32,
}
fn main() {let mut x:P=P{a:6};let y= &x;let z=&x;let z2=&z;let z3=&z2;let z4=&z3;assert_eq!(x.a,6);assert_eq!(y.a,6);assert_eq!(z.a,6);assert_eq!(z4.a,6);assert_eq!((*z4).a,6);assert_eq!((**z4).a,6);assert_eq!((***z4).a,6);assert_eq!((****z4).a,6);println!("end");
}
这里的z4可以直接读成员,也可以解引用若干次再使用。
3,对变量的可变引用
正确代码:
struct P{a:i32,
}
fn main() {let mut x:P=P{a:6};let y= &mut x;assert_eq!(y.a,6);y.a=5;assert_eq!(x.a,5);println!("end");
}
错误代码:
struct P{a:i32,
}
fn main() {let mut x:P=P{a:6};let y= &mut x;assert_eq!(x.a,6);assert_eq!(y.a,6); println!("end");
}
错误原因:y的读写行为结束之前,x不能执行读行为,否则会造成冲突。
可变引用和不可变引用不能同时存在,否则会造成冲突。
5,函数调用
错误代码:
fn fun(x:Vec<i32>)->i32{x[0]+1
}fn main() {let x = vec![1,2,3];assert_eq!(fun(x),2);assert_eq!(x.len(), 3);println!("end");
}
错误原因:函数调用时转移走了所有权。
正确代码:
fn fun(x:&Vec<i32>)->i32{x[0]+1
}fn main() {let x = vec![1,2,3];assert_eq!(fun(&x),2);assert_eq!(x.len(), 3);println!("end");
}
实现方式:函数入参改成引用类型,传参时也要改成引用。
四,引用总结
1,引用的生命周期
(1)一个引用变量的声明周期只到它的最后一次读写为止
(2)如果声明了引用之后没有读写,那么生命周期直接结束,但是这和直接删除这一句不一样,因为声明引用这一行相当于一次读操作。
(3)如果一个引用变量y被z引用了,且z最后一次读写比y的最后一次读写更晚,那么y的生命周期延长到z的最后一次读写。
PS:如果声明了z是对y的引用之后没有读写,那么声明的这一句就是z的最后一次读操作,这也可能延长y的声明周期。
讨论引用规则时我们默认只讨论一个生命周期之内的引用。
2,对字面量的引用
对字面量的引用,无论是可变引用还有不可变引用,其实都不是引用,而是copy拷贝,讨论引用规则时我们默认不把对字面量的引用这个当做引用。
3,对普通变量的引用
对于普通变量,有mut的是可变变量,没有mut的是不可变变量(常量)。
可变变量可以加可变引用,也可以加不可变引用,不可变变量只能加不可变引用。
4,对引用变量的引用
无论是可变引用变量还是不可变引用变量,都和普通变量一样,可能是可变变量也可能是不可能变量。
对引用变量加引用的规则,和对普通变量一致。
5,对同一变量的引用
对不可变变量不能加可变引用,可以加多个不可变引用。
对可变变量可以加唯一的可变引用,也可以加多个不可变引用。
即,可变引用存在的情况下,只能有一个引用。
6,链式引用
以y是对x的引用,z是对y的引用为例,更长的链的情况应该规则类似。
y的声明周期参考上文“引用的生命周期”。
在所有情况下,z对x的读写能力都和y对x的读写能力相同,因为z一直持有对y的读能力。
(1)x是不可变变量
x和y 一直有读能力,没有写能力
(2)x是可变变量
在y的最后一次读操作或写操作之前,x没有读写能力,之后,x有读写能力
y的能力在声明周期内不变,有读能力,有没有写能力取决于是可变引用还是不可变引用。
五,ref
当我们要引用一个Option的内部成员,可以用ref
struct P{a:i32,
}
struct Node{x:Option<P>,
}
fn main() {let mut p = Node{x:Some(P{a:1})};if let Some(ref mut x)=p.x{x.a=2;}if let Some( x)=p.x{assert_eq!(x.a,2);}println!("end");
}