En considérant que la mémoire est divisée en quatre segments: données, tas, pile et code, où font les variables globales, les variables statiques, les types de données constantes, les variables locales (définies et déclarées dans les fonctions), les variables (dans la fonction principale), les pointeurs , et l'espace alloué dynamiquement (en utilisant malloc et calloc) est stocké en mémoire?

Je pense qu'ils seraient répartis comme suit:

• Variables globales -------> données
• Variables statiques -------> données
• Types de données constantes -----> code
• Variables locales (déclarées et définies dans les fonctions) --------> pile
• Variables déclarées et définies dans la fonction principale -----> tas
• Pointeurs (par exemple char *arr, int *arr) -------> tas
• Espace alloué dynamiquement (en utilisant malloc et calloc) --------> stack

Je fais référence à ces variables uniquement du point de vue C.

Veuillez me corriger si je me trompe car je suis nouveau sur C.

Vous en avez raison, mais celui qui a écrit les questions vous a trompé sur au moins une question:

• variables globales -------> données (correctes)
• variables statiques -------> données (correctes)
• types de données constantes -----> code et / ou données. Considérez les littéraux de chaîne pour une situation où une constante elle-même serait stockée dans le segment de données et où les références à celle-ci seraient incorporées dans le code
• variables locales (déclarées et définies dans les fonctions) --------> stack (correct)
• les variables déclarées et définies dans la mainfonction -----> tas s'empilent également (l'enseignant essayait de vous tromper)
• pointeurs (ex: char *arr, int *arr) -------> tas données ou pile, en fonction du contexte. C vous permet de déclarer un global ou un staticpointeur, auquel cas le pointeur lui-même se retrouverait dans le segment de données.
• dynamiquement l' espace alloué ( en utilisant malloc, calloc, realloc) --------> pile tas

Il est à noter que «pile» est officiellement appelée «classe de stockage automatique».

Pour les futurs visiteurs qui pourraient être intéressés à connaître ces segments de mémoire, j'écris des points importants sur 5 segments de mémoire en C:

Quelques avertissements:

1. Chaque fois qu'un programme C est exécuté, de la mémoire est allouée dans la RAM pour l'exécution du programme. Cette mémoire est utilisée pour stocker le code fréquemment exécuté (données binaires), les variables de programme, etc. Les segments de mémoire ci-dessous en parlent:
2. Il existe généralement trois types de variables:
   • Variables locales (également appelées variables automatiques en C)
   • Variables globales
   • Variables statiques
   • Vous pouvez avoir des variables statiques globales ou statiques locales, mais les trois ci-dessus sont les types parents.

5 segments de mémoire en C:

1. Segment de code

• Le segment de code, également appelé segment de texte, est la zone de mémoire qui contient le code fréquemment exécuté.
• Le segment de code est souvent en lecture seule pour éviter le risque d'être remplacé par des bogues de programmation tels que le dépassement de tampon, etc.
• Le segment de code ne contient pas de variables de programme comme la variable locale ( également appelée variable automatique en C ), les variables globales, etc.
• Basé sur l'implémentation C, le segment de code peut également contenir des littéraux de chaîne en lecture seule. Par exemple, lorsque vous faites, la printf("Hello, world")chaîne "Hello, world" est créée dans le segment code / texte. Vous pouvez vérifier cela à l'aide de la sizecommande dans le système d'exploitation Linux.
• Lectures complémentaires

Segment de données

Le segment de données est divisé en deux parties ci-dessous et se trouve généralement en dessous de la zone de tas ou dans certaines implémentations au-dessus de la pile, mais le segment de données ne se trouve jamais entre le tas et la zone de pile.

2. Segment de données non initialisé

• Ce segment est également connu sous le nom de bss .
• C'est la partie de la mémoire qui contient:
  1. Variables globales non initialisées (y compris les variables de pointeur)
  2. Variables globales constantes non initialisées .
  3. Variables statiques locales non initialisées .
