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，进一步下降

[idlercloud]

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语句不加分号也能过编译

[idlercloud]

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]

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

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

[Hoteryoung]

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

[ddx533534]

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

[Lixuhuilll]

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

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

[yasyx]

在 Rust 中，Box::new([0; 100000000000]) 和 vec![0u8; 100000000000].into_boxed_slice(); 这两行代码都试图在堆上分配大量的内存，但是它们的行为和错误信息不同，原因如下：

Box::new([0; 100000000000]) 这行代码尝试创建一个装箱的数组，这个数组的大小是非常大的（100万亿个元素）。当你尝试在栈上分配这么大的数据时，会导致栈溢出，因为栈的大小通常是有限的，远小于100万亿字节。这就是为什么你看到了 "thread 'main' has overflowed its stack" 的错误信息。这个错误并不是说数组一开始分配在栈上，而是你尝试在栈上创建了一个过大的数据结构，这超出了栈的容量限制。

vec![0u8; 100000000000].into_boxed_slice(); 这行代码首先创建一个非常大的 Vec，然后将其转换为一个装箱的切片 Box<[u8]>。Vec 总是在堆上分配的，因为它需要动态地管理内存。当你尝试分配100万亿个字节时，这远远超出了大多数系统能够分配的内存量，因此你会看到 "memory allocation of 100000000000 bytes failed" 的错误信息。这个错误表明内存分配失败，而不是说内存分配一开始是在栈上进行的。

在 Rust 中，堆分配是通过全局分配器进行的，而栈分配是由线程的栈空间提供的。当你创建一个 Vec 或者使用 Box 时，你通常是在请求堆内存。栈溢出错误通常发生在你尝试在栈上创建过大的数据结构时，而内存分配失败错误则发生在你请求的堆内存超出了系统能够提供的量时。

总结来说，这两行代码都试图在堆上分配内存，但是由于请求的内存量过大，导致了不同的错误。第一行代码的错误是因为尝试在栈上创建了一个过大的数据结构，而第二行代码的错误是因为请求的堆内存超出了系统的限制。

[hhhxiao]

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

[jingth]

怎么没有习题了？

[FlorentinoJink]

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

[Almagestum469]

生命周期和程序一样长

[ttxs25830]

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

[duanyuluo]

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

[17998384]

一个进程申请的资源一定会在该进程死亡以后全部回收

[popping001]

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 本来就是堆分配

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

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

[enomothem]

加油

[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应该是浅拷贝吧。

[leaf-potato]

不是，数据是赋值是深拷贝的。如果是浅拷贝，会转移所有权，那么println!("{:?}", arr.len());会编译失败。

[leaf-potato]

数组赋值是深拷贝，打错字了...

[linjinxing]

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

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

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

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

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

[GotGyu]

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

[enomothem]

rust!

[LegendaryStark]

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

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

这里为啥又所有权的转移

[Endermanbugzjfc]

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

[woxin123]

我看不下去了，好混乱，这明显不是累不累的问题，在这瞎写。

[Lixuhuilll]

作者这里把 '=' 叫做所有权转移。
叫什么其实根本没什么影响，你只要知道栈上只会复制，堆上才会真的发生所有权转移就行。
类似的行为其实大多数编程语言都是相通的，只是rust里面有时候称呼会比较奇怪。

[woxin123]

什么叫做叫什么没影响。

先来看一段代码：

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

整个过程中的赋值都是通过值拷贝的方式完成(发生在栈中)，因此并不需要所有权转移。

这是所有权章节的内容。

还有什么叫做没有影响，你把猫叫做狗，没影响吗？我知道是我知道，但是这样的错误很影响阅读的，错误多了，容易对前面自己学的产生怀疑。

[enomothem]

是的，如果使用的 let vec = vec![0; 1000]; 可以称之为转移， 数组[] 实现了Copy trait， 而 vector动态数组没有实现，所以会转移所有权。

[Endermanbugzjfc]

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

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

[enomothem]

借用是借用，转移所有权是Move，这是两个概念，回去看看基础吧哥们

[Lixuhuilll]

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

[poshitou]

解引用是获取Box智能指针结构体中指针所指向的内存地址对应的内存中存储的值

[yanyunwu]

作者帅！

[enomothem]

+1

[marxlee]

最后一句话，使我学习rust的动力

[woxin123]

当栈上数据转移所有权时，实际上是把数据拷贝了一份，最终新旧变量各自拥有不同的数据，因此所有权并未转移。
这里我怎么看不懂，既然是拷贝了一份，为什么又说所有权转移，既然是拷贝的，那么所有权理应没有转移才对。

[enomothem]

是的，深拷贝，并不是转移所有权。
实现Copy Trait（例如整数、浮点数、字符、布尔值等基本类型和固定大小数组） -> 深度拷贝
没有实现Copy Trait （String、Vec、Box等动态分配内存的类型，在栈上只留了指向堆的指针）-> Move 移动所有权

[Hello-world150]

好像懂了:-)