La memoria en un programa C/C++/Java se puede asignar en una pila o en un montón.
Requisito previo: Diseño de memoria del programa C. .

Asignación de pila: La asignación ocurre en bloques contiguos de memoria. Lo llamamos asignación de memoria de pila porque la asignación ocurre en la pila de llamadas a funciones. El compilador conoce el tamaño de la memoria que se asignará y cada vez que se llama a una función, sus variables obtienen memoria asignada en la pila. Y cada vez que finaliza la llamada a la función, se desasigna la memoria para las variables. Todo esto sucede usando algunas rutinas predefinidas en el compilador. Un programador no tiene que preocuparse por la asignación de memoria y la desasignación de variables de la pila. Este tipo de asignación de memoria también se conoce como asignación de memoria temporal porque tan pronto como el método finaliza su ejecución, todos los datos pertenecientes a ese método se eliminan de la pila automáticamente. Esto significa que se puede acceder a cualquier valor almacenado en el esquema de memoria de la pila siempre que el método no haya completado su ejecución y se encuentre actualmente en estado de ejecución.

orden aleatorio sql

Puntos clave:

• Es un esquema de asignación de memoria temporal en el que se puede acceder a los miembros de datos solo si el método () que los contenía se está ejecutando actualmente.
• Asigna o desasigna la memoria automáticamente tan pronto como el método correspondiente completa su ejecución.
• Recibimos el error correspondiente Java. idioma. Error de sobreflujo de pila por JVM , Si la memoria de la pila está completamente llena.
• La asignación de memoria de pila se considera más segura en comparación con la asignación de memoria de pila porque solo el subproceso propietario puede acceder a los datos almacenados.
• La asignación y desasignación de memoria son más rápidas en comparación con la asignación de memoria dinámica.
• La memoria de pila tiene menos espacio de almacenamiento en comparación con la memoria de montón.