• Toute variable locale globale ou statique qui n'est pas initialisée sera stockée dans le segment de données non initialisé
• Par exemple: variable globale int globalVar;ou variable locale statiquestatic int localStatic; sera stockée dans le segment de données non initialisé.
• Si vous déclarez une variable globale et l'initialisez comme 0ouNULL alors elle irait toujours au segment de données non initialisé ou bss.
• Lectures complémentaires

3. Segment de données initialisé

• Ce segment stocke:
  1. Variables globales initialisées (y compris les variables de pointeur)
  2. Variables globales constantes initialisées .
  3. Variables statiques locales initialisées .
• Par exemple: une variable globale int globalVar = 1;ou une variable locale statique static int localStatic = 1;sera stockée dans un segment de données initialisé.
• Ce segment peut être davantage classé en zone de lecture seule initialisée et en zone de lecture-écriture initialisée . Les variables globales constantes initialisées iront dans la zone de lecture seule initialisée tandis que les variables dont les valeurs peuvent être modifiées à l'exécution iront dans la zone de lecture-écriture initialisée .
• La taille de ce segment est déterminée par la taille des valeurs dans le code source du programme et ne change pas au moment de l'exécution .
• Lectures complémentaires

4. Segment de pile

• Le segment de pile est utilisé pour stocker des variables créées à l'intérieur de fonctions (la fonction peut être une fonction principale ou une fonction définie par l'utilisateur ), une variable comme
  1. Variables locales de la fonction (y compris les variables de pointeur)
  2. Arguments passés à la fonction
  3. Adresse de retour
• Les variables stockées dans la pile seront supprimées dès la fin de l'exécution de la fonction.
• Lectures complémentaires

5. Segment de tas

• Ce segment doit prendre en charge l'allocation de mémoire dynamique. Si le programmeur veut allouer de la mémoire dynamique puis en C , il est fait en utilisant le malloc, callocourealloc des méthodes.
• Par exemple, lorsque int* prt = malloc(sizeof(int) * 2)huit octets seront alloués dans le tas et l'adresse mémoire de cet emplacement sera renvoyée et stockée dans la ptrvariable. leptr variable sera sur la pile ou sur le segment de données selon la façon dont elle est déclarée / utilisée.
• Lectures complémentaires

Correction de vos mauvaises phrases

constant data types ----->  code //wrong

variables constantes locales -----> pile

variable constante globale initialisée -----> segment de données

variable constante globale non initialisée -----> bss

variables declared and defined in main function  ----->  heap //wrong

variables déclarées et définies dans la fonction principale -----> pile

pointers(ex:char *arr,int *arr) ------->  heap //wrong

dynamically allocated space(using malloc,calloc) --------> stack //wrong

pointeurs (ex: char * arr, int * arr) -------> la taille de cette variable de pointeur sera dans la pile.

Considérez que vous allouez de la mémoire de n octets (en utilisant mallocou calloc) dynamiquement et que vous créez ensuite une variable de pointeur pour la pointer. Maintenant que les noctets de mémoire sont dans le tas et que la variable pointeur requiert 4 octets (si la machine 64 bits 8 octets) qui sera dans la pile pour stocker le pointeur de départ des noctets du bloc de mémoire.

Remarque: les variables de pointeur peuvent pointer la mémoire de n'importe quel segment.

int x = 10;
void func()
{
int a = 0;
int *p = &a: //Now its pointing the memory of stack
int *p2 = &x; //Now its pointing the memory of data segment
chat *name = "ashok" //Now its pointing the constant string literal 
                     //which is actually present in text segment.
char *name2 = malloc(10); //Now its pointing memory in heap
...
}

espace alloué dynamiquement (en utilisant malloc, calloc) --------> tas

Une architecture de bureau populaire divise la mémoire virtuelle d'un processus en plusieurs segments :

• Segment de texte: contient le code exécutable. Le pointeur d'instruction prend des valeurs dans cette plage.

