advance/smart-pointer/box

[giscus[bot]]

advance/smart-pointer/box

https://course.rs/advance/smart-pointer/box.html

[HollisMeynell]

请问,使用Box::leak后的这段内存,会有被重复使用的风险吗

[sunface]

不会的。

[shirok1]

应该跟在 C/C++ 里面 malloc 之后没有 free 一个效果吧

[Disc4will]

那还挺危险的

[limon]

返回 &mut，不会被 share

[ttxs25830]

不会，上面说了Box::leak消耗传入的值，也就是调用之后原本的值的所有权已经消失了，没有办法传入第二个leak

[X140Yu]

其实很多时候，编译器的鞭笞可以助我们更快的成长，例如所有权规则里的借用、move、生命周期就是编译器在教我们做人，哦不是，是教我们深刻理解堆栈、内存布局、作用域等等你在其它 GC 语言无需去关注的东西。刚开始是很痛苦，但是一旦熟悉了这套规则，写代码的效率和代码本身的质量将飞速上升，直到你可以用 Java 开发的效率写出 Java 代码不可企及的性能和安全性，最终 Rust 语言所谓的开发效率低、心智负担高，对你来说终究不是个事。

因此，不要怪 Rust，它只是在帮我们成为那个更好的程序员，而这些苦难终究成为我们走向优秀的垫脚石。

最后这一段话很棒！

[sunface]

谢谢 ：）

[Yuan-Zhuo]

两个疑问

1. 堆的大小在32位下应该主要取决于虚拟地址空间大小，小于3GB
2. CPU L3 Cache有几十MB，而栈最大一般是8MB，中型数据只要能分配在栈上，应该还是性能更好；另外，堆上分配后第一次读写还会触发page fault，进一步下降

[cxz888]

emmm. 现在 L3 都这么大么，我的只有 8M。。。😂
另外有点疑惑，CPU 缓存各个进程/线程是共用的吧？如果这样的话，一个程序是不是不应该假定自己可以用所有的 L3 缓存呢？
我没有系统学习过这方面的知识，还望不吝赐教😉

[freesrz93]

cache 每次读写是有限制的，x86-64下一般是64字节，接近这个大小不管在堆还是栈都容易不命中。
但是堆内存可能被换出，所以访问开销应该还是大一些，不过一般情况下应该区别不大

[Joneyao]

刷二遍，看的挺轻松，体会到要想rust 学的好，就得多多回顾rust的基本特性。用了一段时间后，再来看，体会真的不一样。

[greyhawk]

确实，刷第二遍，真的感受不同

[makuen]

Box::leak 多次调用的话会不会导致内存越用越多啊

[sunface]

所以，leak最好用于其适合的场景，不要滥用或者交给用户侧去触发

[limon]

Box::from_raw 可以收回来

[ghost]

例如Box::leak()可以用来解决static mut变量的初始化和unsafe问题。从这个场景考虑，我并不愿意将这种可以看作“故意”的操作称为内存泄漏，我更愿意将其当成匿名对象。

[ichsonx]

be better coder,希望如此

[zhouhaoan]

impl Draw for Button {
    fn draw(&self) {
        println!("这是屏幕上第{}号按钮", self.id)
    }
}

想不通为什么print语句不加分号也能过编译

[cxz888]

println! 是个宏，宏内部其实加了分号，所以返回值是 ()。

fn draw(&self) 没有指定返回值，那么默认就是 ()

[duanyuluo]

和macro没有关系，没有；就是表达式expr，有；就是语句statement。自然可以编译通过。但如果这个println之后还有一个expr或statement就报错了。

[ruaruagerry]

提个问题，大佬们详解下。

fn main() {
// 这行代码报错：thread 'main' has overflowed its stack
// 是不是证明了数组并非一开始就分配在堆上，而是先分配到栈上，再挪到堆上？
let test = Box::new([0; 100000000000]);

// 这行代码报错：memory allocation of 100000000000 bytes failed
// 证明一开始就分配到堆上，因此这才是正确的分配到堆上的操作
let test = vec![0u8; 100000000000].into_boxed_slice();

}

[lihongtao1024]

如果是先在栈上分配T，再迁移(copy)到堆的话性能也太低了吧。那rust语言怎么保证效率，连最基础的功能都这么低效。

[lihongtao1024]

let test = Box::new([0u8; 100000000000]);

我改成这样试了一下，在debug下确实是先在栈上分配数组。release下就没有报栈溢出了。

[Hoteryoung]

@lihongtao1024
学到了 学到了 谢谢大佬

[ddx533534]

"release模式下分配到堆上"这一结论是怎么得出来的？有没有可能是release模式下，栈空间分配的很大呢？

[Lixuhuilll]

"release模式下分配到堆上"这一结论是怎么得出来的？有没有可能是release模式下，栈空间分配的很大呢？

