在结构上使用“new”是否在堆或堆栈上分配它？-Java 学习之路

264

使用 new 运算符创建类的实例时，将在堆上分配内存 . 当您使用 new 运算符创建结构的实例时，在堆上还是堆栈上分配内存？

8 回答

4

我可能在这里遗漏了一些东西，但为什么我们关心分配呢？

值类型通过值传递;）因此不能在与定义它们的位置不同的范围内进行变异 . 为了能够改变值，你必须添加[ref]关键字 .

引用类型通过引用传递，可以进行变异 .

当然，不可变引用类型字符串是最受欢迎的字符串 .

数组布局/初始化：值类型 - >零内存[name，zip] [name，zip]引用类型 - >零内存 - > null [ref] [ref]

回复于 2024-05-01T19:31:14+08:00
4
好的，让我们看看我是否可以更清楚地说明这一点 .

首先，Ash是对的：问题不在于值类型变量的分配位置 . 那个's a different question - and one to which the answer isn'只是"on the stack" . 它比那更复杂（并且由于C＃2而变得更加复杂） . 我有一个article on the topic并会根据要求扩展它，但让我们只处理 new 运算符 .

其次，所有这些都取决于你所谈论的程度 . 我正在研究编译器对源代码的作用，就其创建的IL而言 . JIT编译器在优化相当多的“逻辑”分配方面做得很聪明 .

第三，我忽略了泛型，主要是因为我实际上并不知道答案，部分是因为它会使事情变得太复杂 .

最后，所有这些都只是当前的实现 . C＃规范没有详细说明 - 它实际上是一个实现细节 . 有些人认为托管代码开发人员真的不应该关心 . 我不确定我会走得那么远，但是值得设想一个世界，其实所有局部变量都存在于堆上 - 这仍然符合规范 .

new 运算符在值类型上有两种不同的情况：您可以调用无参数构造函数（例如 new Guid() ）或参数构造函数（例如 new Guid(someString) ） . 这些产生显着不同的IL . 要了解原因，需要比较C＃和CLI规范：根据C＃，所有值类型都有一个无参数构造函数 . 根据CLI规范，没有值类型具有无参数构造函数 . （有时候用反射来获取值类型的构造函数 - 你将找不到无参数的构造函数 . ）

C＃将"initialize a value with zeroes"视为构造函数是有道理的，因为它使语言保持一致 - 您可以将_982676视为始终调用构造函数 . 因为没有真正的代码可以调用，所以CLI有必要对它进行不同的思考 - 当然也没有类型特定的代码 .

