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 

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 konvertiert den Quellcode in Maschinencode, wenn dieses Programm kompiliert wird. 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 das Textsegment 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 schreibgeschützt.

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 hingegen fallen unter den Abschnitt schreibgeschützt.

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

#include 

// 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-/Schreibabschnitten und den schreibgeschützten Abschnitten 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 

// 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 
#include 

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

    return 0;
    }

Dieses Code-Snippet demonstriert eine einfache Verwendung der dynamischen Speicherzuweisung in C. Es macht auf die Schritte aufmerksam, die zum Anfordern von Speicher, zum Initialisieren eines Zeigers auf diesen Speicher und zur ordnungsgemäßen Verwaltung des Speichers zur Vermeidung von Lecks erforderlich sind. Obwohl Fehlerbehandlung und Speicherfreigabe in diesem Beispiel nicht berücksichtigt werden, sind dies entscheidende Komponenten für die Arbeit mit dynamischem Speicher in praktischen Anwendungen.

Stapel

Die Hauptfunktion der Stapelsegmente 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 

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;
}

Der Code erklärt, wie Stack-Frames lokale Variablen speichern. Durch die Funktionsaufrufe werden neue Stapelrahmen erstellt und gelöscht, wenn die Funktionen zurückkehren. Die printf-Anweisungen erleichtern die Visualisierung der lokalen Variablenwerte jeder Funktion. Der Ausführungsablauf folgt den Aufrufen und Rückgaben von Funktionen.

Abschluss

C-Programmierer können ihre Codierungstechniken verbessern und ein besseres Verständnis dafür erlangen, wie ihre Programme mit dem Gedächtnis interagieren, indem sie diese Konzepte beherrschen. Das Verständnis des Speicherlayouts ist eine wichtige Fähigkeit in Ihrem Programmier-Werkzeugkasten, unabhängig davon, ob Sie die Leistung optimieren oder ein komplexes Problem beheben.

Fühlen Sie sich frei, uns zu folgen, zu kommentieren und zu klatschen. Viel Spaß beim Codieren!

Vernetzen wir uns auf LinkedIn.