basic/ownership/borrowing

[giscus[bot]]

basic/ownership/borrowing

https://course.rs/basic/ownership/borrowing.html

[mxismean]

讲的很好

[SifungLei]

讲的挺好的。

[worldstearly]

干就完事了。

[MBearo]

同一时刻，你只能拥有要么一个可变引用, 要么任意多个不可变引用。这个同一时刻怎么理解？还是同一作用域？

[sixqa]

可变引用不能借给多个人，不然可能会因为多个人因为修改变量而产生矛盾，而不可变引用就没有这个问题，因为他们没有权限修改，所以不会发生矛盾。

[amazcuter]

同一时刻,你只能拥有一个老婆或多个女朋友.

[songsquirrel]

这就是差距...，我只想到了朋友和女朋友

[h2222]

同一时刻 == 同一作用域?? 我是这么理解的

[SKT1yang]

不仅仅一个作用域，是可变引用定义，到同一作用域下最后使用这个可变引用之间，不能有其他同一个值的可变引用。可能有点绕

[linbird]

可变引用与不可变引用不能同时存在小节下的

注意，引用的作用域 s 从创建开始，一直持续到它最后一次使用的地方，这个跟变量的作用域有所不同，变量的作用域从创建持续到某一个花括号 }

这一段是否应该改为

注意，引用(r1,r2,r3)的作用域从创建开始，一直持续到它最后一次使用的地方(println!(....)行)，这个跟变量的作用域有所不同，变量的作用域从创建持续到某一个花括号 }

[sunface]

确实，修改更的指向更明确，建议提个 PR :)

[ytf4425]

确实，修改更的指向更明确，建议提个 PR :)

这个是不提 PR 就不修改的吗

[asuper0]

确实，修改更的指向更明确，建议提个 PR :)

这个是不提 PR 就不修改的吗

私以为，提PR一方面体现你的付出，另一方面可以减少维护者的负担。

[ytf4425]

确实，修改更的指向更明确，建议提个 PR :)

这个是不提 PR 就不修改的吗

私以为，提PR一方面体现你的付出，另一方面可以减少维护者的负担。

啊我问的不是这个，我是想问问是不是不提 PR 就不修改，因为层主提出问题已近一年，估计也没有提出 PR，Maintainer 也已知悉近一年也并无修改。如果是不提 PR 就不修改，我打算就此提一个 PR，如果不是，想必有别的原因使 Maintainer 没有修改。

下面与本话题无关：此外我觉得既然本教程自诩为”圣经“，维护者对已有问题经常主动做一些小修小补也是很有必要的，这样才能达到”想要的教学效果“，毕竟不能真和《圣经》一样上帝说完就不改了（

[panxy2013]

这个可以不修改, 原本的解释挺好的. 举例只是针对当前的代码的解释

[daweilv]

引用、借用，这章感觉有点绕。引用是语法层面的，借用是概念层面的，可以这么理解么

[0xZoomEye]

汉语里面引用可名可动，这里又列到一个标题介绍，很容易误解成是两个动作。借用的对象时引用， 所以标题应该时借用接好了。

[jonsetian]

借用是概念，引用是操作，只记引用就行，把借用这个词忘掉

[wolfboyyang]

借用与所有权相对，一种操作/概念/意图/解释，而引用是类型，为了实现借用这个操作的具体实现。

[panxy2013]

看了评论,再回去看. 似乎就片尾提到借用. 确实只记录引用就好了. 和C语言一样.只是被应用的对象必须有相同的作用域

[h2222]

borrowing 是一个动名词, 本质是一个动作
reference 在这里可以理解为一个名词, 引用, 是一个东西, 变量的地址借用(borrowing)到一个引用上(reference), 借用一个动作, 引用是个东西用来放地址用的, 能对地址对应的值(value)进行修改的, 叫做可变引用 &mut xxx, 不能修改叫做不可变引用 &xxx

[supernova4869]

无法在函数结束后返回引用，正如无法在法国投降前攻下巴黎

[sunface]

哈哈，好比喻，我也来一个：偷心贼也偷不走他梦寐以求的女神的心。

[qyWeiqy]

每日乳法

[JerryIreya]

精辟

[zhwei820]

这也能乳法

[NovaVoyager]

666

[zhongyi-byte]

好!

[aeiou-h]

感觉跟指针差不多, 但是没有->运算符了

[lonexw]

其实就是是有了所有权概念和一些附加功能的指针，后面还有智能指针的内容 😄

[caoxiemeihao]

很润 😂

[beinglida]

看来之前学习Rust走错路了，之前直接看英文教程，本母语为中文的开发者，理解是真不到位，现在重新学一遍，瞬间豁然开朗了

[sunface]

英文的教程看了后，容易遗忘🤣

[ghost]

有没有可能是英文先打下了基础，再看这一版才有“悟”的感觉。对于这种抽象的内容，只学习一遍（不仅仅是看一遍）肯定是不够的。

[alexniver]

[asuper0]

你说的这个主要是每时每刻有大量新数据生成、旧数据需要删除的应用场景，需要转变的是编程思路，尽量复用数据结构，和用的什么语言关系不大~ 你用rust，不转换思路，一样是一堆new和drop

