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]

:) 是我要感谢这个教程

[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 和其他语言对比比较大的特点

[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"的所有权到底是被哪个变量所持有？感觉这里还是有些模糊

[lonexw]

首先理解一个概念："hello" 是一个字符串字面量，

1）在内存管理中。Rust除了使用堆栈，还使用全局内存区(静态变量区和字面量区)，Rust编译器会将全局内存区的数据直接嵌入在二进制程序文件中，当启动并加载程序时，嵌入在全局内存区的数据被放入内存的某个位置。

2）全局内存区的数据是编译期间就可确定的，且存活于整个程序运行期间。

3）字符串字面量、static定义的静态变量(相当于全局变量)都会硬编码嵌入到二进制程序的全局内存区。

x: &str 是一个普通的引用（reference），你也可以理解为一个指针，这个数据存储在栈上，x 变量绑定了这个引用的所用权，这个指针指向 “hello world” 的内存地址。

拓展学习：

• https://rust-book.junmajinlong.com/ch5/02_rust_mem.html
• https://zhuanlan.zhihu.com/p/152119007

[ghost]

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

[miniTsl]

x应该只是借用了所有权

[bluecode2017]

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

[Sphinm]

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

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

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

[sirius768]

rust 对「基本类型」的拷贝，我认为理解为深拷贝更符合直觉。这部分内容，如果对C++比较熟的同学，理解起来应该不困难

[Skyfacon]

打卡，讲解的很清楚，尤其是从堆栈再延伸到 所有权的概念

[luoyingying123]

let mut x: String=String::from("hello world");
x={let s: String=x;s};//x移动给了s，为什么x还可以继续用
println!("{x}");
{let s:String=x;}
println!("{x}");//这里会报错

有大佬可以解释下这个问题吗

[luoyingying123]

x暂时失效但没离开作用域，栈上的内存还没释放?

[EiEddie]

重新赋值算不上"用", 在同一个作用域内 mut 变量总是可以重新赋值; 但是读写这个变量就算是 "用" 了.

let mut x = String::from("alpha");
drop(x);
// println!("{x}");   <--- error[E0382]: borrow of moved value: `x`
x = String::from("beta");
println!("{x}"); // 打印出 "beta"
x = String::from("gamma");
println!("{x}"); // 打印出 "gamma"

本质上 x 只是栈区的一个指针, 指向分配在堆区的一段内存, String 存储在堆区.
将 x drop 后堆区的内存被释放, 储存的字符串也烟消云散了, 但是 x 的本体--栈区的指针还在, 还可以重新指向堆区的另一段 String.

上面都是我推测的...

[luoyingying123]

s1被移动到s2中......s1不再指向任何数据，只有s2是有效的，当s2离开作用域，它就会释放内存

所以x和s1一样，移动后都相当于回到未初始化状态了？

[luoyingying123]

那路或多，多谢了

[mingbai2006]

建议在“变量绑定背后的数据交互”之前先介绍一下所有权和垃圾回收机制，并且使用基础数据类型来举例，然后再讲述转移和String类型，否则会有些跳脱，官方文档在这部分就写的比较好，可以作为参考

[abcfy2]

类比java或者其他高级语言来说，基本类型的变量绑定是值拷贝，高级类型的变量绑定是值引用，这么理解就通顺了

[umlink]

很棒

[sofakeer]

形象理解规则:

想象你有一个苹果，这个苹果是一个值，而你是这个值的所有者。这个苹果只能被你一个人所拥有，其他人不能同时拥有这个苹果。

现在，如果你把这个苹果放在桌子上（作用域范围），你仍然是它的所有者，因为只有你能够拿起它或者控制它。但是，一旦你离开了房间（作用域范围），你就无法再控制这个苹果了。在这种情况下，这个苹果会被丢弃，因为没有人能够继续拥有它。

换句话说，在 Rust 中，变量是值的所有者，当变量（所有者）离开了作用域范围时，对应的值就会被丢弃。就像你离开了房间，苹果就被丢弃了一样。这种所有权模型确保了内存的安全性和有效性，因为每个值都有一个明确的所有者，并且内存管理是在编译时进行的，避免了内存泄漏和悬空引用等问题。
by GPT

[lilhammer111]

“这段代码并没有发生所有权的转移，原因很简单： 代码首先将 5 绑定到变量 x，接着拷贝 x 的值赋给 y，最终 x 和 y 都等于 5，因为整数是 Rust 基本数据类型，是固定大小的简单值，因此这两个值都是通过自动拷贝的方式来赋值的，都被存在栈中，完全无需在堆上分配内存。
”

我觉得对于这段话，更通俗的理解是:
“这段代码并没有发生所有权的转移，因为正如所有权规则所言——Rust中一个值某一时刻只能被一个变量所拥有——这里的x,y变量只是都拥有了各自的'5'而已，这完美遵循了所有权规则，而上面这段代码导致‘新建’了一个5给了y的底层原因还是因为...”

[lilhammer111]

菜鸡的胡言乱语，大佬请忽略。。。

至于这段代码

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

为什么就没有为s2'新建'一个跟s1一模一样的值（或者说小女朋友，这么说只是为了迎合贵书画风），然后让s2也拥有一个同款女友？
这样的考虑也是为了提防一个经常会遇到的内存安全问题，即二次释放(double free)。
因为所谓的“同款女友”，本质上最核心的特征是，同款女友（指针）指向相同内存区域（地址），double free用一种恐怖的说法解释，就是你没法将同一个人“杀死”两次，她第一次“被杀死”就是一具尸体了，你说你又“杀”了她一次，你确定你没“杀”错人吗？这是一个细思极恐的问题，回到计算机上，你释放同一片区域（地址）的内存，你确定你没“释放”错内存吗？

[lilhammer111]

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

至于这个例子就更有趣了，有个细想之下容易迷糊的问题：
为什么字符串字面值"hello, world"和String类型的值都是在内存上，而前者之例子就会存在二次释放问题，而对于后者，当x，y变量走出作用域，却不存在二次释放问题了呢？

另一个对于我这样的初学者会感到困惑的点是，第一次见字符串字面值时，我不太明白为什么字符串字面值的类型不是简简单单的"str"，而是"&str"，一种被官方称为引用的类型。

这两个问题其实有很强的关联性，在我认为。

对于第一个问题，前者存在二次释放，后者不存在二次释放，产生这种差别的本质原因在于后者例中数据（即，字符串字面值）在内存中只读。
在内存中只读，则意味着可以安全的共享或者访问，对于这类内存中只读的安全数据，Rust使用一个特殊的处理，对该类数据的变量做上特殊标记，在释放时至多一次释放就可以保证安全（这个是纯tm瞎猜的，从逻辑上），这种与前者不同的处理方式，为了自洽Rust所有权规则，被称之为“变量不拥有数据所有权”，这也是这种变量的类型被特别命名为“引用”的原因。
而对于前者，因为这类数据在内存中不可变，因此要永远保证只有一个变量或者指针指向这片内存，这就是Rust所有权的一般规则，而后者例则更像是一个特殊规则。
所以，所谓的“指针”跟“引用”在Rust里的区别是不是就是一个指向内存可读可写数据，一个指向内存中只读数据呢？

[lilhammer111]

实际上，我的“纯tm瞎猜”是"真tm瞎j8猜"，因为这些内存中只读的数据（被引用数据）的生命周期贯穿整个程序，因此根本不存在变量走出作用域后释放内存的问题，或者说二次释放的问题。

[yetHandsome]

最后这里的注释没有看明白
fn makes_copy(some_integer: i32) { // some_integer 进入作用域
println!("{}", some_integer);
} // 这里，some_integer 移出作用域。不会有特殊操作

这里不应该是复制，就有2份，那复制进去的这份，在函数执行完成后
为什么这里是不会特殊操作，这里不应该是调用 drop 释放空间吗？

还是说，这里只是一个入栈跟出栈，原来的变量还在栈内没有释放？

[small-white0-0]

1. i32是纯粹的栈上数据，不需要回收堆空间。
2. 一个单纯的数字类型，标准库显然不会有其他额外的操作。

综合以上两点，所以变量生命周期结束后，自然什么都不会做，即没有特殊操作。

至于这个具体是做了什么。你可以理解为rust为所有未明确实现Drop trait的类型生成了内容为空的drop函数，也可以理解为没有实现Drop trait就没有调用drop函数。你喜欢哪个都可以，两种理解方式都可以认为是没有特殊操作。

如果你非要较真，可以去rust的 playground 看看编译后的mir或者hir，甚至llvm ir。

PS：纠正你一点错误，drop不负责释放栈空间。rust的栈空间管理是和多数语言（除了golang）一样自动释放的，离开函数就自己结束了。

[yetHandsome]

非常感谢你的解答，就是文中这样一段话
将值传递给函数，一样会发生 移动 或者 复制，就跟 let 语句一样
所以 这个
···
let x = 5; // x 进入作用域

makes_copy(x);

···

是否可以认为跟下面是等价的
···
let x = 5;
{
let y = x;
}
···
所以我认为，函数调用这里是复制了一份，且函数执行完成y不在作用域就被释放了

[small-white0-0]

···
let x = 5; // x 进入作用域

makes_copy(x);

···

是否可以认为跟下面是等价的
···
let x = 5;
{
let y = x;
}
···

上面两个代码效果是等价的。你的理解，我认为应该是正确的。

虽然可能内部实际细节可能是不一样的，但函数传参和赋值很多表现都差不多。我个人是完全把传参理解为一种特殊的赋值。

[hamster0523]

无处不再call某加加

[zcjie1]

为啥作者与其他编程语言对比的时候都不提C语言呢

[small-white0-0]

应该是没有必要吧。
虽然说c语言也是一种高级语言。但是，c语言也是现在常见语言中最低级的语言。
c语言语法简单，主要就是对于硬件的真实反映。个人认为c语言语法简单，高深内容本质上是对内存的理解和运用，和语言本身关系不大。在硬件架构没有大变的情况，c语言已经用足够简单的语法提供了硬件的抽象了，应该不会有语言试图冲击这个成功机会不大的行为。

没有语言可以做出更简单的硬件抽象且带来巨大的效益（这个巨大效益带来动力理论上是最难的。），让大量的c语言开发的基础设施修改。否则，没有语言可以打败c。

所以，现在多数语言都是在冲击高层次的抽象，并添加独特的特色。c++是抽象+高性能，rust是抽象+高性能+安全，Python是抽象+易用。
（其实关于高性能是每个语言都希望的目标，但是每个语言要求是不一样的。所以上面的目标高性能主要是根据语言社区本身的一些口号和外部评论总结的，不一定准。特色也是我简单总结的，应该是有不完整的或不准确的。）

都不和c打低级抽象战，都转为高级抽象，并通过有助于开发使用的特点去吸引某一个领域的人使用。

[amluckydave]

“当 s1 和 s2 离开作用域，它们都会尝试释放相同的内存”
此处的“和”，是否可以考虑替换成“或”，即可以表达的含义是，s1或者s2或者两者一并离开作用域时，都会发生二次释放？

[shanjiwan]

fn main() {
let s = String::from("hello"); // s 进入作用域

takes_ownership(s);             // s 的值移动到函数里 ...
                                // ... 所以到这里不再有效

let x = 5;                      // x 进入作用域

makes_copy(x);                  // x 应该移动函数里，
                                // 但 i32 是 Copy 的，所以在后面可继续使用 x

} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
// 所以不会有特殊操作

fn takes_ownership(some_string: String) { // some_string 进入作用域
println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 drop 方法。占用的内存被释放

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

最后的some_integer不是被copy了一份吗，为什么不需要特殊操作？

[AndySpf]

i32类型是实现了Copy的，那么就会存储在栈上，而存储在栈上的变量是不需要drop释放的
This effectively does nothing for types which implement Copy, e.g. integers. Such values are copied and then moved into the function, so the value persists after this function call.

[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 这样一个表达式（字符串应该没法直接加，只是表达这样一个意思）时，又会怎么样呢？还是说编译器会自动寻找最优的方法？