目录

一，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");
}