Rust 我是否需要装箱结构的子结构来获取堆上的所有内容？

我不明白在Rust中，当我们

Box

父结构时，结构中的结构会发生什么

struct Outer1 {
    child: Inner1,
}

struct Inner1 {
    n: i32,
}

struct Outer2 {
    child: Box<Inner2>,
}

struct Inner2 {
    n: Box<i32>,
}

pub fn main() {
    let x1 = Box::new(Outer1 {
        child: Inner1 { n: 1 },
    });
    let x2 = Box::new(Outer2 {
        child: Box::new(Inner2 { n: Box::new(1) }),
    });
}

struct Outer1{
孩子：1，
}
结构Inner1{
n:i32，
}
结构外部2{
孩子：盒子，
}
结构Inner2{
n:盒子，
}
pub fn main（）{
设x1=Box:：new（Outer1{
子：Inner1{n:1}，
});
设x2=Box:：新建（Outer2）{
子：Box:：new（Inner2{n:Box:：new（1）}），
});
}

x2.child

和

x2.child.n

应该在堆上，对吗？其中是

x1.child

和

x1.child.n

：堆栈还是堆

如果

child.n

的类型是

String

，

n

应该是一个引用，

String

不需要

框

就可以在堆上？这是正确的吗

我是否需要装箱结构的子结构来获取堆上的所有内容

否。当您框选一个值时，即框选整个值，即所有成员值。由于该值的每个成员都在框中，所以所有内容都在堆中

如果我做内拳击会怎么样？它指向不同的记忆吗

对。堆栈上的变量将指向堆中的数据，然后这些数据将指向堆中的不同数据

+------------++----------+
|堆栈| |堆|
+-----------+         +----------+
|           +--------->          +------+
|           |         |          |      |
|           |         |          |      |
|           |         |          |      |
+-----------+         |          |      |
|   .....   |         +----------+      |
+-----------+         |   ....   |      |
|           |         +----------+      |
|           |         |          |      |
|           |         |          
我是否需要装箱结构的子结构来获取堆上的所有内容

否。当您框选一个值时，即框选整个值，即所有成员值。由于该值的每个成员都在框中，所以所有内容都在堆中

如果我做内拳击会怎么样？它指向不同的记忆吗

对。堆栈上的变量将指向堆中的数据，然后这些数据将指向堆中的不同数据

+------------++----------+
|堆栈| |堆|
+-----------+         +----------+
|           +--------->          +------+
|           |         |          |      |
|           |         |          |      |
|           |         |          |      |
+-----------+         |          |      |
|   .....   |         +----------+      |
+-----------+         |   ....   |      |
|           |         +----------+      |
|           |         |          |      |
|| |想象每种类型（
Outer1
，
Inner1
，
i32
）都有一种颜色，并且
内存插槽由一个或多个堆叠/嵌入的彩色字节帧组成

struct Outer1 {
    child: Inner1,
}

struct Inner1 {
    n: i32,
}

let x1 = Box::new(Outer1 {
    child: Inner1 { n: 1 },
});

具有以下布局：


struct Outer2{
孩子：盒子，
}
结构Inner2{
n:盒子，
}
设x2=Box:：新建（Outer2）{
子：Box:：new（Inner2{n:Box:：new（1）}），
});

具有以下布局：


每个
框
启动一个新的彩色边框

显然，内存不是有色的：这是一个可能有助于表示的概念：真正存在的只是字节，最终由于内存对齐而造成一些空间浪费

下面是包含字符串属性的结构的内存布局


A由三个组件组成：指向缓冲区的指针、长度和容量（在本例中它们位于堆栈上）以及始终存储在堆上的缓冲区

注意：上面的示例指针大小与64位体系结构有关。
想象每种类型（
Outer1
，
Inner1
，
i32
）都有一种颜色，并且
内存插槽由一个或多个堆叠/嵌入的彩色字节帧组成

struct Outer1 {
    child: Inner1,
}

struct Inner1 {
    n: i32,
}

let x1 = Box::new(Outer1 {
    child: Inner1 { n: 1 },
});

具有以下布局：


struct Outer2{
孩子：盒子，
}
结构Inner2{
n:盒子，
}
设x2=Box:：新建（Outer2）{
子：Box:：new（Inner2{n:Box:：new（1）}），
});

具有以下布局：


每个
框
启动一个新的彩色边框

显然，内存不是有色的：这是一个可能有助于表示的概念：真正存在的只是字节，最终由于内存对齐而造成一些空间浪费

下面是包含字符串属性的结构的内存布局


A由三个组件组成：指向缓冲区的指针、长度和容量（在本例中它们位于堆栈上）以及始终存储在堆上的缓冲区

注意：上面的示例指针大小与64位体系结构有关。
子结构是内联存储的，因此不需要嵌套框。子结构是内联存储的，因此不需要嵌套框。如果我进行内部装箱，会发生什么？它指向不同的记忆吗？还是被编译器删除？@Markys每次创建一个框时，都会在堆上分配一个新的内存段，因此内部框指向不同的内存。创建一个盒子不仅仅是关于某个东西是否存储在堆栈的堆上，因此编译器不能简单地决定将您请求存储在盒子中的东西内联存储，至少在一般情况下不是这样，因为行为明显不同。如果我做内部装箱，会发生什么？它指向不同的记忆吗？还是被编译器删除？@Markys每次创建一个框时，都会在堆上分配一个新的内存段，因此内部框指向不同的内存。创建一个盒子不仅仅是关于某个东西是否存储在堆栈的堆上，因此编译器不能简单地决定将您请求存储在盒子中的东西内联存储，至少在一般情况下不是这样，因为行为明显不同。