basic/ownership/ownership

[giscus[bot]]

basic/ownership/ownership

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

[zmh1994]

写得太好啦，对入门及其友好

[zhucan]

所有权从s1 move 到s2后，s1在栈上的空间是在离开作用域后，这个空间才会被释放吗？

[fenglea]

转移所有权仅仅是复制一份栈中的指针，再将新的指针赋予新的变量，然后让拥有旧指针的变量失效

[noalias]

s1栈上空间应该还在，只是rust编译器限制了对该地址的访问

[jtyoui]

离开作用域之后，会自动弹出栈，也就自动释放了

[Tmem0rethinks]

啊、不是取出复制后不放回吗？

[ysy]

具体s1/s2在栈上怎么存放，及什么时候释放，要看编译器的实现。教程上讲的仅仅是逻辑上等效的操作。
let s1 = "hello world"
let s2 = s1
这的示例代码，在编译优化时，可能s1压根就不会存在，直接优化成 let s2 = "hello world!"了。

[caoxiemeihao]

Rust：”可以帮你开辟变量空间，但用完必须马上还我“
人话：”钱可以借给你，但用完必须马上还我“

[keigu2008]

钱是凭本事借的，为什么要还(doge)

[sdllh]

我啥时候借过你钱？(doge)

[chenxiaochun]

rust：panic！

[xwal]

哈哈，应该是橡皮擦用完了还我

[zank520]

我明明向张三借的钱，虽然张三的钱是从你那拿的，但是你怎么绕过张三直接向我要钱

[Chechengyi]

1 Rust 中每一个值都 有且只有 一个所有者(变量)

是否可以理解为 Rust 每一块内存空间都只能被 一个变量使用呢？

[underwoodnoble]

@small-white0-0 不可以有多个mut引用的，你这里本质上就是只有一个引用，b在c定义之后是无法再使用了。

[small-white0-0]

@underwoodnoble

这个是可以的。可运行的例子：https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=9fbf5e52c2a14605744aedfad6bd1c24

这个是我在另外一本书里面看到的东西。不过，我并没搞清楚原理，也不清楚实用价值。只是当时正好看到，就拿出来说了一下。😂
这个也没有完全绕过借用检查，在c结束前，不可以使用b。在一个时间线上还是保证了可变引用只有一个。

（我看的rust资料比较乱，已经找不到在哪里看到的了。都要以为是我记错了，不过测试下来可以运行。）

[small-white0-0]

抱歉，我弄错了。这个就是在这个资料里面看到的。在生命周期那一章节。里面有个再借用。

（很好的资料，感谢大佬们。）

[realHakeen]

这个简短的理解应该 所有权结合作用域 Rust就能判断该内存空间是否可以释放

[starccy]

@small-white0-0 这个叫 None Lexical Lifetimes 非词法作用域生命周期。编译器会根据实际是否使用到了引用进行检查。

[ivechan]

原文：

• Each value in Rust has a variable that’s called its owner.
• There can only be one owner at a time.

中文：

• Rust 中每一个值都 有且只有 一个所有者(变量)

这里感觉翻译地特别到位，一个是没必要合并翻译，另一个是合并后含义有些改动。
比如这个章节里“转移所有权”概念里，如果用原文理解就比较容易。
但是如果按中文翻译的定义来理解就会产生一些疑问，比如
“只有一个所有者，那为什么会有转义的概念”

[ivechan]

这里感觉翻译地特别到位 -> 这里感觉翻译地不是特别到位

[sunface]

确实，译文中少了一层含义，感谢告知

[ivechan]

:) 是我要感谢这个教程

[zzlufida]

我来翻译一下:
RUST中的每个值都有个爹
只能有一个爹
没有后爹,亲爹的说法,后认养的儿子,他也会叫你亲爹.你问原来的爹呢,不好意思,我不认识.已被drop

[tomtomtomtony]

没看出来有什么翻译问题。顶多是缺一个“任意时刻”：“任意时刻，Rust 中每一个值都 有且只有 一个所有者(变量)”。

[yurnery]

有个疑惑, 像 Swift 这种依赖于自动引用计数的, 他是通过在编译的时候插入内存管理代码, 感觉比 Rust 还轻松呢.

[AndyJado]