因为栈空间再大也不可能有90多GB，而且操作系统线程栈的大小是固定的，除非代码里面手动进行系统调用修改栈空间大小

[hhhxiao]

类似于c++的std::unique_ptr吗

[jingth]

怎么没有习题了？

[FlorentinoJink]

Box::leak的内存在程序结束后会被回收吗？如果不会回收岂不是真的内存泄露了

[Almagestum469]

生命周期和程序一样长

[ttxs25830]

Rust内部我不太清楚，但是在大多数操作系统上都可以放心，进程结束时OS会释放所有该进程占用的空间

[duanyuluo]

process不可能分配到超出自身的内存，这些都在操作系统层面来释放了。

[Joyserr]

Box::leak，它可以消费掉 Box 并且强制目标值从内存中泄漏
这段不是很理解，怎么理解这个泄露？有大佬来解释一下吗？

[ttxs25830]

就是Box里面的东西不是分配在堆上的，Box生命周期结束之后会释放么？leak就是不会进行这个释放了，这块内存不会被释放，就会一直存在下去，直到程序结束操作系统释放程序占用的所有内存为止

[darkforest42]

你好，我有个疑问
在这节的“堆栈的性能”里，小型数据，中型数据有点模糊，能具体有个范围吗？

[duanyuluo]

不同的CPU参数，不同的OS都会不一样。

[Endermanbugzjfc]

还是自己做 benchmark 吧 😅

[wangyaoyao233]

最后的总结说的很好，让一头雾水的我又开始振奋了

[alexnest]

应该怎么去理解“DST 类型”。定义下面会报错，因为List 是个递归类型。它一个枚举值引用了自身。
enum List {
Cons(i32, List),
Nil,
}
那为什么定义下面这个不报错？Node是个类型，它的一个值也引用了自身Vec<Node>。该如何去理解？为什么这里不需要用Box包装？
pub struct Node {
pub node: T,
pub children: Vec<Node>,
}

[duanyuluo]

两个代码的核心不同是，前者List是一个T，而后者是Vec。
Vec在struct中就是一个引用，四个字节，是确定长度的。而List则不是，因为递归定义了。

[duanyuluo]

你把你的第二段代码改为pub children：Node试试

[Endermanbugzjfc]

Vec 本来就是堆分配

[duhbbx]

• println! 可以正常打印出 a 的值，是因为它隐式地调用了 Deref 对智能指针
• 因为在表达式中，我们无法自动隐式地执行 Deref 解引用

这他喵的不是增加心智负担吗？一会要隐式，一会儿显式。。

[small-white0-0]

老实说这个一会儿隐式一会儿显式确实有很大的心智负担。
所以一般都会配合 rust-analyzer插件，在写代码的时候，让部分隐式变为显式（生命周期，重借用，类型推导等）。

不过一般来说，隐式的行为，主要出现在 方法调用、宏、生命周期的隐式，三个方面。
除了生命周期的隐式行为外，另外两个隐式行为还好，也不至于心智负担太重。生命周期的话，直接写出，代码的模板化就太严重了。只能编译器自动推导，再配合rust-analyzer显式展示。

只能说 c 可以用记事本写。rust 没有 rust-analyzer , 用记事本写，应该是没有能一次过编译的 ：）

[zeroonechange]

苦难终究成为我们走向优秀的垫脚石

[SnailFighter]

"它们都拥有一个所有者，因此受所有权规则的限制：当赋值时，发生的是所有权的转移"

这句话的意思是不是这样理解：
let stack = String::new("dump");
let stack1 = stack;

在堆上创建了一个字符串，内容是"dump", 并赋值给stack。 这个时候在堆上其实也有个指针指向了"stack" 这个变量？
let stack1 = stack;
然后赋值给stack1, 这个时候堆上的变量中的那个指针有指向了stack1.
"它们都拥有一个所有者" 这个“所有者” 就是堆上的这个指针指向的变量？堆上存在这样的指针吗？

[Endermanbugzjfc]

嗯？ 指针不是放棧上的吗？？

[john1127]

当栈上数据转移所有权时，实际上是把数据拷贝了一份，最终新旧变量各自拥有不同的数据，因此所有权并未转移。
-->这里应该是不是要描述数据实现了COPY特征，数据发生值拷贝；若一个结构体只包含基本类型，在栈上分配内存，并不会有值拷贝?

[AoranAllen]

应该是的，我测试了一下，这种所有权转移然后数据深拷贝了一份并存储在不同的变量中这种情况只有数据实现了Copy Trait的情况下才会发生，也就是说这种栈数据在所有权转移时默认先按照copy trait进行复制，没有实现copy trait的情况下就会进行所有权检查并报错

[john1127]

这个问题我又仔细思考了一下
#[derive(Debug)]
struct Point {
i:i32,
y:i32
}

