¿Qué es la memoria de pila?

Es una región especial de la memoria de su

computadora que almacena variables
temporales creadas por cada función
(incluida la función main ()).
La pila es una estructura de datos "LIFO", que
es administrada y optimizada por la CPU muy
de cerca.
Cada vez que una función declara una nueva
variable, se empuja en la pila. Luego, cada vez
que una función sale, se liberan todas las
variables empujadas en la pila por esa
función.
una vez que se libera una variable de pila, esa región de memoria queda disponible para otras
variables de pila.

Memoria de Pila (o Stack)

Cambiemos el ejemplo nuevamente para soportar varios saludos, introduciendo una función
"saludar".
#include <stdio.h>
#include <stdlib.h>

void saludar(int sufijo) {

printf("Hola Programacion %i !\n", sufijo);
}
int main() {
saludar(1);
saludar(2);
saludar(3);
return 0;
}

Acá vemos otro tipo de variable, los parámetros de funciones.

Cada función tiene define su contexto. Este contexto tiene variables. Y estas variables "viven"
solo durante la ejecución de la función/procedimiento. Es decir que "nacen" al ingresar el
llamado a la función y mueren al retornar el control a la función que la llamó (con return o
implícitamente).
Como sabemos también, un programa puede llamar dinámicamente a una función, y ésta a su
vez llamar a otra, y otra, y otra.
Esto se da en forma dinámica. Entonces el lenguaje tiene un mecanismo de gestión de
memoria automática para estos casos. Internamente se maneja con una Pila.
Cuando se entra a una nueva función, se apila un nuevo contexto para ella.
El contexto tiene las variables locales a la función.
Al retornar, se desapila el contexto.
En nuestro ejemplo sucedería algo así:
Pila [ ]
saludar(1) -> Pila[1]
Pila[]
saludar(2) -> Pila[2]
Pila[]
saludar(3) -> Pila[3]
Pila[]

STACK
Cuando un programa es ejecutado, a cada hilo se le asigna una cantidad limitada de espacio en
el Stack. El Stack almacena la información usada por el programa incluyendo el byte-code
ejecutado por el procesador. Se trata de un fragmento de memoria donde se van apilando
linealmente (estructura LIFO) las distintas funciones ejecutadas, así como las variables locales
de cada una de ellas. El modo en cómo se asignará la memoria en el Stack, se define durante el
proceso de compilado.
Algunas consideraciones y aspectos sobre el Stack:

 Las variables almacenadas en el Stack (o variables automáticas) son almacenadas

directamente a esta memoria.
 Su acceso es muy rápido.
 Es liberada al terminar la ejecución.
 Fragmentos grandes de memoria, como arrays de gran envergadura, no deberían ser
almacenados en el Stack, para prevenir desbordamientos del mismo (Stack Overflow).
 Las variables almacenadas en el Stack solamente son accesibles desde el bloque de
código donde fueron declaradas.

En el siguiente código, x es almacenada en el Stack. Su valor no es accesible desde fuera del

bloque if(), de modo que intentar acceder a esa variable fuera del bloque, generaria en un
error de compilación.
Ejemplo de asignación de memoria en el Stack:

void main(){
if(true) {
int x = 0;
}
x = 1;
}