rust牛在(据说)多线程的安全,轻松就意味着somehow loose constrain了鸭
https://forums.swift.org/t/what-language-is-more-memory-safe-swift-or-rust/31987/2

[lonexw]

自动引用计数也只是一种内存管理模式，主要的区别 swift 还是有 GC（垃圾回收的机制），rust 在无 GC 的情况下提供安全内存管理i的方式，这块从内存安全和性能提升的层面都有很大的提升，也是 rust 和其他语言对比比较大的特点

[aswangc]

但是rust的智能指针岂不是还是有用引用计数，从某种角度来说还是实现GC的功能，不同点是当这个智能指针不再使用时(离开作用域时)会被删除，可以这么理解么

[zhucan]

函数返回，不相当于离开了作用域吗 LAIN ***@***.***> 于2022年4月16日周六 17:34写道：

…

处于栈上的数据都是在函数返回时会释放吧，不一定是作用域 — Reply to this email directly, view it on GitHub <#690 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ADKZIT52TGBW57ZINQ3TLPLVFKCR7ANCNFSM5SIJA2HQ> . You are receiving this because you commented.Message ID: ***@***.***>

[cenmmy]

函数作用域了解一下

[cybernagle]

我推测了一下理解下来的一个变量的生命周期:

1. 申请变量, 压栈
2. 被直接使用, 出栈, 被消费.
3. 被子函数直接使用, 出栈, 压栈到子函数, 被消费.
4. 被子函数引用使用, 压栈寄存器值到子函数, 被消费.

这样的话, 形式上就实现了所谓的所有权. 这样理解正确吗?

[cybernagle]

不对, 变量创建的时候,在当前作用域其实不需要压栈. 是直接放在寄存器里面.
然后需要调用的时候, 把寄存器里面的值进行压栈, 传递栈地址给到子函数.
子函数再一一 pop 出来.
实际上与传统的调用方式发生的区别就是, 压栈了之后, 子函数还要消费父函数的东西. 直接消费的话, x86 里面, ebp 应该怎么指向呢 ,感觉好复杂.

[acctZCW]

不正确。其实我觉得用Rust来讲解堆栈概念并不合理，因为堆和栈本质上还是由于操作系统的规定，所以所有程序都使用这一概念，它和Rust本身的所有权特性是无关的。

从OS的角度来说，你每进入一次函数或者新的语句块，就会进行一次压栈，形成新的栈帧，你在里面定义的所有变量都在这个栈帧当中，当执行结束后栈指针会直接归位到开始位置，相当于一次性弹出了。

实际上有点类似C++的RAII概念，如果你希望继续控制这个变量，应当在弹栈时将指针传出来，如果不希望控制这个变量了，那么就会在弹栈时被自动回收。

Rust做的事比实际的栈要多。它实际上从编译器的角度做了改进：一是弹栈时回收变量时会自动释放堆上空间（栈本身没有这个功能，它只是纯粹的释放掉了栈自己存储的指针），二是在一个栈帧内实现了所有权的控制，也就是从编译器的角度来限制默认情况下不允许存在共享所有权的变量。

但是从栈的角度来说，天然是允许共享所有权的。

[meteorzh]

小疑问：
let x: &str = "hello, world";
这个"hello, world"的所有权在哪儿呢？

[Blackjack200]

你可以理解为，这个"hello world"的所有权在一个不可用变量名直接访问的变量上

[noalias]

&str 是引用类型，具有 Copy 特征，不会转移所有权

[xx-98946]

我也很好奇这个问题，其实书中提到了一点，但是并没有说很多，书中提到"hello,world"是被硬编码的，也就是硬编码到程序中，程序运行时是会被加载到内存中的，具体位置根据rust编译器决定。而所有权归程序所有，可以理解为是从字符串定义时开始占用内存，在最后一个访问该值后释放内存。其实就相当于所有权归属于一个不可直接访问的变量。

[xx-98946]

看到下面有个答案更准确，硬编码是出现在全局内存区（另外一种使用内存的方式），而不是在堆栈中，这样字符串字面量只会在程序销毁后才被释放，这也能解释为什么相同字面量的值对应的是同一个引用了。

[leslie255]

因此说明 s2 确实完整的复制了

这里的 “的” 应该用 “地” 😅
不过写的确实非常好，我感觉是所有 rust 教程里面所有权和借用讲的最清楚的了

