Speicherlayout in C

Einführung

Speicherlayout bezieht sich darauf, wie der Speicher eines Computers organisiert und strukturiert ist. Es definiert, wie der Speicher von verschiedenen Systemkomponenten aufgeteilt und genutzt wird.

Dies ist in C von entscheidender Bedeutung, da es sich direkt darauf auswirkt, wie Variablen, Funktionen und Datenstrukturen während der Ausführung gespeichert und darauf zugegriffen werden.

In diesem Artikel lernen wir die grundlegenden Aspekte des Speicherlayouts im C kennen.

Segmente im Speicherlayout von C

Das Speicherlayout in C besteht aus verschiedenen Segmenten, unten sind die Segmente aufgeführt;

1. Text(Code)-Segment.
2. Datensegment.
3. Haufen.
4. Stapel.

Das Diagramm unten zeigt das Speicherlayout von C.

Lassen Sie uns nun die Segmente im Detail besprechen.

Text(code)-Segment

Das Textsegment ist ein Speicherbereich in einem C-Programm, der die kompilierten Maschinencodeanweisungen speichert. Diese Anweisungen stellen die ausführbare Logik des Programms dar und sind für die Definition seines Verhaltens verantwortlich.

Hier ist ein einfaches Beispiel, um das Konzept des Textsegments in einem C-Programm zu veranschaulichen:

#include <stdio.h>

int main() {
    int x = 5;
    int y = 10;
    int sum;

    sum = x + y;
    printf("The sum of %d and %d is %d\n", x, y, sum);

    return 0;
}

Der Compiler wandelt den Quellcode beim Kompilieren dieses Programms in Maschinencode um. Dieser Maschinencode stellt die Logik und das Verhalten eines Programms dar und wird im Textsegment gespeichert.

Während wir den Maschinencode nicht direkt sehen können. Wir können verstehen, dass der Textabschnitt die kompilierten Anweisungen enthält.

Im Wesentlichen enthält das Textsegment Anweisungen, die definieren, wie sich das Programm verhält, wenn es ausgeführt wird.

Datensegment

Das Datensegment ist in zwei Teile unterteilt:

• Initialisiertes Datensegment
• nicht initialisiertes Datensegment

Initialisiertes Datensegment

Das initialisierte Datensegment besteht aus globalen, externen, statischen (sowohl lokalen als auch globalen) und konstanten globalen Variablen, die zuvor initialisiert wurden. Das initialisierte Datensegment besteht aus zwei Abschnitten, den Abschnitten schreibgeschützt und Lese-/Schreibzugriff.

Variablen mit vordefinierten Werten, die geändert werden können, d. h. initialisierte globale, externe und statische (sowohl lokale als auch globale) Variablen, werden im Abschnitt Lese-/Schreibzugriff gespeichert. Konstante Variablen fallen hingegen unter den Abschnitt schreibgeschützt.

Hier ist ein Beispiel, das Variablen veranschaulicht, die im initialisierten Datensegment gespeichert sind, sowohl im Lese-/Schreib- als auch im schreibgeschützten Abschnitt:

#include <stdio.h>

// Global variable (read-write section)
int globalVar = 10;

// External variable declaration (read-write section)
extern int externVar;

// Static global variable (read-write section)
static int staticGlobalVar = 20;

// Constant global variable (read-only section)
const int constGlobalVar = 30;

int main() {
    globalVar += 5;
    staticGlobalVar += 10;

    printf("Global variable: %d\n", globalVar);
    printf("Extern variable: %d\n", externVar);  // Assuming externVar is defined in another file
    printf("Static global variable: %d\n", staticGlobalVar);
    printf("Constant global variable: %d\n", constGlobalVar);

    return 0;
}

Dies veranschaulicht Variablen, die in den Lese-/Schreib- und Leseabschnitten des initialisierten Datensegments gespeichert sind.

Nicht initialisiertes Datensegment

Das nicht initialisierte Datensegment, auch bekannt als BSS-Segment (Block gestartet durch Symbol), besteht aus nicht initialisierten globalen, externen und statischen (sowohl lokalen als auch globalen) Variablen.