• Segment de données: contient des variables globales (c'est-à-dire des objets avec liaison statique). Subdivisé en données en lecture seule (telles que les constantes de chaîne) et en données non initialisées ("BSS").

• Segment de pile: contient la mémoire dynamique du programme, c'est-à-dire le magasin libre ("tas") et les cadres de pile locale pour tous les threads. Traditionnellement, la pile C et le tas C se développaient dans le segment de pile à partir d'extrémités opposées, mais je crois que cette pratique a été abandonnée parce qu'elle est trop dangereuse.

Le programme AC place généralement des objets avec une durée de stockage statique dans le segment de données, des objets alloués dynamiquement sur le magasin gratuit et des objets automatiques sur la pile d'appels du thread dans lequel il vit.

Sur d'autres plates-formes, comme l'ancien mode réel x86 ou sur les appareils embarqués, les choses peuvent évidemment être radicalement différentes.

Je fais référence à ces variables uniquement du point de vue C.

Du point de vue du langage C , tout ce qui compte, c'est l'étendue, la portée, le lien et l'accès; La façon exacte dont les éléments sont mappés sur différents segments de mémoire dépend de l'implémentation individuelle, et cela varie. La norme linguistique ne parle pas de segments de mémoire du tout . La plupart des architectures modernes agissent essentiellement de la même manière; les variables de portée de bloc et les arguments de fonction seront alloués à partir de la pile, les variables de portée de fichier et statiques seront allouées à partir d'un segment de données ou de code, la mémoire dynamique sera allouée à partir d'un tas, certaines données constantes seront stockées dans des segments en lecture seule , etc.

Une chose à garder à l'esprit à propos du stockage est la règle du « comme si » . Le compilateur n'est pas obligé de placer une variable à un endroit spécifique - au lieu de cela, il peut la placer où bon lui semble aussi longtemps que le programme compilé se comporte comme s'il était exécuté dans la machine abstraite C selon les règles de la machine abstraite C. Cela s'applique à toutes les durées de stockage . Par exemple:

• une variable qui n'est pas accessible à tous peut être complètement éliminée - elle n'a pas de stockage ... n'importe où. Exemple - voyez comment il y a 42dans le code d'assemblage généré mais aucun signe de404 .
• une variable avec une durée de stockage automatique dont l'adresse n'est pas prise n'a pas du tout besoin d'être stockée en mémoire. Un exemple serait une variable de boucle.
• une variable qui est constou constn'a pas besoin d'être en mémoire. Exemple - le compilateur peut prouver que fooc'est effectivement le cas constet intègre son utilisation dans le code. bara un lien externe et le compilateur ne peut pas prouver qu'il ne serait pas modifié en dehors du module actuel, il n'est donc pas en ligne.
• un objet alloué avec mallocn'a pas besoin de résider dans la mémoire allouée à partir du tas! Exemple - remarquez que le code n'a pas d'appel à mallocet que la valeur 42 n'est jamais stockée en mémoire, elle est conservée dans un registre!
• donc un objet qui a été alloué par mallocet la référence est perdue sans désallouer l'objet avec free besoin de ne pas fuir de mémoire ...
• l'objet alloué par mallocn'a pas besoin d'être dans le tas sous le programme break ( sbrk(0)) sous Unixen ...

pointeurs (ex: char * arr, int * arr) -------> tas

Non, ils peuvent être sur la pile ou dans le segment de données. Ils peuvent pointer n'importe où.

• Variables / variables automatiques ---> section stack
• Variables allouées dynamiquement ---> section de tas
• Variables globales initialisées -> section données
• Variables globales non initialisées -> section data (bss)
• Variables statiques -> section données
• Constantes de chaîne -> section de texte / section de code
• Fonctions -> section de texte / section de code
• Code de texte -> section de texte / section de code
• Registres -> registres CPU
• Entrées de ligne de commande -> section environnement / ligne de commande
• Variables d'environnement -> section environnement / ligne de commande

Exemples exécutables minimaux Linux avec analyse de désassemblage

Puisqu'il s'agit d'un détail d'implémentation non spécifié par les normes, jetons simplement un coup d'œil à ce que le compilateur fait sur une implémentation particulière.

Dans cette réponse, je vais soit créer un lien vers des réponses spécifiques qui font l'analyse, soit fournir l'analyse directement ici, et résumer tous les résultats ici.

Tous ces éléments sont dans différentes versions d'Ubuntu / GCC, et les résultats sont probablement assez stables d'une version à l'autre, mais si nous trouvons des variantes, spécifions des versions plus précises.

Variable locale à l'intérieur d'une fonction

Que ce mainsoit ou toute autre fonction:

void f(void) {
    int my_local_var;
}

Comme indiqué à: Que signifie <value optimized out> dans gdb?

• -O0: pile
• -O3: enregistre s'ils ne débordent pas, empilez autrement

Pour savoir pourquoi la pile existe, voir: Quelle est la fonction des instructions push / pop utilisées sur les registres dans l'assemblage x86?

Variables globales et staticvariables de fonction

/* BSS */
int my_global_implicit;
int my_global_implicit_explicit_0 = 0;

/* DATA */
int my_global_implicit_explicit_1 = 1;

void f(void) {
    /* BSS */
    static int my_static_local_var_implicit;
    static int my_static_local_var_explicit_0 = 0;

    /* DATA */
    static int my_static_local_var_explicit_1 = 1;
}

• s'il est initialisé 0ou non initialisé (et donc implicitement initialisé à 0): .bsssection, voir aussi: Pourquoi le segment .bss est-il requis?
• sinon: .datasection

char * et char c[]

Comme indiqué à: Où les variables statiques sont-elles stockées en C et C ++?

void f(void) {
    /* RODATA / TEXT */
    char *a = "abc";

    /* Stack. */
    char b[] = "abc";
    char c[] = {'a', 'b', 'c', '\0'};
}

TODO est-ce que de très gros littéraux de chaîne seront également mis sur la pile? Ou .data? Ou la compilation échoue-t-elle?

Arguments de fonction

void f(int i, int j);

Doit passer par la convention d'appel appropriée, par exemple: https://en.wikipedia.org/wiki/X86_calling_conventions pour X86, qui spécifie soit des registres spécifiques, soit des emplacements de pile pour chaque variable.

Ensuite, comme indiqué à Que signifie <valeur optimisée sortie> dans gdb? , -O0puis insère tout dans la pile, tout en -O3essayant d'utiliser les registres autant que possible.

Cependant, si la fonction est intégrée, ils sont traités comme des locaux ordinaires.

const

Je pense que cela ne fait aucune différence car vous pouvez le typer.

Inversement, si le compilateur est capable de déterminer que certaines données ne sont jamais écrites, il pourrait en théorie les placer .rodatamême si ce n'est pas const.

Analyse TODO.

Pointeurs

Ce sont des variables (qui contiennent des adresses, qui sont des nombres), donc comme tout le reste :-)