[ddxiaoming]

和C++对比一下就是，Rust中基本类型的赋值操作表现出copy的行为，复合类型的赋值操作表现出move的行为，如果想让复合类型的赋值操作表现出copy的行为，就要显式的调用clone

[lonexw]

我觉得这样类比不是很好，这样有点生硬的从语法层面理解 move 关键字，copy 和 clone trait 的使用了，还是要挖清楚所有权的内部机制，内存管理的细节，才有助于写好 rust 代码 ：）

[ChrisLee0211]

let x: &str = "hello, world"中的"hello, world"的所有权到底是被哪个变量所持有？感觉这里还是有些模糊

[ghost]

x作为一个引用类型，不涉及所有权的问题。

[miniTsl]

x应该只是借用了所有权

[bluecode2017]

x 是指针，类型是&str。没有所有权。

[Sphinm]

基础类型没有所有权的问题

[aswangc]

let x: &str = "hello, world"; // x 是对字符串字面量的引用	

• &str 类型的变量（如 x）不拥有内存的所有权，它只是对已有字符串的引用。
• 字符串字面量的所有权属于编译器管理的内存区域，不需要在运行时显式释放。

[lhpqaq]

这个例子里：

fn main() {
    let x: &str = "hello, world";
    let y = x;
    println!("{},{}",x,y);
}

"hello, world"这块内存怎么回收？

[xhp281]

3.当所有者(变量)离开作用域范围时，这个值将被丢弃(drop)

应该是这个吧

[xhp281]

在 2.3.2 引用章节看到的示例：

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

let r1 = &s;
let r2 = &s;
println!("{} and {}", r1, r2);
// 新编译器中，r1,r2作用域在这里结束

let r3 = &mut s;
println!("{}", r3);

} // 老编译器中，r1、r2、r3作用域在这里结束
// 新编译器中，r3作用域在这里结束

[chenxiaohu]

"hello world"的内存在是在静态区，不会回收的，和整个程序命一样长

[Civitasv]

Rust 的所有权实现了 RAII(Resource Acquisition Is Initialization programming) 原则，实际上 C++ 里面的智能指针也是按这个原则实现的。

[duwoodly]

let x: &str = "hello, world";
字面量保存在只读数据区，&str是栈上的指针指向它而已。 它的生命周期持续到程序结束，程序结束后，由操作系统回收内存。

[holenlv]

可以简单理解拷贝堆内存的东西就是深拷贝 拷贝栈内存的就是浅拷贝么
以及 文中对于"值"的定义 其实就是一块内存吧？

[J1nH4ng]

有个偏题的问题：

代码中的::操作符和.操作符的具体区别是什么，对于例子中的代码：

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

s.push_str(", world!"); // push_str() 在字符串后追加字面值

println!("{}", s); // 将打印 `hello, world!`

为什么不可以是s::push_str("world")(抛开语法错误)

[mooxiu]

:: 是namespace下的function，.是method

[overflowaker]

请问文中最后一个例子函数返回 some_string 时是保留堆中的内存不变只把指针传给 s2 ，然后再在函数中将已经失效的所有者 some_string 移出作用域；还是在函数结束时只把内容传出去，然后把 some_string 这块内存 drop 掉，然后在 main 中为 s2 重新申请一块内存空间存储对应内容绑定 s2 呢？
第一种应该比较快，对 some_string 这块内存无需先 drop 再重新申请内存。但如果函数返回的不是像 some_string 这样一个变量，而是类似 some_string1+some_string2 这样一个表达式（字符串应该没法直接加，只是表达这样一个意思）时，又会怎么样呢？还是说编译器会自动寻找最优的方法？

[TigerLauCVTE]

所以常量没有“所有者”

[TigerLauCVTE]

应该说是常量值没有所有者

[SaberInGh]

刚开始不了解为什么二次释放会内存污染, 我觉得第二次如果检查到不存在忽略不就好了吗, 随后去查:
"当内存被释放后，操作系统或内存管理器可能会将该内存块标记为可用，并可能随后将其分配给其他部分的程序。如果同一个内存块被释放两次，那么第二次释放时，该内存可能已经被重新分配给程序的其他部分了。这时，第二次释放操作可能会破坏已经存储在新分配内存中的数据，或者更糟糕的是，可能会破坏内存管理器的内部数据结构。"

