• Byte[]分配在哪里?


    http://stackoverflow.com/questions/1113819/arrays-heap-and-stack-and-value-types

    Your array is allocated on the heap, and the ints are not boxed.

    The source of your confusion is likely because people have said that reference types are allocated on the heap and value types are allocated on the stack. This is not an entirely accurate representation.

    All local variables and parameters are allocated on the stack. This includes both value types and reference types. The difference between the two is only what is stored in the variable. Unsurprisingly, for a value type, the value of the type is stored directly in the variable, and for a reference type, the value of the type is stored on the heap, and a reference to this value is what is stored in the variable.

    The same holds true for fields. When memory is allocated for an instance of an aggregate type (a class or a struct), it must include storage for each of its instance fields. For reference-type fields, this storage holds just a reference to the value, which would itself be allocated on the heap later. For value-type fields, this storage holds the actual value.

    So, given the following types:

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

    struct ValType{
    public int I;
    public string S;
    public long L;
    }
    The values of each of these types would require 16 bytes of memory (assuming a 32-bit word size). The field I in each case takes 4 bytes to store its value, the field S takes 4 bytes to store its reference, and the field L takes 8 bytes to store its value. So the memory for the value of both RefType and ValType looks like this:

    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;
    then your stack might look like this:

    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;
    Then your stack might look something like this:

    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 └───────────────────┘
    Memory at address 0x4A963B68 (value of refType) would be something like:

    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 └───────────────────┘
    Memory at address 0x4AA4C288 (value of intArray) would be something like:

    0 ┌───────────────────┐
    │ 4 │ -- length of array
    4 ├───────────────────┤
    │ 300 │ -- intArray[0]
    8 ├───────────────────┤
    │ 301 │ -- intArray[1]
    12 ├───────────────────┤
    │ 302 │ -- intArray[2]
    16 ├───────────────────┤
    │ 303 │ -- intArray[3]
    20 └───────────────────┘
    Now if you passed intArray to another function, the value pushed onto the stack would be 0x4AA4C288, the address of the array, not a copy of the array.

  • 相关阅读:
    20140630 科技脉搏-互联网精神之“我不是为了输赢,我就是认真”
    iOS 获取本地视频的缩略图
    iOS App与iTunes文件传输的方法和对iOS App文件结构的说明
    罗振宇自媒体品牌“罗辑思维”估值1亿背后:媒体通往社群之路
    20140622 科技脉搏 -互联网思维之“一群人团结起来占其他人便宜”
    20140616 科技脉搏 -最大颠覆来自创业公司与边缘产业
    关于流媒体(m3u8)的下载与播放
    20140608 科技脉搏 -下半身需求是人类共同需求,有多少人就有多大市场
    IOS遍历未知对象属性、函数
    iOS中使用 Reachability 检测网络
  • 原文地址:https://www.cnblogs.com/chucklu/p/4165824.html
Copyright © 2020-2023  润新知