malloc

La question n'a pas beaucoup de sens pour malloc, puisque mallocc'est une fonction, et dans:

int *i = malloc(sizeof(int));

*i est une variable qui contient une adresse, elle relève donc du cas ci-dessus.

Quant au fonctionnement de malloc en interne, lorsque vous l'appelez le noyau Linux marque certaines adresses comme inscriptibles sur ses structures de données internes, et lorsqu'elles sont touchées par le programme initialement, une erreur se produit et le noyau active les tables de pages, ce qui permet l'accès sans segfaul: comment fonctionne la pagination x86?

Notez cependant que c'est fondamentalement exactement ce que fait l' execappel système sous le capot lorsque vous essayez d'exécuter un exécutable: il marque les pages sur lesquelles il veut charger et y écrit le programme, voir aussi: Comment le noyau obtient-il un fichier binaire exécutable fonctionnant sous Linux? Sauf que cela execa des limitations supplémentaires sur l'endroit où charger (par exemple, le code n'est-il pas déplaçable ).

L'appel système exact utilisé mallocest mmapdans les implémentations modernes de 2020, et dans le passé brkétait utilisé: malloc () utilise-t-il brk () ou mmap ()?

Bibliothèques dynamiques

Fondamentalement, mmapaccédez à la mémoire: /unix/226524/what-system-call-is-used-to-load-libraries-in-linux/462710#462710

variables d'environnement et maindeargv

Au-dessus de la pile initiale: /unix/75939/where-is-the-environment-string-actual-stored TODO pourquoi pas en .data?