在初始化之后，您还要对该值做些什么 . IL用于
```
Guid localVariable = new Guid(someString);
```
与用于的IL不同：
```
myInstanceOrStaticVariable = new Guid(someString);
```
另外，如果该值用作中间值，例如，方法调用的参数，事情再次略有不同 . 为了显示所有这些差异，这里显示了静态变量和实例变量之间的区别：IL在 stfld 和 stsfld 之间会有所不同，但这就是全部 .
```
using System;

public class Test
{
    static Guid field;

    static void Main() {}
    static void MethodTakingGuid(Guid guid) {}


    static void ParameterisedCtorAssignToField()
    {
        field = new Guid("");
    }

    static void ParameterisedCtorAssignToLocal()
    {
        Guid local = new Guid("");
        // Force the value to be used
        local.ToString();
    }

    static void ParameterisedCtorCallMethod()
    {
        MethodTakingGuid(new Guid(""));
    }

    static void ParameterlessCtorAssignToField()
    {
        field = new Guid();
    }

    static void ParameterlessCtorAssignToLocal()
    {
        Guid local = new Guid();
        // Force the value to be used
        local.ToString();
    }

    static void ParameterlessCtorCallMethod()
    {
        MethodTakingGuid(new Guid());
    }
}
```
这是类的IL，不包括不相关的位（例如nops）：
```
.class public auto ansi beforefieldinit Test extends [mscorlib]System.Object    
{
    // Removed Test's constructor, Main, and MethodTakingGuid.

    .method private hidebysig static void ParameterisedCtorAssignToField() cil managed
    {
        .maxstack 8
        L_0001: ldstr ""
        L_0006: newobj instance void [mscorlib]System.Guid::.ctor(string)
        L_000b: stsfld valuetype [mscorlib]System.Guid Test::field
        L_0010: ret     
    }

    .method private hidebysig static void ParameterisedCtorAssignToLocal() cil managed
    {
        .maxstack 2
        .locals init ([0] valuetype [mscorlib]System.Guid guid)    
        L_0001: ldloca.s guid    
        L_0003: ldstr ""    
        L_0008: call instance void [mscorlib]System.Guid::.ctor(string)    
        // Removed ToString() call
        L_001c: ret
    }

    .method private hidebysig static void ParameterisedCtorCallMethod() cil  managed    
    {   
        .maxstack 8
        L_0001: ldstr ""
        L_0006: newobj instance void [mscorlib]System.Guid::.ctor(string)
        L_000b: call void Test::MethodTakingGuid(valuetype [mscorlib]System.Guid)
        L_0011: ret     
    }

    .method private hidebysig static void ParameterlessCtorAssignToField() cil managed
    {
        .maxstack 8
        L_0001: ldsflda valuetype [mscorlib]System.Guid Test::field
        L_0006: initobj [mscorlib]System.Guid
        L_000c: ret 
    }

    .method private hidebysig static void ParameterlessCtorAssignToLocal() cil managed
    {
        .maxstack 1
        .locals init ([0] valuetype [mscorlib]System.Guid guid)
        L_0001: ldloca.s guid
        L_0003: initobj [mscorlib]System.Guid
        // Removed ToString() call
        L_0017: ret 
    }

    .method private hidebysig static void ParameterlessCtorCallMethod() cil managed
    {
        .maxstack 1
        .locals init ([0] valuetype [mscorlib]System.Guid guid)    
        L_0001: ldloca.s guid
        L_0003: initobj [mscorlib]System.Guid
        L_0009: ldloc.0 
        L_000a: call void Test::MethodTakingGuid(valuetype [mscorlib]System.Guid)
        L_0010: ret 
    }

    .field private static valuetype [mscorlib]System.Guid field
}
```
如您所见，有许多不同的指令用于调用构造函数：
- newobj ：在堆栈上分配值，调用参数化构造函数 . 用于中间值，例如用于赋值给字段或用作方法参数 .
- call instance ：使用已分配的存储位置（无论是否在堆栈中） . 这在上面的代码中用于分配局部变量 . 如果使用多个 new 调用为同一个局部变量分配了一个值，它只是在旧值的顶部初始化数据 - 它不会每次分配更多的堆栈空间 .
- initobj ：使用已分配的存储位置，只擦除数据 . 这用于我们所有的无参数构造函数调用，包括分配给局部变量的调用 . 对于方法调用，有效地引入了一个中间局部变量，并且其值被 initobj 擦除 .
我希望这能说明这个主题有多复杂，同时同时照亮它 . 在某些概念意义上，每次调用 new 都会在堆栈上分配空间 - 但正如我们在IL级别上真正发生的那样 . 我想强调一个特例 . 采取这种方法：
```
void HowManyStackAllocations()
{
    Guid guid = new Guid();
    // [...] Use guid
    guid = new Guid(someBytes);
    // [...] Use guid
    guid = new Guid(someString);
    // [...] Use guid
}
```
"logically"有4个堆栈分配 - 一个用于变量，一个用于三个 new 调用 - 但实际上（对于该特定代码）堆栈仅分配一次，然后重用相同的存储位置 .

编辑：只是要清楚，这在某些情况下才是正确的...特别是，如果 Guid 构造函数抛出异常， guid 的值将不可见，这就是C＃编译器能够重用相同堆栈的原因插槽 . 有关详细信息和不适用的情况，请参阅Eric Lippert的blog post on value type construction .