[lovefengruoqing]

感谢，确实比官方的文档更细致入微，之前看了几遍官方文档也没真正弄懂，现在终于搞懂了！

[ZYFZYF]

同一作用域，特定数据只能有一个可变引用
说这个可以避免竞争，但是直接修改原来的变量也可以改值，再加上那个可变引用，其实还是有两个地方可以修改变量的值，这样不会竞争么？

[Water3000]

@fritz1149 的举例是对的。并不会有两个地方可以修改变量的值，因为在y创建时，x值的所有权已经借给了y而不再属于x自己，且在y的生命周期内一直保持如此。在本例中，y的生命周期一直到*y=3之后才结束，所以中间的x=2会报编译错误。

[ghost]

@Water3000 提醒了我，“一个作者或多个读者”的原则，不仅适用于引用与引用，也适用于引用与所有者本身。细节太多了

[fenglea]

你是真的细！！！！！！

[xjy12345654]

@Water3000 不是说引用没有所有权转移么？ 是不是应该理解为防止数据竞争？

[xianzheTM]

@xjy12345654 借用是没有所有权的，他的说法确实不对，直白地理解就是我借给别人一辆宝马开，在别人还回来之后我才能把我这辆宝马换成奔驰。

[violeshnv]

fn main() {
    let mut s = String::from("456");
    let mut n = &mut s;
    foo(&mut n);
}

fn foo(s: &mut String) {
    let m = s;
    m.push_str("asd")
}

fn main() {
    let mut s = String::from("456");
    let n = &mut s;
    foo(n);
}

fn foo(s: &mut String) {
    let m = s;
    m.push_str("asd")
}

fn main() {
    let mut s = String::from("456");
    let mut n = &mut s;
    foo(&mut n);
}

fn foo(s: &mut &mut String) {
    let m = s;
    m.push_str("asd")
}

这三个都可以运行🤨

[violeshnv]

fn main() {
    let mut s = String::from("456");
    foo(&mut &mut &mut &mut &mut &mut s);
}

fn foo(s: &mut String) {
    let m = s;
    m.push_str("asd")
}

改正一下，可以任意加上 &mut

[zhwei820]

发现华点

[small-white0-0]

1和2的话，是因为let mut这里的mut不是一个“类型的声明”，他只是给编译器说明变量是否可以改变的关键字。（这个我在看模式匹配部分，遇到过类似的问题。测试下来是这样的。）

let mut n = &mut s在编译器自动推导规则下，等价于let mut n:&mut String = &mut s,let n = &mut s等价于let n:&mut String = &mut s。

前者可以在后面再次对n赋予一个&mut String类型的值，后者则不可以再次赋值，否则会导致编译器报错。但是他们的类型都是一样的。

[underwoodnoble]

后面可以看到，传递参数的时候，编译器会自动解引用到类型匹配的值，所以你加很多个&mut程序也能正常运行

[beichen2012]

let mut n = &mut s； 这里左边的mut是指n是可变的，后面还可以把n绑定到其他的mut String变量上面。右边的 &mut s， 是指这个n是s的可变引用，可以通过n（不管n可变不可变）去改变s的值： *n = String::from("other");。
在第三个例子里，m.push_str里的m，被解了两次引用，可以理解成 &mut (**m).push_str，rust自动做了解引用。

[Garker]

开始最难的阶段

[Elixin]

借用在值的改变上，既然String可以使用&mut进行改变，为什么同样使用基本类型却没办法进行改变了，有点一丢丢感觉不合理，这不是欺负老实人嘛！

[lonexw]

跟是否基本类型没有什么关系啦

[TianChen-Yu]

struct S;

fn add(v: &mut Vec<S>, x: S) -> &mut S {
    v.push(x);
    v.last_mut().unwrap()
}

fn use_(v: &mut Vec<S>, x: &S) {}

fn borrow(s: &S) {}

fn main() {
    let mut v = Vec::new();
    let added_s = {
        add(&mut v, S)
    };
    borrow(added_s);
    use_(&mut v, added_s);
}

这段代码编译器说是多个可变借用：

error[E0499]: cannot borrow `v` as mutable more than once at a time
  --> src\[...]\main.rs:18:10
   |
15 |         add(&mut v, S)
   |             ------ first mutable borrow occurs here
...
18 |     use_(&mut v, added_s);
   |          ^^^^^^  ------- first borrow later used here
   |          |
   |          second mutable borrow occurs here

但我感觉奇怪的是，
明明在add里边已经用掉了v的可变借用（脱离掉了大括号作用域），
为何这还是重复的可变借用……

[pplmx]

因为你没用掉added_s, 这样就可以

struct S;

fn add(v: &mut Vec<S>, x: S) -> &mut S {
    v.push(x);
    v.last_mut().unwrap()
}

fn use_(v: &mut Vec<S>) {}

fn borrow(s: &S) {}

fn main() {
    let mut v = Vec::new();
    let added_s = {
        add(&mut v, S)
    };
    borrow(added_s);
    use_(&mut v);
}

[Maninnlack]