[zzlufida]

let 穷逼的女朋友=String::from("明星高圆圆");
let 赵又廷的老婆=穷逼的女朋友;
println!("现在给大家介绍一下,这位是穷逼的女朋友{}!", 穷逼的女朋友);

运行结果如下:

error[E0382]: 女票被移动: `穷逼的女朋友`
 --> src/main.rs:5:28
  |
2 |     let 穷逼的女朋友=String::from("明星高圆圆");
  |         --编译器:"我承认,这时候高圆圆的确是你的女票"
3 |     let 赵又廷的老婆=穷逼的女朋友;
  |              -- 编译器:"但是,你看看这里,你把你女朋友送给了赵又廷"
4 |
5 |     println!("现在给大家介绍一下,这位是穷逼的女朋友{}!", 穷逼的女朋友);
  |                                                    ^^ 所以你装逼失败
  |
  = note: 下次不要随便把女朋友送给任何人,容易被绑架,我把你这种行为叫做变量绑架,哦,不对,应该是变量绑定
  |
3 |     let 赵又廷的老婆=穷逼的女朋友.clone();
  |                    ++++++++如果科技发达的哪一天,我还是建议你克隆一个女票送他

关于更多丢失女朋友的问题, 请看`rustc --explain E0382`.

[J1nH4ng]

太rusty了，哥

[ppinkpant]

这个所有权 我个人觉得和java是一样的 只是java不立刻回收堆

[simexce]

以前的语言，语法和标准库基本上没多少关系，但现在的语言和标准库耦合严重，导致难以理解。
比如 1..4语法用于构造Range？ 要想理解1..4，就得知道struct。

[wjw99830]

s1到s2的move，为什么除指向堆数据的指针之外还额外拷贝了字符串的长度和容量？这一点是如何体现的，String的定义中只能看到一个vec字段，没有其他信息

[simexce]

=，内存上都是按位复制，但语义上要么move，要么copy；如果是move，只是编译器强制你不能用了；
因为vec就是数据解构里面常说的动态数组呀，所以里面有你说的三个东西；

[DataShare-duo]

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 这里，some_integer 移出作用域。不会有特殊操作

不会有特殊操作？

个人理解，在 makes_copy 函数中，some_integer 是一个局部变量，在离开作用域后，也是会被 drop 掉

[simexce]

Copy与Drop互斥，因为i32实现了Copy，所以不会drop

[DataShare-duo]

那 some_integer ，离开作用域后，内存是怎么被收回的呢

[simexce]

栈上的内存，随着函数返回，自动销毁

[oamcoder]

有两段代码：
fn main() {
let a = (1,2,3);
let b = a;
println!("{:p}", &a);
println!("{:p}", &b);
}
打印的值为：
0x16f2b6f24
0x16f2b6f30

fn main() {
let a = (1,2,3);
let b = a;
println!("{:?}", a);
}
通过内存调试，发现a和b的地址相同，如果再末尾加上 println!("{:?}", b); 地址又不同了，这个是编译器优化吗？

[1654364091]

关于文中提到的：“不可变引用 &T ，例如转移所有权中的最后一个例子，但是注意: 可变引用 &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()
}

[Futurow]

这里的s1移动到了s2，改成s1改名为s2会不会更好理解

let s1 = String::from("hello");
let s2 = s1;

[LancelotSaki]

我理解的转移所有权是这样的：基本类型的所有权就相当于小学的时候快收上去的作业本，每本作业本上的名字就是声明的变量，值就是作业的内容，因为内容简单我自己拿同桌的过来抄一份就还回去，虽然内容一样，但是有我的署名啊，对老师来说就是两份；非基本类型的所有权就相当于作业的内容太多了，时间来不及啊（好的，那现在这作业本就是我的了），我直接把同桌的作业本上的名字擦掉改成我自己的（这TM妥妥的明抢啊），后面老师检查作业本的时候发现有你的作业，在老师看来你同桌的作业本确实是没了。

[169LI]

我有笔和手机 。 笔便宜，给你或者借给你用都可以 但是手机不行 死我也要带着手机一起走。我是手机的拥有者，我可以改名（变量名），但我（内存地址）还是我。

[Flouis2017]

Java / JS 应该没有悬空指针的问题~