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 la manière dont la mémoire est divisée et utilisée par les différents 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 de texte (Code).
2. Segment de données.
3. Tas.
4. Empiler.

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

Parlons 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 de code machine compilées. 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 

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 lors de la compilation de ce programme. 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 

// 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. Permettant ainsi de les lire et d'y écrire pendant l'exécution du programme.

Exemple:

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

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

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, il s'agit de composants cruciaux pour travailler 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 

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

Le code explique comment les cadres de pile stockent les variables locales. De nouveaux cadres de pile sont créés par les appels de fonction et sont éliminés au retour des fonctions. Les instructions printf facilitent la visualisation des valeurs des variables locales de chaque fonction. Le flux d'exécution suit les appels et les retours des fonctions.

Conclusion

Les programmeurs C peuvent améliorer leurs techniques de codage et mieux comprendre comment leurs programmes interagissent avec la mémoire en maîtrisant ces concepts. Comprendre la disposition de la mémoire est une compétence essentielle dans votre boîte à outils de programmation, que vous souhaitiez optimiser les performances ou résoudre un problème complexe.

N'hésitez pas à suivre, commenter et applaudir. Bon codage !

Connectons-nous sur LinkedIn.