Pourquoi char [] est-il sur la pile, mais char * sur le tas?

Je suis très confus au sujet de ce qui se passe. J'ai toujours pensé que char * et char [] étaient interchangeables, mais après avoir regardé les adresses de mémoire il me semble char * alloue de l'espace dans le tas, alors que char [] est d'allouer de la mémoire sur la pile.

char stack[] = "hello";
char *heap = "hello";

char *heap_string_malloc = malloc(5);
heap_string_malloc = "hello";

printf("Address of stack[0]: %p\n", stack);
printf("Address of heap[0]: %p\n", heap);
printf("Address of heap_string_malloc[0]: %p\n", heap_string_malloc);

Résultats suivants:

Address of stack[0]: 0x7fff8b0b85b0
Address of heap[0]: 0x400760
Address of heap_string_malloc[0]: 0x400760

Est-ce à dire que char * est allouée dynamiquement?

Suite à ma confusion, comment se fait - malloc est d'allouer la même adresse mémoire que ce char *heap a déjà alloué? Je ne suis pas en cours d'exécution toute optimisation (simplement gcc file.c).

source d'informationauteur tgun926

  1. 31

    Les tableaux ne sont pas des pointeurs. Quel est votre programme est en train de faire, ligne par ligne, est

    //Allocate 6 bytes in the stack and store "hello" in them
char stack[] = "hello";

//Allocate pointer on the stack and point it to a static, read-only buffer
//containing "hello"
char *heap = "hello";

//Malloc 5 bytes (which isn't enough to hold "hello" due to the NUL byte)
char *heap_string_malloc = malloc(5);

//Reset heap_string_malloc to point to a static buffer; memory leak!
heap_string_malloc = "hello";

    La raison pour laquelle vous voyez le pointeur de même deux fois, c'est parce que le compilateur optimisé à l'écart de la deuxième statique de la mémoire tampon contenant "hello".

  2. 11

    Lorsque vous faites par exemple

    char *heap = "hello";

    le pointeur heap fait n'est pas le point le tas, c'points de données statiques chargés avec le reste du programme par le chargeur du système d'exploitation. En fait, pour être correct, il devrait être

    const char *heap = "hello";

    comme heap pointant vers un constante et en lecture seule morceau de mémoire.

    Aussi, tandis que les tableaux se désintègre (et peut être utilisé comme) des pointeurs, et des pointeurs peut être utilisée avec la syntaxe de tableau, ils sont pas le même. La plus grande différence étant que pour un tableau, vous pouvez utiliser, par exemple, sizeof pour obtenir la taille en octets du tableau réel, alors il n'est pas possible pour les pointeurs.

    Et une troisième chose, quand vous faites

    char *heap_string_malloc = malloc(5);
heap_string_malloc = "hello";

    vous avez un fuite de mémoireque vous devez d'abord assigner quelque chose à heap_string_malloc mais alors directement après réaffecter heap_string_malloc pour pointer vers quelque chose de complètement différent.

    Que pour la raison pour laquelle vous obtenez la même adresse pour les deux heap et heap_string_malloc c'est parce que les deux points de la même chaîne littérale.

  3. 1

    "pile" est un tableau statique de caractères de sorte qu'il sera alloué dans la pile et libéré automatiquement une fois que la fonction se termine, parce que sa taille est connue depuis sa définition.
    Tandis que le "tas" et "heap_string_malloc" sont tous deux déclaré que les pointeurs de char tampons et doivent être allouées dynamicly avec malloc afin de définir la taille de leur contenu, c'est pourquoi ils se trouvent dans le segment de mémoire.
    Par:

    char *heap = "hello";

    et:

    heap_string_malloc = "hello";

    vous êtes en train de modifier les pointeurs eux-auto (avec un statique de la valeur tampon), pas le contenu auquel ils sont le pointant du doigt. Vous devriez plutôt utiliser memcpy pour modifier la mémoire pointée par le "heap_string_malloc" pointeur avec vos données:

    memcpy(heap_string_malloc, "hello", 5);
  4. 1

    Cela crée un tableau sur la pile, contenant une copie de la statique de la chaîne de caractères "bonjour":

    char stack[] = "hello";

    Cela crée un pointeur sur la pile, contenant l'adresse de la statique de la chaîne de caractères "bonjour":

    char *heap = "hello";

    Cela crée un pointeur sur la pile, contenant l'adresse d'un tampon allouée dynamiquement de 5 octets:

    char *heap_string_malloc = malloc(5);

    Mais dans les trois cas, vous mettez quelque chose sur la pile. char* n'est pas "sur le tas". C'est un pointeur (sur la pile) qui pointe vers quelque chose, quelque part.