我在写这个答案时学到了很多 - 如果有任何不清楚的地方请请澄清！
回复于 2024-05-01T19:31:14+08:00
34

包含结构字段的内存可以在堆栈或堆上分配，具体取决于具体情况 . 如果struct-type变量是a局部变量或参数未被某些匿名委托或迭代器类捕获，然后它将在堆栈上分配 . 如果变量是某个类的一部分，那么它将在堆上的类中分配 .

如果在堆上分配结构，则实际上不需要调用new运算符来分配内存 . 唯一的目的是根据构造函数中的任何内容设置字段值 . 如果未调用构造函数，则所有字段都将获得其默认值（0或null） .

类似地，对于在堆栈上分配的结构，除了C＃要求所有局部变量在使用之前设置为某个值，因此您必须调用自定义构造函数或默认构造函数（不带参数的构造函数始终可用于结构） .

回复于 2024-05-01T19:31:14+08:00
1

简单地说，new是结构的误称，调用new只是调用构造函数 . 结构的唯一存储位置是它定义的位置 .

如果它是一个成员变量，它将直接存储在它定义的任何内容中，如果它是局部变量或参数，则它存储在堆栈中 .

将其与类对比，这些类在结构完整存储的任何地方都有引用，而引用指向堆上的某处 . （堆栈中的本地/参数）

可能有助于查看C，其中class / struct之间没有真正的区别 . （语言中有类似的名称，但它们仅指代事物的默认可访问性）当您调用new时，您将获得指向堆位置的指针，而如果您有非指针引用，则它将直接存储在堆栈上或在另一个对象中，ala结构在C＃中 .

回复于 2024-05-01T19:31:14+08:00
10

与所有值类型一样，结构总是位于声明它们的位置 .

有关何时使用结构的更多详细信息，请参阅此问题here . 关于结构的更多信息，这个问题here .

Edit: 我mistankely回答他们总是进入堆叠 . 这是incorrect .

回复于 2024-05-01T19:31:14+08:00
291

class 或 struct 声明就像一个蓝图，用于在运行时创建实例或对象 . 如果定义名为 class 或 struct 的Person，则Person是该类型的名称 . 如果声明并初始化Person类型的变量p，则p被称为Person的对象或实例 . 可以创建相同Person类型的多个实例，并且每个实例在其 properties 和 fields 中可以具有不同的值 .

class 是引用类型 . 创建 class 的对象时，为其分配对象的变量仅保留对该内存的引用 . 将对象引用分配给新变量时，新变量引用原始对象 . 通过一个变量进行的更改会反映在另一个变量中，因为它们都引用相同的数据 .

struct 是值类型 . 创建 struct 时，分配 struct 的变量保存结构的实际数据 . 将 struct 分配给新变量时，将复制该变量 . 因此，新变量和原始变量包含相同数据的两个单独副本 . 对一个副本所做的更改不会影响另一个副本 .

通常， classes 用于建模更复杂的行为，或者在创建 class 对象后要修改的数据 . Structs 最适合于主要包含在创建 struct 之后不打算修改的数据的小型数据结构 .

for more...

回复于 2024-05-01T19:31:14+08:00
1

几乎被认为是值类型的结构在堆栈上分配，而对象在堆上分配，而对象引用（指针）在堆栈上分配 .

回复于 2024-05-01T19:31:14+08:00
2

结构被分配到堆栈 . 这是一个有用的解释：

Structs

此外，在.NET中实例化的类会在堆上分配内存或.NET的保留内存空间 . 而由于堆栈上的分配，结构化在实例化时产生更高的效率 . 此外，应该注意，在结构内传递参数是通过值来完成的 .

回复于 2024-05-01T19:31:14+08:00

在结构上使用“new”是否在堆或堆栈上分配它？

8 回答

相关问题