int[] myIntegers;
myIntegers = new int[100];

在上面的代码中，new int[100] 是在堆上生成数组吗？根据我通过 c# 在 CLR 上阅读的内容，答案是肯定的。但我不明白的是，数组内部的实际 int 会发生什么。由于它们是值类型，我猜它们必须被装箱，例如，我可以将 myIntegers 传递给程序的其他部分，如果它们一直留在堆栈上，它会弄乱堆栈.还是我错了？我猜他们只是被装箱了，只要数组存在，它们就会一直在堆上。

最佳答案

你的数组是在堆上分配的，整数没有装箱。

你的困惑可能是因为人们说引用类型是在堆上分配的，而值类型是在堆栈上分配的。这不是一个完全准确的表示。

所有局部变量和参数都在堆栈上分配。这包括值类型和引用类型。两者的区别仅在于变量中存储的内容。不出所料，对于值类型，该类型的value直接存储在变量中，而对于引用类型，该类型的值存储在堆上，而一个reference 到这个值就是存储在变量中的内容。

字段也是如此。当为聚合类型(class 或 struct)的实例分配内存时，它必须包含每个实例字段的存储空间。对于引用类型字段，此存储仅保存对值的引用，该值本身稍后会在堆上分配。对于值类型字段，此存储保存实际值。

所以，给定以下类型:

class RefType{
    public int    I;
    public string S;
    public long   L;
}

struct ValType{
    public int    I;
    public string S;
    public long   L;
}

每种类型的值都需要 16 字节的内存(假设字长为 32 位)。在每种情况下，字段 I 占用 4 个字节来存储其值，字段 S 占用 4 个字节来存储其引用，字段 L需要 8 个字节来存储它的值。所以 RefType 和 ValType 的值的内存看起来像这样:

 0 ┌───────────────────┐
   │        I          │
 4 ├───────────────────┤
   │        S          │
 8 ├───────────────────┤
   │        L          │
   │                   │
16 └───────────────────┘

Now if you had three local variables in a function, of types RefType, ValType, and int[], like this:

RefType refType;
ValType valType;
int[]   intArray;

那么您的堆栈可能如下所示:

 0 ┌───────────────────┐
   │     refType       │
 4 ├───────────────────┤
   │     valType       │
   │                   │
   │                   │
   │                   │
20 ├───────────────────┤
   │     intArray      │
24 └───────────────────┘

If you assigned values to these local variables, like so:

refType = new RefType();
refType.I = 100;
refType.S = "refType.S";
refType.L = 0x0123456789ABCDEF;

valType = new ValType();
valType.I = 200;
valType.S = "valType.S";
valType.L = 0x0011223344556677;

intArray = new int[4];
intArray[0] = 300;
intArray[1] = 301;
intArray[2] = 302;
intArray[3] = 303;

那么你的堆栈可能看起来像这样:

 0 ┌───────────────────┐
   │    0x4A963B68     │ -- heap address of `refType`
 4 ├───────────────────┤
   │       200         │ -- value of `valType.I`
   │    0x4A984C10     │ -- heap address of `valType.S`
   │    0x44556677     │ -- low 32-bits of `valType.L`
   │    0x00112233     │ -- high 32-bits of `valType.L`
20 ├───────────────────┤
   │    0x4AA4C288     │ -- heap address of `intArray`
24 └───────────────────┘

地址 0x4A963B68 的内存(refType 的值)类似于:

 0 ┌───────────────────┐
   │       100         │ -- value of `refType.I`
 4 ├───────────────────┤
   │    0x4A984D88     │ -- heap address of `refType.S`
 8 ├───────────────────┤
   │    0x89ABCDEF     │ -- low 32-bits of `refType.L`
   │    0x01234567     │ -- high 32-bits of `refType.L`
16 └───────────────────┘

地址 0x4AA4C288 的内存(intArray 的值)类似于:

 0 ┌───────────────────┐
   │        4          │ -- length of array
 4 ├───────────────────┤
   │       300         │ -- `intArray[0]`
 8 ├───────────────────┤
   │       301         │ -- `intArray[1]`
12 ├───────────────────┤
   │       302         │ -- `intArray[2]`
16 ├───────────────────┤
   │       303         │ -- `intArray[3]`
20 └───────────────────┘

现在，如果您将 intArray 传递给另一个函数，则压入堆栈的值将是 0x4AA4C288，数组的地址，不是 数组的副本。

关于c# - 数组、堆和栈以及值类型，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1113819/