借用

作者: BIGHAI | 来源:发表于2017-06-09 18:28 被阅读0次

借用
借用
借用
借用
借用
《借用》
借用认知
《借用星空》
人物（借用）
2017.3.17（借用）

唯一的区别就是对象的字面形式仍然需要使用“，”来分割元素，而class语法不需要。。。。

通过前面的学习，我们知道了所有权可以有效避免程序在运行期间执行某些无效操作，对于某些我们希望可以宽容的绕过所有权的严格处理的方法就是——让借出去的所有权归还给自己。但是上篇对此所提到的做法并不优雅，实在是繁琐，看看下面的邋遢的代码段：

fn main(){
    let mut v1:Vec<i32> = vec![1,2,3];
    let mut v2:Vec<i32> = vec![4,5,6];
    /*
    **let answer:i32;
    **(v1, v2, answer) = giveBack(v1, v2);
    **error[E0070]: invalid left-hand side expression
    */
    let (v1, v2, answer) = giveBack(v1, v2);
    for num1 in v1{println!("{}", num1);}
    for num2 in v2{println!("{}", num2);}
    println!("{}", answer);
}

fn giveBack(v1:Vec<i32>, v2:Vec<i32>) -> (Vec<i32>, Vec<i32>, i32){
    println!("give back to you!");
    (v1, v2, 99)
}

就像看上去的那样，而且如果利用模式赋值的话貌似左边必须出现一个let？暂且抛开这个问题不提，下面聊聊rust中的借用和引用。

1.使用借用

我们可以使用借用改写一下上面的那个例子：

fn main(){
    let v1:Vec<i32> = vec![1,2,3];
    let v2:Vec<i32> = vec![4,5,6];
    let answer:i32 = borrow(&v1, &v2);
    println!("{}", answer);
    for num1 in v1{
        println!("{}", num1);
    }
    for num2 in v2{
        println!("{}", num2);
    }
}

fn borrow(v1:&Vec<i32>, v2:&Vec<i32>) -> i32{
    99
}

通过上面的实际例子，我们就可以发现是使用借用的确是对所有权系统的一个很好的补充。当我们使用借用的时候，我们利用借用得到的变量对资源所做的改变会实际影响原先的变量，而且尽管我们利用借用所得到的变量会进入某些块作用域中，但是在离开这个块作用域的时候并不会使得借用变量所绑定的存储在堆上的资源被销毁。下面看个更加复杂的关于借用的例子：

fn main(){
    let vec1:Vec<i32> = vec![0; 20];
    let vec2:Vec<i32> = vec![0; 70];
    let total:usize = fun2(&vec1, &vec2);
    println!("{}", total);//90
    for num1 in vec1{
        print!("{} ", num1);//0 0 0 0 0.....
    }
    println!("");
    for num2 in vec2{
        print!("{} ", num2);//0 0 0 0 .....
    }
}

fn fun1(v:&Vec<i32>) -> usize{
    v.len()
}

fn fun2(v1:&Vec<i32>, v2:&Vec<i32>) -> usize{
    let length1:usize = fun1(v1);
    let length2:usize = fun1(v2);
    length1 + length2
}

题外话：vector数据类型不仅索引的数据类型是usize，而且利用对象方法len()获得长度其数据类型也为usize。这里的问题是这样的：如果把上面的代码改成下面的样子的话也能够成功运行：

fn main(){
    let vec1:Vec<i32> = vec![0; 20];
    let vec2:Vec<i32> = vec![0; 70];
    let total:usize = fun2(&vec1, &vec2);
    println!("{}", total);//90
    for num1 in vec1{
        print!("{} ", num1);//0 0 0 0...
    }
    println!("");
    for num2 in vec2{
        print!("{} ", num2);//0 0 0 0 0...
    }
}

fn fun1(v:&Vec<i32>) -> usize{
    v.len()
}

fn fun2(v1:&Vec<i32>, v2:&Vec<i32>) -> usize{
    let length1:usize = fun1(&v1);
    let length2:usize = fun1(&v2);
    length1 + length2
}

通过上面的例子。我们能够知道：对于fun2函数中的局部变量v1以及v2来说，他们都是引用数据类型的变量；但是为什么可以对一个引用再次利用&得到他的引用呢？？

2.借用类型也是默认不可变的

对于一个借用数据类型的变量来说，默认情况下，我们不能够对其进行任何会改变其值的行为，因为借用数据类型变量也是默认不可变的。但是如果你实在希望实现对借用类型进行值更改的操作的话，那么你只需要对其加上mut修饰就足够了。但是对于希望函数的形参是一个可变的借用类型的话，那么不仅需要在声明形参的时候像下面这样声明：variableName:&mut type，而且传入的实参也得像下面这样：&mut variableName。由此就要求variableName这个变量本身就得是可变的。下面举一个例子：