这一小节好像没有讲到 ref 关键字的部分，但是在课后练习的部分发现了有相关的题目，这是写漏了？

[jeferwang]

啊...这令人着迷的安全性

[sofakeer]

讲的很好

[mzzxll]

fn main() {
    let a = String::from("something");
    foo(&a);
}

fn foo(s: &String) {
    println!("s is {}", *s);
    println!("s is {}", s);
}

为什么在 foo 里面的s可以不用解引用自动就可以获取到值，而且手动加上解引用也没有报错？

[herman7]

Nice !!!

[yunqingshaw]

但是，可变的s，和可变的s的引用s1；这俩都能修改s的内容，这不也是一种数据不安全么？本质上，与两个可变的s引用s1,s2不能同时使用，感觉是一样的道理呀~ 为啥第一种情况被允许呢

[TalpsG]

fn main() {
    let mut s1 = String::from("hello");
    let r1 = &mut s1;
    let r2 = &mut s1;
}

不是不能有多个可变引用么，我这段代码在本地可以过编译是为什么呀

[codecoron]

fn main() {
    let mut s1 = String::from("hello");
    let r1 = &mut s1; // 如果没有底下的println，r1的生命周期就持续到这里，就不会出现在r1的生命周期内，s1被mut borrow 两次
    let r2 = &mut s1;

    // println!("{}", r1); // 加上这行后，r1的生命周期持续到这里。就会出现在r1的生命周期内，s1被mut borrow 两次
}

[restart126]

绝了，这语言简直就是为并行设计的，这种引用设计直接避免竞争问题

[trytew]

建议可以单独说一下数组的引用，特别是如果多个可变/可变和不可变同时引用数组的不同元素的时候为什么会编译错误。rust会把数组看成一个整体，但是会有人会把数组每个元素都看成一个独立的内存产生迷惑。是的，那个人是我

[groobyming]

有个不太理解的问题，为什么会出现不可变和可变借用冲突。我大概的理解是 u_mut_ref 有对 name的可变借用，而 if let Some(ref name) 这句会生成一个对 name 的 不可变借用，然后在调用 modify_user(u_mut_ref, name) 这个函数的时候，同时有对name的可变借用和不可变借用的作用域冲突吗？

fn main() {
    test_reference_conflict()
}

struct User {
    name:Option<String>,
    age: Option<i32>,
}

fn test_reference_conflict() {
    let mut u = User {
        name: Some("candy".to_string()),
        age: Some(11),
    };
    let u_mut_ref = &mut u;
    if let Some(ref name) = u_mut_ref.name {
        modify_user(u_mut_ref, name);
    }
}

fn modify_user(user: &mut User, name: &str) {
    println!("begin to modify user...")
}

【错误提示】

error[E0502]: cannot borrow `*u_mut_ref` as mutable because it is also borrowed as immutable
  --> src/bin/simple_test.rs:17:9
   |
16 |     if let Some(ref name) = u_mut_ref.name {
   |                 -------- immutable borrow occurs here
17 |         modify_user(u_mut_ref, name);
   |         -----------^^^^^^^^^^^^^^^^^
   |         |
   |         mutable borrow occurs here
   |         immutable borrow later used by call

[AndySpf]

请问下，NLL编译器优化是不是还存在漏洞?

fn main() {
    let mut s = String::from("hello");
 
     let r1 = s.as_str();
     let r2 = &s;
     let r4 = first_word(r1);  // **_如果在这里传递参到其他函数，另一个函数内即使没有用到该引用，作用域的判断就会异常_**
     println!("{} and {}", r1, r2);
     // 新编译器中，r1,r2作用域在这里结束
 
     let r3 = &mut s;  // **_error: cannot borrow `s` as mutable because it is also borrowed as immutable_**
     println!("{} and {}", r3, r4);
 } // 老编译器中，r1、r2、r3作用域在这里结束
   // 新编译器中，r3作用域在这里结束

fn first_word(_s: &str) -> &str {
    "1"
}

这是什么原因导致的？

[xjy12345654]

问了下大佬， 因为lifetime elison规则 fn first_word<'a>(_s: &'a str) -> &'a str {
"1"
} 你传入了&'a str 返回了&‘a str 所以r1还在 那就不能使用可变引用 https://doc.rust-lang.org/reference/lifetime-elision.html?highlight=lifetime%20eli#lifetime-elision-in-functions

[AndySpf]

感谢感谢，所以这里是生命周期判断导致的，我只用把first_world的返回值改为String，就可以了

[xjy12345654]

额，我又仔细的回想了下， 再进一步解释下， r4虽然返回了“1” 但是在编译器看来 fn first_word<'a>(_s: &'a str) -> &'a str {
"1"} 返回值生命周期依赖于 _s入参， 也就是r4依赖于r1，r1是不可变引用。 r4有效期内 不可以再使用可变引用。 所以print中 既是可变引用又是不可变引用报错。

[YiiMus]

不愧是圣经，使我的大脑旋转

[donneyluck]

学就完事了

[lincyyaran]

把每个值都当成东西,立刻感觉好理解多了
我的,你借,需要还我
不是我的,我需要借,也要还的
你想改我的东西,,别人就改不了