fn test() {
let p1 = Point{x:1, y:1};
let i = 100;

println!("p1 = {:?} {:p}", p1, &p1 as *const Point); //输出:p1 = Point { x: 1, y: 1 } 0x7fff1b21095c

let p2 = p1;
let j = i;

//println!("p1 = {:?}", p1); //编译错误
println!("p2 = {:?} {:p}", p2, &p2 as *const Point); //输出:p2 = Point { x: 1, y: 1 } 0x7fff1b2109c4
println!("i = {} {:p}", i, &i as *const i32); //输出:i = 100 0x7fff1b210964
println!("j = {} {:p}", j, &j as *const i32); //输出:j = 100 0x7fff1b2109cc

}

根据以上例子我理解要只要是栈上变量"赋值"(函数传参，函数内局部变量，函数值返回)，rust和其他语言一样都会有内存拷贝(栈上)，
但是rust多了一步，编译器标记等号右侧变量无效直到其离开作用域并drop；若变量实现有copy特征，则运算符右侧变量依然有效

个人理解rust对变量的"赋值"和其他语言(c,c++,go)并没有两样，只是在编译器层面做出了一些限制

[AoranAllen]

我把下面这段代码反汇编看了下，的确是这样，drop这一说法在栈上并不准确，只是说编译器可以复用这一块儿的内存了

struct Co {
    i: i32,
}

fn main() {
    let c = Co { i: 1 };
    println!("{:p}", &c);
    let c2 = c;
    println!("{:p}", &c2);
}

0000000100002cf0 <__ZN4dors4main17h4563fab9ced14984E>:
100002cf0: 55                          	pushq	%rbp
100002cf1: 48 89 e5                    	movq	%rsp, %rbp
100002cf4: 41 57                       	pushq	%r15
100002cf6: 41 56                       	pushq	%r14
100002cf8: 41 54                       	pushq	%r12
100002cfa: 53                          	pushq	%rbx
100002cfb: 48 83 ec 50                 	subq	$80, %rsp
100002cff: c7 45 dc 01 00 00 00        	movl	$1, -36(%rbp)
100002d06: 48 8d 45 dc                 	leaq	-36(%rbp), %rax
100002d0a: 48 89 45 d0                 	movq	%rax, -48(%rbp)
100002d0e: 48 8d 5d d0                 	leaq	-48(%rbp), %rbx
100002d12: 48 89 5d c0                 	movq	%rbx, -64(%rbp) <--- i of Co
100002d16: 4c 8d 35 a3 ff ff ff        	leaq	-93(%rip), %r14         ## 0x100002cc0 <__ZN44_$LT$$RF$T$u20$as$u20$core..fmt..Pointer$GT$3fmt17h76476a963a14b374E>
100002d1d: 4c 89 75 c8                 	movq	%r14, -56(%rbp)
100002d21: 4c 8d 3d 20 55 04 00        	leaq	283936(%rip), %r15      ## 0x100048248 <_writev+0x100048248>

100002d28: 4c 89 7d 90                 	movq	%r15, -112(%rbp)
100002d2c: 48 c7 45 98 02 00 00 00     	movq	$2, -104(%rbp)
100002d34: 48 c7 45 b0 00 00 00 00     	movq	$0, -80(%rbp)
100002d3c: 4c 8d 65 c0                 	leaq	-64(%rbp), %r12
100002d40: 4c 89 65 a0                 	movq	%r12, -96(%rbp)
100002d44: 48 c7 45 a8 01 00 00 00     	movq	$1, -88(%rbp)
100002d4c: 48 8d 7d 90                 	leaq	-112(%rbp), %rdi
100002d50: e8 eb d0 01 00              	callq	0x10001fe40 <__ZN3std2io5stdio6_print17h3a964b8dccd58770E>

100002d55: 8b 45 dc                    	movl	-36(%rbp), %eax
100002d58: 89 45 d8                    	movl	%eax, -40(%rbp)
100002d5b: 48 8d 45 d8                 	leaq	-40(%rbp), %rax
100002d5f: 48 89 45 d0                 	movq	%rax, -48(%rbp)
100002d63: 48 89 5d c0                 	movq	%rbx, -64(%rbp)
100002d67: 4c 89 75 c8                 	movq	%r14, -56(%rbp)

100002d6b: 4c 89 7d 90                 	movq	%r15, -112(%rbp)
100002d6f: 48 c7 45 98 02 00 00 00     	movq	$2, -104(%rbp)
100002d77: 48 c7 45 b0 00 00 00 00     	movq	$0, -80(%rbp)
100002d7f: 4c 89 65 a0                 	movq	%r12, -96(%rbp)
100002d83: 48 c7 45 a8 01 00 00 00     	movq	$1, -88(%rbp)
100002d8b: 48 8d 7d 90                 	leaq	-112(%rbp), %rdi
100002d8f: e8 ac d0 01 00              	callq	0x10001fe40 <__ZN3std2io5stdio6_print17h3a964b8dccd58770E>