Diese Variablen werden vor der Ausführung des Programms standardmäßig auf Null initialisiert. Sie verfügen über Lese-/Schreibberechtigungen. Dadurch können sie während der Programmausführung sowohl gelesen als auch beschrieben werden.

Beispiel:

#include <stdio.h>

// Uninitialized global variable (goes to the BSS segment)
int globalVar;

// Uninitialized static global variable (also goes to the BSS segment)
static int staticGlobalVar;

int main() {
    // Uninitialized local static variable (goes to the BSS segment)
    static int staticLocalVar;

    printf("Uninitialized Global Variable: %d\n", globalVar);
    printf("Uninitialized Static Global Variable: %d\n", staticGlobalVar);
    printf("Uninitialized Static Local Variable: %d\n", staticLocalVar);
    return 0;
}

In diesem Programm enthalten die nicht initialisierten Variablen standardmäßig Null- oder Nullwerte. Dies liegt an der automatischen Initialisierung durch den Compiler. Dies zeigt das Verhalten der im BSS-Segment gespeicherten Variablen.

Haufen

Der Heap ist ein Speicherbereich, der zur dynamischen Speicherzuweisung während der Laufzeit verwendet wird. Dies ermöglicht die Zuweisung und Freigabe von Speicher nach Bedarf während der Programmausführung. Funktionen wie malloc(), calloc(), realloc() und free() werden für die Speicherzuweisung und -freigabe verwendet im Haufen. Der Heap ist für alle Teile des Programms zugänglich.

Beispiel:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Dynamically allocate memory for an integer variable on the heap
    int *ptr = (int *)malloc(sizeof(int));

    return 0;
    }

Dieser Codeausschnitt demonstriert eine einfache Verwendung der dynamischen Speicherzuweisung in C. Er macht auf die Schritte aufmerksam, die zum Anfordern von Speicher, zum Initialisieren eines Zeigers auf diesen Speicher und zum ordnungsgemäßen Verwalten des Speichers zur Vermeidung von Lecks erforderlich sind. Obwohl Fehlerbehandlung und Speicherfreigabe in diesem Beispiel nicht enthalten sind, sind dies entscheidende Komponenten für die Arbeit mit dynamischem Speicher in praktischen Anwendungen.

Stapel

Die Hauptfunktion der Stack-Segmente besteht darin, Funktionsaufrufe zu verwalten und lokale Variablen zu speichern. Dieser Teil ist für das Speicherlayout eines Programms von entscheidender Bedeutung, da er den Ablauf innerhalb eines Programms steuert. Der Stapel verwendet eine LIFO-Struktur (Last In, First Out), was bedeutet, dass die zuletzt hinzugefügten Daten zuerst entfernt werden. Dies macht den Stack sehr effizient für die Verwaltung lokaler Variablen und verschachtelter Funktionsaufrufe.

Beispiel:

#include <stdio.h>

void functionA(int n) {
    int a = n + 1; // Local variable
    printf("In functionA, a = %d\n", a);
}

void functionB() {
    int b = 10; // Local variable
    printf("In functionB, b = %d\n", b);
    functionA(b); // Call to functionA
}

int main() {
    int x = 20; // Local variable
    printf("In main, x = %d\n", x);
    functionB(); // Call to functionB
    return 0;
}

The code explains how stack frames store local variables. New stack frames are created by the function calls and are eliminated when the functions return. The printf instructions facilitate the visualization of each function's local variable values. The execution flow follows the calls to and returns from functions.

Conclusion

C programmers can improve their coding techniques and gain a better understanding of how their programs interact with memory by mastering these concepts. Understanding memory layout is a vital skill in your programming toolbox, whether you're optimizing for performance or troubleshooting a complex problem.

Feel free to follow, comment, and leave claps. Happy Coding!

Let’s connect on LinkedIn.

Das obige ist der detaillierte Inhalt vonSpeicherlayout in C. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!