int main() {  // All these variables get memory  // allocated on stack  int a;  int b[10];  int n = 20;  int c[n]; }>

Asignación de montón: La memoria se asigna durante la ejecución de instrucciones escritas por los programadores. Tenga en cuenta que el nombre del montón no tiene nada que ver con el pérdida de memoria puede suceder en el programa.

La asignación de memoria dinámica se divide a su vez en tres categorías: - Estas tres categorías nos ayudan a priorizar los datos (Objetos) que se almacenarán en la memoria Heap o en el Recolección de basura .

linux $ casa

• Generación joven - Es la parte de la memoria donde se crean todos los datos (objetos) nuevos para asignar el espacio y cada vez que esta memoria se llena por completo, el resto de los datos se almacena en la recolección de basura.
• Generación antigua o permanente – Esta es la parte de la memoria dinámica que contiene los objetos de datos más antiguos que no se utilizan con frecuencia o que no se utilizan en absoluto.
• Generación Permanente – Esta es la parte de la memoria Heap que contiene los metadatos de la JVM para las clases de tiempo de ejecución y los métodos de la aplicación.

Puntos clave:

• Recibimos el mensaje de error correspondiente si el espacio del montón está completamente lleno, Java. idioma.OutOfMemoryError por JVM.
• Este esquema de asignación de memoria es diferente de la asignación de espacio de pila; aquí no se proporciona ninguna función de desasignación automática. Necesitamos utilizar un recolector de basura para eliminar los objetos antiguos no utilizados para poder utilizar la memoria de manera eficiente.
• El tiempo de procesamiento (tiempo de acceso) de esta memoria es bastante lento en comparación con la memoria de pila.
• La memoria de montón tampoco es tan segura para subprocesos como la memoria de pila porque los datos almacenados en la memoria de montón son visibles para todos los subprocesos.
• El tamaño de la memoria Heap es bastante mayor en comparación con la memoria Stack.
• La memoria dinámica es accesible o existe mientras se ejecute toda la aplicación (o programa Java).

int main() {  // This memory for 10 integers  // is allocated on heap.  int *ptr = new int[10]; }>

Ejemplo combinado de ambos tipos de asignación de memoria Heap y Stack en Java:

#include  using namespace std; int main() {  int a = 10; // stored in stack  int* p = new int(); // allocate memory in heap  *p = 10;  delete (p);  p = new int[4]; // array in heap allocation  delete[] p;  p = NULL; // free heap  return 0; }>

class Emp {  int id;  String emp_name;  public Emp(int id, String emp_name) {  this.id = id;  this.emp_name = emp_name;  } } public class Emp_detail {  private static Emp Emp_detail(int id, String emp_name) {  return new Emp(id, emp_name);  }  public static void main(String[] args) {  int id = 21;  String name = 'Maddy';  Emp person_ = null;  person_ = Emp_detail(id, name);  } }>

def main(): a = 10 # stored in stack p = None # declaring p variable p = 10 # allocating memory in heap del p # deleting memory allocation in heap p = [None] * 4 # array in heap allocation p = None # free heap return 0 if __name__ == '__main__': main()>

// Define the Emp class with id and emp_name properties class Emp {  constructor(id, emp_name) {  this.id = id; // Initialize id  this.emp_name = emp_name; // Initialize emp_name  } } // Create an instance of the Emp class const person = new Emp(21, 'Maddy'); // Initialize person with id 21 and emp_name 'Maddy' console.log(person); // Output the person object to the console>

A continuación se detallan las conclusiones a las que llegaremos después de analizar el ejemplo anterior:

• Cuando comenzamos la ejecución del programa have, todas las clases de tiempo de ejecución se almacenan en el espacio de memoria Heap.
• Luego encontramos el método main() en la siguiente línea que se almacena en la pila junto con todas sus primitivas (o locales) y la variable de referencia Emp de tipo Emp_detail también se almacenará en la pila y señalará el objeto correspondiente. almacenado en la memoria del montón.
• Luego, la siguiente línea llamará al constructor parametrizado Emp(int, String) desde main() y también lo asignará a la parte superior del mismo bloque de memoria de la pila. Esto almacenará:
  • La referencia de objeto del objeto invocado de la memoria de la pila.
  • El valor primitivo ( La variable de referencia del argumento String emp_name apuntará a la cadena real del grupo de cadenas a la memoria del montón.
• Luego, el método principal llamará nuevamente al método estático Emp_detail(), para lo cual la asignación se realizará en el bloque de memoria de pila encima del bloque de memoria anterior.
• La variable de referencia del argumento String emp_name apuntará a la cadena real del grupo de cadenas a la memoria del montón.

La variable de referencia del argumento String emp_name apuntará a la cadena real del grupo de cadenas a la memoria del montón.

Figura 1

sintaxis de extracción de git

Diferencias clave entre asignaciones de pila y montón

1. En una pila, el compilador realiza automáticamente la asignación y desasignación, mientras que, en el montón, el programador debe realizarla manualmente.
2. Manejar el marco del montón es más costoso que manejar el marco de la pila.
3. Es más probable que el problema de escasez de memoria ocurra en la pila, mientras que el problema principal en la memoria del montón es la fragmentación.
4. El acceso al marco de pila es más fácil que al marco de montón, ya que la pila tiene una pequeña región de memoria y es compatible con el caché, pero en el caso de marcos de montón que están dispersos por toda la memoria, provoca más errores de caché.
5. Una pila no es flexible, el tamaño de la memoria asignada no se puede cambiar, mientras que un montón es flexible y la memoria asignada se puede modificar.
6. Acceder al tiempo del montón requiere más que una pila.

Cuadro comparativo

Parámetro	PILA	MONTÓN
Básico	La memoria se asigna en un bloque contiguo.	La memoria se asigna en cualquier orden aleatorio.
Asignación y desasignación	Automático por instrucciones del compilador.	Manual del programador.
Costo	Menos	Más
Implementación	Fácil	Duro
Tiempo de acceso	Más rápido	Más lento
Tema principal	escasez de memoria	Fragmentación de la memoria
Localidad de referencia	Excelente	Adecuado
Seguridad	Seguro para subprocesos, solo el propietario puede acceder a los datos almacenados	No es seguro para subprocesos, los datos almacenados son visibles para todos los subprocesos
Flexibilidad	Tamaño fijo	Cambiar el tamaño es posible
Estructura de tipo de datos	Lineal	Jerárquico
Privilegiado	Se prefiere la asignación de memoria estática en una matriz.	Se prefiere la asignación de memoria dinámica en la lista vinculada.
Tamaño	Más pequeño que la memoria del montón.	Más grande que la memoria de la pila.