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]

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

[jonsetian]

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

[wolfboyyang]

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

[panxy2013]

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

[h2222]

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

[aswangc]

借用是对引用更高一层的概念，引用是拿到变量的地址（& 取址），而借用也包含了引用（取址）但是Rust编译器怎加了一个所有权的实现即：-同一时刻，你只能拥有要么一个可变引用，要么任意多个不可变引用

综上所述：Rust将引用与所有权的实现合并的概念称为借用

[supernova4869]

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

[sunface]

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

[qyWeiqy]

每日乳法

[JerryIreya]

精辟

[zhwei820]

这也能乳法

[NovaVoyager]

666

[zhongyi-byte]

好!

[ghost]

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

[lonexw]

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

[caoxiemeihao]

很润 😂

[beinglida]

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

[sunface]

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

[ghost]

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

[alexniver]

[asuper0]

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

[lovefengruoqing]

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

[ZYFZYF]

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

[ghost]

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

[fenglea]

你是真的细！！！！！！

[xjy12345654]

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

[xianzheTM]

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

[aswangc]

•	所有权转移会使原始变量失效，无法再被使用。
•	借用则允许临时使用变量，而不改变其所有权，原始变量在借用期间仍然有效。
•	借用是 Rust 内存安全的基础，确保在运行时不会出现悬垂引用或数据竞争问题。

所有权转移意味着原始的变量将变得不可用，为借用则不然，借用可以理解为是将所有权暂时借出，不会销毁原始变量

[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]

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

[travisbikkle]

合理，太他妈合理了。怎么没早发现 rust

[JavaZeroo]

太漂亮

[simexce]

这不是就是读写锁思想吗？

[jieqiyue]

所以借用的目的就是为了让某些变量，不会在调用了某一个函数之后就失去作用吗？
我目前就想到这样的好处，并且还让整个程序简单一些，不用太过考虑某一个变量这个时候是不是可以使用？

[jsenjobs]

引用必须有效的有点怪，不是因为引用必须发生在所有者生命周期内，才出现的引用肯定是有效的吗？

[YaQia]

补充一些关于可变引用的内容：

防止出现数据竞争不光是多线程的事情，在单线程时依然有用武之地。

单线程时假设同时出现两个引用：一个可变，一个不可变，则可能会造成混乱。

fn main() {
    let mut x = 42;
    let y = &x; // 不可变引用
    change_x(&mut x); // 可变引用（编译错误）
    println!("{}", y);
}
fn change_x(z: &mut i32) {
    *z = 99;
}

这个代码里y拿到了x的值42，而且z修改了x的值为99。

如果这份代码能编译通过，虽然实际中y的值也会随之变化为99，但程序员可能会假定拿到的是开始时的值（假如修改做得更隐蔽一些，就很难看出来x的值已经改变了），随后导致各种逻辑错误。这就是单线程也需要防止数据竞争：防止使用了过期的值、引发数据错乱等。

变量本身和可变引用之间是否也是一种数据竞争？

是，所以实际上在声明了一个可变引用后，使用这个可变引用时会独占这个变量的访问权。

下面这份代码是会报错的：

let mut x = 10;
let y = &mut x;  // 可变引用
x = 20;          // 尝试直接修改变量（违反规则）
*y = 30;

所以不光是可变引用和不可变引用不可以在一个作用域内使用，甚至变量本身和可变引用都不可以在一个作用域内使用。

[druhuvy]

前面补充得当，后面貌似解释不太合理。因为let y = &mut x; // 这里的y是一个指针类型。
直接操作 y=20，相当于把i32类型赋值给指针类型，这肯定是不对的。所以操作指针指向的值，必须对指针解引用。

[1654364091]

关于“所有权”小节提到的：“但是注意: 可变引用 &mut T 是不可以 Copy的”，我有一些疑惑，既然可变引用 &mut T没有copy 特征，那么不就意味着可变引用传入函数后，后续代码将无法继续使用这个可变引用吗？但是我实际测试发现，函数调用并没有发生可变引用的move：
fn main(){
let mut s = String::from("hello");

let s1 = &mut s; // 可变引用

let l = str_len(s1); // 传入参数（如果没有copy特征，不就意味着会变量s1会发生move，进而失效？）
println!("{} size: {}", s1, l); // 如果s1被move，这里就无法编译通过，但事实是编译通过，说明s1没有失效。

// 正当我怀疑可变引用具有copy特征时，发现下面的两行代码会提示s1被move而报错（黑人问号脸）
// let s2 = s1;
// println!("{}", s1);

}
// 以可变引用为参数的函数
fn str_len(s: &mut String)->usize{
s.len()
}

[1654364091]

请问有人能帮忙解释这个现象吗？可变引用为什么没有在传入参数后失去所有权呢？

[xjy12345654]

引用没有所有权

[1654364091]

@xjy12345654 这里不是有关所有权的讨论点，是有关move特征和copy特征的疑问。相关的疑惑已经解决了，是rust中的reborrow机制发挥了作用

[xjy12345654]

ok

[1654364091]

@xjy12345654 嗯，顺便展开解释一下。我们说“可变引用没有所有权”，其实是指可变引用它没有所指对象的所有权，能更改堆内存数据是“借用”机制赋予它的权利。同时，可变引用本身在栈内是有数据存储的，虽然是栈的数据，且没有堆数据的所有权，但是不影响这个变量本身也可以被move，理由如下：
“move”语义强调的「将一个值从一个变量转移到另一个变量，并让原变量后续不可用」，这是核心目标：确保内存安全。尤其是拥有所有权的数据，因为它们背后有堆内存数据管理，所以move是它们的标配行为。这种常见“所有权变量+move”的场景，容易让我们误解move的目标必须是拥有堆内存所有权的变量，但从move的设计上讲，我们其实可以move任何变量，比如一个i32类型的变量，只不过没有必要，因为它们足够简单轻量，本身就存在栈上，直接copy最省事，也就不会有并发隐患。同理，我们也可以move“不可变引用”，当然，这也是没必要的，因为多个不可变引用之间也没有并发隐患。「避免这种没必要的move，就是copy特征存在的意义！」
回到可变引用，它拥有一个堆内存的更改权限，所以和String等类型一样具有内存安全的隐患，因此rust没有给他赋予copy特征，编译器看到它没有copy特征，那么我们把它赋值给另一个变量时，就会对它进行move。解释到这里，也就说明白我最开始的疑惑了——可变引用没有copy特征，在传入函数时却没像String类型一样发生预期中的move！
现在问题解决了，是rust存在的reborrow机制（我只能说：holy shit！）

[xbsheng]

冲冲冲~

[xbsheng]

👍🏻

[Huangyj-86]

感觉和C++的指针差不多啊,只是不再用释放内存了

[AboidoLiven]

有点像互斥锁与共享锁

[xflcx1991]

Rust 1.81 允许这样写了，是借用检查器更智能了？

    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s;

[xflcx1991]

Rust 1.81 这样也可以了

    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{},", r2);

更加智能，只要不同时用就可以？

[kmfors]

应该是检测到r1没有使用，因此编译期间会当作最后使用从而脱离作用域吧。

[xlay666888]

文章里，s、s1、“hello”字符串，3者的关系有问题。s应该也指向“hello”而不是s1.

[xlay666888]

那个图片，有问题

[xlay666888]

还有本章里不应该存在“引用”这个词，应该全部改成“借用”，，可变借用，不可变借用。

[by1aN]

因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。

未曾拥有过，所以也不会失去