Disposition de la mémoire en C

Introduction

La disposition de la mémoire fait référence à la manière dont la mémoire d'un ordinateur est organisée et structurée. Il définit comment la mémoire est divisée et utilisée par divers composants du système.

Ceci est crucial en C car cela a un impact direct sur la façon dont les variables, les fonctions et les structures de données sont stockées et accessibles pendant l'exécution.

Dans cet article, nous découvrirons les aspects fondamentaux de la disposition de la mémoire dans le C.

Segments dans la disposition de la mémoire C

La disposition de la mémoire en C se compose de différents segments, ci-dessous se trouvent les segments ;

1. Segment texte (Code).
2. Segment de données.
3. Tas.
4. Pile.

Le diagramme ci-dessous représente la disposition de la mémoire de C.

Discutons maintenant des segments en détail.

Segment de texte (code)

Le segment de texte est une région de mémoire dans un programme C qui stocke les instructions du code machine compilé. Ces instructions constituent la logique exécutable du programme et sont chargées de définir son comportement.

Voici un exemple simple pour illustrer le concept de segment de texte dans un programme C :

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

Le compilateur convertit le code source en code machine lorsque ce programme est compilé. Ce code machine constitue la logique et le comportement d'un programme et est stocké dans le segment de texte.

Bien que nous ne puissions pas voir directement le code machine. On peut comprendre que le segment de texte contient les instructions compilées.

Essentiellement, le segment de texte contient des instructions qui définissent le comportement du programme lorsqu'il est exécuté.

Segment de données

Le segment de données est divisé en deux parties :

• Segment de données initialisé
• segment de données non initialisé

Segment de données initialisé

Le segment de données initialisé se compose de variables globales globales, externes, statiques (à la fois locales et globales) et constantes initialisées au préalable. Le segment de données initialisé comporte deux sections, les sections lecture seule et lecture-écriture.

Les variables avec des valeurs prédéfinies qui peuvent être modifiées, c'est-à-dire les variables globales, externes et statiques initialisées (locales et globales) sont stockées dans la section lecture-écriture. Les variables constantes, quant à elles, relèvent de la section lecture seule.

Voici un exemple illustrant les variables stockées dans le segment de données initialisé, à la fois dans les sections en lecture-écriture et en lecture seule :

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

Cela illustre les variables stockées dans les sections en lecture-écriture et en lecture seule du segment de données initialisé.

Segment de données non initialisé

Le segment de données non initialisé, également connu sous le nom de segment BSS (bloc démarré par symbole), se compose de variables globales, externes et statiques non initialisées (locales et globales).

Ces variables sont initialisées à zéro par défaut avant l'exécution du programme. Ils disposent d'autorisations de lecture-écriture. Leur permettant ainsi d'être à la fois lus et écrits pendant l'exécution du programme.

Exemple :

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

Dans ce programme, les variables non initialisées contiendront des valeurs nulles ou nulles par défaut. Cela est dû à l'initialisation automatique par le compilateur. Ceci montre le comportement des variables stockées dans le segment BSS.

Tas

Le tas est une région de mémoire utilisée pour l'allocation dynamique de mémoire pendant l'exécution. Cela permet à la mémoire d'être allouée et libérée selon les besoins pendant l'exécution du programme. Des fonctions telles que malloc(), calloc(), realloc() et free() sont utilisées pour l'allocation et la désallocation de mémoire dans le tas. Le tas est accessible à toutes les parties du programme.

Exemple :

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

Cet extrait de code démontre une utilisation simple de l'allocation dynamique de mémoire en C. Il attire l'attention sur les étapes impliquées dans la demande de mémoire, l'initialisation d'un pointeur vers cette mémoire et la gestion correcte de la mémoire pour éviter les fuites. Bien que la gestion des erreurs et la désallocation de mémoire ne soient pas incluses dans cet exemple, elles constituent des éléments cruciaux du travail avec la mémoire dynamique dans des applications pratiques.

Empiler

La fonction principale des segments de pile est de gérer les appels de fonction et de stocker les variables locales. Cette partie est cruciale dans la configuration de la mémoire d'un programme, car elle contrôle le flux au sein d'un programme. La pile adopte une structure Last In, First Out (LIFO), ce qui signifie que les données les plus récemment ajoutées sont supprimées en premier. Cela rend la pile très efficace pour gérer les variables locales et les appels de fonctions imbriquées.

Exemple :

#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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!