fn main(){
    let mut v1:Vec<i32> = vec![1,2,3];
    let len:usize = borrow(&mut v1);
    println!("{}", len);//4
    for num in v1{
        print!("{} ", num);//1 2 3 9
    }
}

fn borrow(v:&mut Vec<i32>) -> usize{
    v.push(9);
    v.len()
}

3.关于借用所必须要注意的问题

1.不可变借用也好，可变借用也罢，他们都得必须位于比拥有者更小的作用域。举一个例子：

//例子抛出错误：error: `num` does not live long enough
fn main(){
    let borrow:&i32;
    let num:i32 = 9;
    borrow = #// 1 borrow occurs here
}//num dropped here while still borrowed

为什么借用必须位于比拥有者更小的作用域呢？这里做一个猜测：我们知道普通变量是存储在栈里面的，而对于栈这种数据结构来说，先进后出是他的标志性特征，所以对于上面的例子来说borrow变量一定是后于num变量被销毁的，在位置1处，borrow变量开始借用num，但是随之就是main函数的结束，所以里面的变量都会被销毁，根据销毁顺序那么也应该是先销毁num，但是此时borrow还存在着，他跟num是绑定着的，所以将num销毁的话，将会让borrow找不着北，所以这种情况下会报错。但是如果是先将borrow删除的话，那么就是OK的。

2.在同一个作用域下，对同一个资源不能同时存在不可变引用和可变引用。

//抛出错误：error[E0502]: cannot borrow `source` as mutable because it is also borrowed as immutable
fn main(){
    let mut source:i32 = 9;
    let immutable_borrow:&i32 = &source;
    let mutable_borrow:&mut i32 = &mut source;
}

从上面的例子，我们还能够看出另外一点特性：那就是对于一个可变的变量来说，我们既可以为其创建不可变的引用；也可以为他创建可变的引用——当然了在同一个作用域中是不能够同时出现的。但是对于一个不可变的变量来说，你就不能够为其创建一个可变的引用。言归正传，回到抛出的错误：error[E0502]: cannot borrow source as mutable because it is also borrowed as immutable，错误提示已经很明显了，就是说对于同一个资源来说不能够同时对其的可变引用和不可变引用。那么这是为什么呢？对于可变引用，他可以改变引用的资源内容，但是对于我们的不可变引用来说，很显然他接受不到资源的实时变化，而对于这种情况显然是注重安全的rust所不能够接受的，所以说这两种引用不可以在同一块作用域对同一个资源进行绑定。

3.在同一个作用域下，对同一个资源只能够有一个可变引用。

//抛出错误：error[E0499]: cannot borrow `num` as mutable more than once at a time
fn main(){
    let mut num:i32 = 9;
    let mutable_borrow1:&mut i32 = &mut num;
    let mutable_borrow2:&mut i32 = &mut num;
}

从抛出的错误信息来看，我们也可以很直观的看出那就是对于同一个资源来说在同一块作用域不能够有多个可变引用。就目前而言，我并知道为什么rust需要这样设计，以后在做解答吧。

4.在同一个作用域下，虽然不能够对同一个资源有多个可变引用，但是对同一个资源有多个不可变引用还是可以的。

fn main(){
    let mut num:i32 = 9;
    let immutable_borrow1:&i32 = #
    let immutable_borrow2:&i32 = #
}

对于这种情况，只能够用情理之中来形容，所以不解释。

4.隐式的不可变借用

直接看代码吧，反正目前为止也解释不了，记住即可：

fn main(){
    let mut num:i32 = 9;
    println!("{}", num);//输出9 位置1
}

别小看了上面那乍看起来貌似简单的代码，其实吧它上面隐藏了某些细节，就比如说位置1处的代码，其实在那里的num访问其实是一种不可变的引用？
可以看一个应用例子：

//error[E0502]: cannot borrow `num` as immutable because it is also borrowed as mutable
fn main(){
    let mut num:i32 = 9;
    let mutable_borrow1:&mut i32 = &mut num;//mutable borrow accurs here
    println!("{}", num);//immutable borrow accurs here
}

上面这个例子抛出的错误信息也很明显，说明了对于一条简单的println!()语句中出现的变量来说，从更深层次角度来看是表明了这个变量是对资源的不可变式的引用。既然如此的话，由于在rust中规定了不能够在同一个作用域中出现对同一块资源即出现可变引用又出现不可变引用，所以这个例子会抛出错误。

当然，修改这个例子也很简单，因为是由于在某一个时间段中即出现对同一个资源的可变引用又出现了不可变引用，所以我们对此做的补救措施就是将其中一个引用给销毁，所以应该销毁先出现的那个引用，怎么销毁？利用一个块作用域嘛，离开作用域后即自动被销毁了。：

fn main(){
    let mut num:i32 = 8;
    {
        let mutable_borrow1:&mut i32 = &mut num;
        *mutable_borrow1 += 1;
    }
    println!("{}", num);//9
}

如上所示，即达到了我们所希望看到的结果。