100002d94: 48 83 c4 50                 	addq	$80, %rsp
100002d98: 5b                          	popq	%rbx
100002d99: 41 5c                       	popq	%r12
100002d9b: 41 5e                       	popq	%r14
100002d9d: 41 5f                       	popq	%r15
100002d9f: 5d                          	popq	%rbp
100002da0: c3                          	retq
100002da1: 66 2e 0f 1f 84 00 00 00 00 00       	nopw	%cs:(%rax,%rax)
100002dab: 0f 1f 44 00 00              	nopl	(%rax,%rax)

[hookover]

总结给了我继续学习的信心

[pikacyxooo]

对这一句话有个疑问 “而特征对象在做的就是将 DST 类型转换为固定大小类型”
我理解是不是应该为 “特征对象是DST类型，然后用Box将特征对象由DST类型变为固定大小”，实际上还是使用场景中的第三点。

[tengfei-xy]

“将arr所有权转移arr1，由于 arr 分配在栈上，因此这里实际上是直接重新深拷贝了一份数据”
这段话有个问题，这里是进行了深拷贝嘛？在https://course.rs/basic/ownership/ownership.html#克隆深拷贝 页面上说，“Rust 永远也不会自动创建数据的 “深拷贝””，以及“浅拷贝只发生在栈上”。

[tengfei-xy]

而且示例中的数组，实现了Copy特征，所以是浅拷贝吧

[Tonylp666]

数组是值类型的，自动实现了 clone 语义的，因此是深拷贝。

[YongxinCao12138]

fn main() {
    // 在栈上创建一个长度为1000的数组
    let arr = [0;1000];
    // 将arr所有权转移arr1，由于 `arr` 分配在栈上，因此这里实际上是直接重新深拷贝了一份数据
    let arr1 = arr;
    // arr 和 arr1 都拥有各自的栈上数组，因此不会报错
    println!("{:?}", arr.len());
    println!("{:?}", arr1.len());
}

请问，这里的arr和arr1不是在栈上么，所以ler arr1 = arr不是复制了一份指针给arr1应该是浅拷贝吧。

[linjinxing]

当栈上数据转移所有权时，实际上是把数据拷贝了一份，最终新旧变量各自拥有不同的数据，因此所有权并未转移。
而堆上则不然，底层数据并不会被拷贝，转移所有权仅仅是复制一份栈中的指针，再将新的指针赋予新的变量，然后让拥有旧指针的变量失效，最终完成了所有权的转移：

说反了吧？？？我问了chatgpt，也和我理解的一样：不正确。在 Rust 中，当栈上的数据转移所有权时，并不会发生数据的拷贝。相反，所有权会从一个变量转移到另一个变量，旧变量将被认为无效。这种所有权转移的过程称为"移动语义"。通过移动语义，Rust 确保在编译时避免了数据竞争和内存安全问题。

当将所有权转移到新变量时，旧变量将被标记为无效，以防止对同一数据的并发访问。这意味着只有一个变量拥有有效的所有权，因此不存在数据的重复拷贝。这种所有权转移机制使得 Rust 能够在编译时进行内存管理，而无需依赖垃圾回收或手动内存管理。

需要注意的是，对于堆上的数据，所有权转移时会发生实际的数据拷贝。这是因为堆上的数据由指针和数据组成，所有权转移会复制指针和数据。但是，这种拷贝是针对指针和数据的，而不是针对数据的内容。

因此，在 Rust 中，所有权的转移是一种高效的机制，它确保了内存安全和并发安全，而不需要额外的运行时开销。

[GotGyu]

最后一段话突然励志起来了哈哈哈

[LegendaryStark]

// 在栈上创建一个长度为1000的数组
let arr = [0;1000];
// 将arr所有权转移arr1，由于 `arr` 分配在栈上，因此这里实际上是直接重新深拷贝了一份数据
let arr1 = arr;

// arr 和 arr1 都拥有各自的栈上数组，因此不会报错
println!("{:?}", arr.len());
println!("{:?}", arr1.len());

这里为啥又所有权的转移

[Endermanbugzjfc]

这章写得确实有点奇怪，让作者休息会 😅

[Endermanbugzjfc]

使用 & 借用数组中的元素，否则会报所有权错误

正常来说 ”借用” borrow 应该是指转移所有权吧？ 作者写的越来越混淆，前面几章也是这样，希望可以改进！

[Lixuhuilll]

想问一下，Box解引用为什么可以转移Box对其内部持有的类型T的所有权，这是不是相当于将堆上的数据复制到栈上并释放了Box？