l'allocation de mémoire dans la Pile et le Tas

Cela peut sembler une question très simple, mais son été dans ma tête:

Lorsque nous allouer une variable locale, il va dans la pile. De même, l'allocation dynamique de provoquer la variable d'aller sur le tas. Maintenant, ma question est, est-ce variable en fait allonger sur la pile ou le tas ou nous allons juste une référence dans la pile et le Tas.

Par exemple,

Supposons que je déclare une variable int i. Maintenant, ce i est alloué sur la pile. Donc, quand j'ai imprimer l'adresse de i, ce sera l'une de l'emplacement de la pile? Même question pour les tas.

Je ne comprends pas très bien votre question. Mais vous pouvez lire le livre Computer Systems - Un point de vue du Programmeur et vous connaissez la réponse.

OriginalL'auteur Samir Baid | 2011-07-21

  1. 37

    Je ne suis pas entièrement sûr de ce que vous demandez, mais je vais essayer de mon mieux pour répondre.

    L'exemple suivant déclare une variable i sur la pile:

    int i;

    Quand je demande à une adresse à l'aide &i - je obtenir de l'emplacement réel sur la pile.

    Quand je allouer quelque chose de manière dynamique à l'aide malloc, il y a en fait DEUX morceaux de données qui sont stockées. La dynamique de la mémoire est allouée sur le tas, et le pointeur lui-même est alloué sur la pile. Donc dans ce code:

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

    C'est d'allouer de l'espace sur le tas pour un entier. C'est aussi l'allocation de l'espace sur la pile pour un pointeur (j). La variable j's valeur est définie pour l'adresse retournée par malloc.

    Merci Chris pour ta réponse. C'était la réponse que je cherchais. Donc, c'est la raison pour laquelle nous avons un problème de Programmes en cours d'exécution hors de la Pile mais jamais de la TAS, parce que TAS pourrait être limitée par le système de mémoire.
    En fait la seule raison d'exécution des programmes de l'espace de pile si vite c'est parce qu'il est pratique courante de mettre très petites limites sur l'espace de pile (je pense que 8 KO est assez commun). Et oui, le tas peut être assez dang grand " si vous le permettez.
    pas de. À la fois la pile et le tas est limité par la quantité de mémoire système. Les programmes de pile s'épuise avant de courir hors de segment de mémoire en raison de la taille du tapis est généralement ordres de grandeur plus petit que le tas. Les programmes peuvent encore exécuté de mémoire.
    Sur Windows, la limite est généralement de 1 MO, pas de 8 ko. Je suppose que d'autres systèmes ont des limites similaires. Bien sûr, ce n'est probablement très différente pour les systèmes embarqués.
    Je pensais que sur Windows les limites ont été compilés DANS le binaire, et donc au développeur. Je pourrais certainement croire que 1 MO est la valeur par défaut, 8KO semble assez spartiate, si vous me demandez...

    OriginalL'auteur Chris Eberle

  2. 8

    J'espère que la suite est utile:

    void foo()
{
    //an integer stored on the stack
    int a_stack_integer; 

    //a pointer to integer data, the pointer itself is stored on the stack
    int *a_stack_pointer; 

    //make a_stack_pointer "point" to integer data that's allocated on the heap
    a_stack_pointer = (int*)malloc(10 * sizeof(int));
}

    Dans le cas de la pile des variables, la variable elle-même (données réelles) est stockée dans la pile.

    Dans le cas de mémoire dans la mémoire allouée, les données sous-jacentes sont toujours stockées sur le tas. Un pointeur vers cette mémoire de données/peut être stockés localement sur la pile.

    Espère que cette aide.

    Cela a été utile Darren, mais pouvez-vous m'expliquer un scearnio où la en cas de mémoire dans la mémoire allouée, le pointeur ne peut pas être stocké sur la pile?
    Vous pouvez avoir plus de structure de données complexe, où le segment de mémoire allouée de données contient des pointeurs vers d'autres segments du segment de données allouées. Les classiques de la mise en œuvre d'une liste liée serait un exemple de cette, où chaque "nœud" dans la liste contient un pointeur vers le prochain nœud "" et ainsi de suite
    merci de souligner ce point. Liste liée glissé mon esprit 🙂

    OriginalL'auteur Darren Engwirda

  3. 5

    Le pointeur de la variable elle-même réside dans la pile. Le mémoire que le pointeur pointe vers réside dans le tas.

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

    i réside dans la pile, la mémoire réelle que j'ai des points à *i serait sur le tas.

    OriginalL'auteur Suroot

  4. 2

    Je suis d'accord avec Chris. Juste une autre façon de l'expliquer. Considérons le code suivant:

    int* j = malloc(sizeof(int));
free(j);

    Même après l'utilisation gratuite(j), ce qui devrait libérer la mémoire dans le tas, le pointeur existe toujours et nous avons besoin de faire explicitement NULLE. Absolument, cela suggère qu'il y a aussi une pile de contrepartie de l'aiguille, sinon il doit avoir été inexistant après la commande free. Cette pile variable est l'un pointant vers l'adresse sur le tas où la mémoire a été allouée dynamiquement à l'aide de malloc.

    OriginalL'auteur Prateek

  5. 0

    de la pile ou le tas ne sont pas séparés de la mémoire, ils sont des segments de mémoire que l'exécution d'un programme est attribué par le système, les différentes façons d'organiser les données dans la mémoire.

    Ainsi, lorsque vous obtenez &j'ai, c'est une adresse en mémoire, tout simplement.

    OriginalL'auteur Anh Pham

  6. 0

    M. Eberle la réponse est correcte à 100%, mais depuis que Google montre ce que la première réponse lors de la recherche pour malloc heap or stack, je dois ajouter que malloc() alloue des données sur le tas "plus" de l'époque. Si les données allouées a été plus importante que MMAP_THRESHOLD qui est généralement de 128ko sur les systèmes 32 bits, malloc() sera pas utiliser le tas et au lieu alloue les données dans un Anonyme d'un Segment de Mémoire trouve généralement en dessous de la pile, se développe dans la direction de la mémoire basse.

    C'est la même région que les bibliothèques chargées dynamiquement (libc.so, etc.). Voici le passage pertinent de homme malloc:

    Normalement, la fonction malloc() alloue de la mémoire dans le tas, et ajuste l'
    la taille du segment de mémoire que nécessaire, en utilisant sbrk(2). Lors de l'attribution des blocs
    de mémoire plus grande que MMAP_THRESHOLD octets, l'
    la glibc malloc() alloue de la mise en œuvre de la mémoire privée anonyme de cartographie à l'aide de mmap(2). MMAP_THRESHOLD est de 128 ko par défaut,
    mais est réglable à l'aide de mallopt(3). Avant
    Linux 4.7 dotations effectuées à l'aide de mmap(2) n'ont pas été affectées par la RLIMIT_DATA plafond de ressources; depuis Linux 4.7, cette limite est aussi
    appliquée pour les attributions effectuées à l'aide de mmap(2).

    Un exemple concret, n'hésitez pas à consulter le post suivant. Essentiellement, il alloue de 300 ko avec malloc() puis exécute pmap <PID> pour montrer pertinentes d'un segment de mémoire.

    OriginalL'auteur Solidak