Wie werden Arrays und Werttypen auf dem Stack und Heap in C# zugewiesen?

Array-Zuordnung und Werttypen auf Stack vs. Heap

In Ihrem Code-Snippet:

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

wenn Sie Wenn Sie das Array myIntegers mit dem Schlüsselwort new erstellen, wird das Array selbst auf dem Heap zugewiesen, wie von der CLR vorgeschlagen. Allerdings sind die ganzzahligen Elemente innerhalb des Arrays, da es sich um Werttypen handelt, nicht eingerahmt.

Stapel- und lokale Variablen

Alle lokalen Variablen in einer Funktion, einschließlich Werttypen und Referenztypen werden auf dem Stapel zugewiesen. Der Unterschied zwischen den beiden liegt darin, was in diesen Variablen gespeichert ist.

• Werttypen speichern den tatsächlichen Wert direkt in der Variablen.
• Referenztypen speichern eine Referenz auf den Wert auf der Heap, und die Variable selbst enthält die Adresse dieser Referenz.

Beispiel für RefTypes und ValTypes

Berücksichtigen Sie die folgenden Typen:

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

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

Der Wert jedes Typs erfordert 16 Byte Speicher: 4 Byte für I, 4 Byte für die S-Referenz (oder die tatsächliche). S-Zeichenfolge für ValType) und 8 Bytes für L.

Wenn Sie lokale Variablen vom Typ RefType, ValType und haben int[] würden sie wie folgt auf dem Stapel zugewiesen:

Stack:

0-3 bytes: RefType variable
4-7 bytes: ValType variable
8-11 bytes: int[] variable

Speicherlayout

Beim Zuweisen von Werten zu diesen Variablen:

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;

Die Werte werden im Folgenden verteilt Art und Weise:

Stack:

0-3 bytes: Heap address of `refType`
4-7 bytes: Value of `valType.I`
8-11 bytes: Heap address of `valType.S`
12-15 bytes: Low 32-bits of `valType.L`
16-19 bytes: High 32-bits of `valType.L`
20-23 bytes: Heap address of `intArray`

Heap:

• An der Heap-Adresse von refType:

  • 0-3 Bytes: Wert von refType.I
  • 4-7 Bytes: Heap-Adresse von refType.S
  • 8-11 Bytes: Niedrige 32 Bits von refType.L
  • 12-15 Bytes: Hohe 32 Bits von refType.L

• Auf dem Heap von intArray Adresse:

  • 0-3 Bytes: Länge des Arrays (4)
  • 4-7 Bytes: Wert von intArray[0] (300)
  • 8 -11 Bytes: Wert von intArray[1] (301)
  • 12-15 Bytes: Wert von intArray[2] (302)
  • 16-19 Bytes: Wert von intArray[3] (303)

**Passing Arrays**

Das obige ist der detaillierte Inhalt vonWie werden Arrays und Werttypen auf dem Stack und Heap in C# zugewiesen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!