rust-course/basic/ownership/ownership

[giscus[bot]]

basic/ownership/ownership

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

[zmh1994]

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

[zhucan]

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

[jtyoui]

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

[Tmem0rethinks]

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

[ysy]

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

[YanZu6wh]

对楼上的疑问:
let s1 = "hello world"
let s2 = s1
此时 s1 s2 应该都有效吧 不是s1 不会存在吧？
应该是 String::from 这种方式创建的 进行变量绑定，s1 才会失效！(不知理解是否出错)

[1mujue]

说s1不存在，是如果s1只在s2被定义的时候使用，而之后都没有被使用，那么s1就完全用s2来代替，所以s1不存在。假设s2在被定义后从未被使用，那么优化后，s1和s2就都不会存在。

[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 中每一个值都 有且只有 一个所有者(变量)

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

[sunface]

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

[ivechan]

:) 是我要感谢这个教程

[zzlufida]

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

[tomtomtomtony]

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

[w3hh3w]

这里说的每一个值是可以理解为每一个值的内存空间有且只有一个所有者或者说有且只有一个变量拥有这个值内存空间的所有权吗

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

[dxchub]

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

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

[craftopc]

似乎所有权的转让是在编译期间进行检查的， 实际中我调试代码时候似乎没有发现相关代码
本人水平有限， 仅供参考

[meteorzh]

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

[Blackjack200]

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

[noalias]

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

[xx-in]

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

[xx-in]

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

[leslie255]

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

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

[starkm-li]

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

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

[dxchub]

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]

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

[jeddygong]

写的真好啊，看了这么多 Rust 相关的书籍和资料，也就这里能一遍就懂~

[Vuiora]

原变量在所有权转移后为什么不被视为未使用的变量呢

[yhm-amber]

我理解，假如有 a ，然后值从 a 转移给 b ，那么这也算一种对 a 的使用了。因为，大不了，如果对应的值真的完全没被用到 —— 从而推得就没必要计算或定义它的话，这意味着此时 b 是那个未被使用的名称，编译器要提醒这种事情就用 b 报错就好了。

[yhm-amber]

确实，简单值不会被 move 。

fn add1(a: u32) -> u32 
{
	a + 1
}

fn main() 
{
	let a = 1;
	println!("{}", add1(a));
	println!("{}", add1(a))
}

play

[yhm-amber]

对于 &str 这种自然可理解为引用，因为有 & 。那，所有有相似行为的类型，比如 i32, u8 啥的，都可视为是对于 一个 硬编码值的引用吗？

[yuzhiblue]

看了两遍所有权这一节，我发现老师把简单的事情讲复杂了。。。。

首先应该从rust的类型开始，类型分为基础的（u32,i8,char,[],&str等等）和高级的（String,Vec等等）。

基础的都是静态的，都存在栈上，栈上的数据不存在所有权转移，我们把这个特性起了个名字叫Copy特征。

高级的都是动态的，都存在堆上，堆上的数据都会转移所有权，如果两个变量都想要该怎么办呢？使用clone()方法。

通篇只讲了一点，那就是：别的语言堆上的数据不转移所有权，所以不安全。rust的解决方案就是转移所有权。就这一点区别，仅此而已。

以上表述可能不是很准确，但大体是这个意思，看看老师举的例子是不是符合我说的几点？大家不要钻牛角尖出不来。

[Aimercatxxx]

醍醐灌顶

[GrandMarch]

想了半天，其实这个和C#/.net的值类型和引用类型几乎一样啊。值类型是的x=y是复制了一份，引用类型的x=y是引用了y（相当于指针）。rust与C#不同的是强制引用计数器始终是1而已，C#的引用计数器可以大于1。

[GrandMarch]

$str其实相当于指针（比指针高级很多），C#也是有指针的。看到这里我用了大约两个多小时，目前为止我还没有觉得有让我难以理解的内容。

[jim-yefeng]

和 C++的拷贝（构造/赋值）， 移动（构造/赋值） 语义相同

[zhoudh2024]

有种被枪逼着用指针的感觉啊

[lanshi17]

这个和c++中的移动语义有什么区别？🤔

[baoheipojis]

为什么所有权部分的练习题就已经涉及引用了呢。感觉在这里做练习的时候用到了很多没讲到的东西。如果作者是想2.3.1和2.3.2都学完一起做练习，那我想应当把这两部分的题合在一起。

[ishenmao]

看起来感觉就像C++里的 std::move()，

[yikolemon]

无语和你说不下去，典型的Java思维。之前写Java看这个感觉脑子快不够用了

[Capyhw]

rust还挺纯爱的 😎

[telecomshy]

2026年4月，还有没有人一起和我一样老老实实啃教程的？

[Antecer]

感觉本章需要解释一下这个问题：
fn main() {
let s1 = String::from("中");
let s2 = "中";
println!("s1_len: {}", size_of_val(&s1));
println!("s2_len: {}", size_of_val(&s2));
}
输出：
s1_len: 24
s2_len: 16

这里 s1 是字符串类型 String 包含 <指针长度，有效字符串长度，字符串容器长度>
这里 s2 是一个胖指针 &str 包含 <指针长度，有效字符串长度>

[Mahiro2211]

我前段时间在阅读《Rust程序设计》这本出版物，看的有点懵，但是里头有有句话是“能力不足怨不得书”，这本书对读者前置要求比较多，所以我去找另外的教程，发现了这个教程，这绝对是最适合新手阅读的Rust教程。👍