asignación de memoria en Stack y Heap

Esto puede parecer una pregunta muy básica, pero ha estado en mi cabeza así que:

Cuando asignamos una variable local, entra en la pila. De manera similar, la asignación dinámica hace que la variable se acumule. Ahora, mi pregunta es, ¿esta variable realmente se encuentra en la pila o en el montón o solo haremos una referencia en la pila y en el montón?

Por ejemplo,

Supongamos que declaro una variable int i. Ahora esto i se asigna en la pila. Entonces, cuando imprimo la dirección de i, ¿esta será una de las ubicaciones en la pila? La misma pregunta para el montón también.

No estoy completamente seguro de lo que estás preguntando, pero haré todo lo posible para responder.

Lo siguiente declara una variable i en la pila:

int i;

Cuando pido una dirección usando &i Obtengo la ubicación real en la pila.

Cuando asigno algo dinámicamente usando mallocen realidad hay DOS piezas de datos que se almacenan. La memoria dinámica se asigna en el montón y el propio puntero se asigna en la pila. Así que en este código:

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

Esto es asignar espacio en el montón para un número entero. También está asignando espacio en la pila para un puntero (j). La variable jEl valor de se establece en la dirección devuelta por malloc.

Esperemos que lo siguiente sea útil:

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

En el caso de las variables de pila, la propia variable (los datos reales) se almacena en la pila.

En el caso de la memoria asignada al montón, los datos subyacentes siempre se almacenan en el montón. Un puntero a esta memoria/datos mayo almacenarse localmente en la pila.

Espero que esto ayude.

La variable de puntero en sí residiría en la pila. La memoria a la que apunta el puntero reside en el montón.

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

i residiría en la pila, la memoria real a la que apunto *i estaría en el montón.

Estoy de acuerdo con Chris. Sólo otra forma de explicar eso. Considere el siguiente código:

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

Incluso después de usar free(j), que debería desasignar la memoria del montón, el puntero aún existe y debemos convertirlo explícitamente en NULL. Esto definitivamente sugiere que también hay una contraparte de pila del puntero; de lo contrario, debería haber sido inexistente después del comando libre. Esta variable de pila es la que apunta a la dirección en el montón donde la memoria se asignó dinámicamente usando malloc.

La respuesta del Sr. Eberle es 100% correcta, pero dado que Google muestra esto como la primera respuesta cuando busca malloc heap or stacktengo que agregar que malloc() asigna datos en el montón “la mayor parte” del tiempo. Si los datos asignados eran mayores que MMAP_THRESHOLD que suele ser de 128 kb en sistemas de 32 bits, malloc() voluntad no usa el montón y en su lugar asigna los datos en un Segmento de memoria anónimo ubicado generalmente debajo de la pila, creciendo en la dirección de poca memoria.

Esta es la misma región en la que se encuentran las bibliotecas cargadas dinámicamente (libc.so, etc). Aquí está el pasaje relevante de man malloc:

Normalmente, malloc() asigna memoria del montón y ajusta el tamaño del montón según sea necesario, usando sbrk(2). Cuando se asignan bloques de memoria mayores que MMAP_THRESHOLD bytes, la implementación de glibc malloc() asigna la memoria como un mapeo anónimo privado usando mmap(2). MMAP_THRESHOLD es de 128 kB por defecto, pero se puede ajustar usando mallopt(3). Antes de Linux 4.7, las asignaciones realizadas con mmap(2) no se veían afectadas por el límite de recursos RLIMIT_DATA; desde Linux 4.7, este límite también se aplica a las asignaciones realizadas mediante mmap(2).

Como ejemplo práctico, no dudes en consultar el siguiente post. Básicamente asigna 300kb con malloc() y luego corre pmap <PID> para mostrar el segmento de memoria relevante.

stack o heap no son memoria separada, son segmentos de memoria que el sistema asigna a un programa en ejecución, solo diferentes formas de organizar los datos en la memoria.

Entonces, cuando obtienes &i, es una dirección de memoria, así de simple.