What is Heap memory?
Heaps are memory areas allocated to each program. Memory allocated to heaps can be dynamically allocated, unlike memory allocated to stacks.
As a result, the heap segment can be requested and released whenever the program needs it. This memory is also global, which means that it can be accessed and modified from wherever in the program it is allocated instead of being localized by the function in which it is allocated. Dynamically allocated memory is referenced using ‘pointers’, which in turn leads to slight performance degradation over the use of local variables (on the stack).
Heap memory is also known as “dynamic” memory.
Heap memory is different from local stack memory. It not only differs in the way it allocates and deallocates variables when the function is called but also in the way it deallocates the variable when the function exit. This memory “block” is usually determined automatically according to the size of the object they are creating.
Advantages of heap memory:
- Heap doesn’t have any limit on memory size.
- It allows you to access variables globally.
- Garbage collection runs on the heap memory to free the memory used by the object.
- The heap method is also used in the Priority Queue.
Disadvantages of heap memory:
- It takes too much time to execute compared to the stack.
- It takes more time to compute.
- It can provide the maximum memory an OS can provide
- Memory management is more complicated in heap memory as it is used globally.
Problems that can be solved with heap memory:
The following are some important points about Garbage Collection.
- The Java Virtual Machine invokes garbage collection to get rid of unused heap memory objects. It removes every object that is not being used anymore by the running Java program. In this process, unused memory is freed up for other new objects to use.
- Garbage collection calls the finalize() method of an object before removing it from memory and giving it a chance to be cleaned up. If the programmer does not override this method, the default finalize method will be invoked (the method defined in the Object class).
- Garbage collection is invoked based on the size of dynamically allocated memory from the heap. It is slow, and hard to predict. Programs with real-time performance constraints may find this difficult to handle.
Example of creating memory in heap:
C++
int Geeks(){ // Nothing allocated yet excluding the // pointer itself, which is allocated // here on the stack. char* p; // Memory allocated on the stack. bool flag = true; if (flag) { // Create 1000 bytes on the stack char buffer[1000]; // Create 1000 bytes on the heap p = new char[1000]; } // buffer is deallocated here but pointer // p is not Here occurs a memory leak, // We have to call delete[] p;} |
Java
/*package whatever //do not write package name here */import java.io.*;class GFG { public static void main(String[] args) { // java does not have direct access to memory // location ie. pointers so we use Object Object p; // Memory allocated on the stack. boolean flag = true; if (flag) { // Create 16 bytes on the stack memory char buffer; // Create 1000 bytes on the heap memory p = new Object[1000]; } }}//This code is contributed by Akshay Tripathi(akshaytripathi19410) |
Python
def Geeks(): # Nothing allocated yet excluding the # pointer itself, which is allocated # here on the stack. p = None # Memory allocated on the stack. flag = True if flag: # Create 1000 bytes on the stack buffer = bytearray(1000) # Create 1000 bytes on the heap p = bytearray(1000) # buffer is deallocated here but pointer # p is not. Here occurs a memory leak, # We have to call del p # this code is contributed by bhardwajji |
Javascript
<script>// Define a function called Geeksfunction Geeks() {// Declare a pointer variable p// No memory has been allocated yet, except for the pointer itself on the stacklet p;// Declare a boolean variable flag and set it to truelet flag = true;if (flag) { // Declare a char array called buffer and allocate 1000 bytes on the stacklet buffer = new Array(1000);// Allocate 1000 bytes on the heap and assign the pointer to pp = new Array(1000);} // buffer is deallocated here but pointer // p is not Here occurs a memory leak, // We have to call delete[] p;}// This code is contributed by Aman Kumar.</script> |
C#
using System;class Program{ static void Main(string[] args) { // In C#, the equivalent of a Java Object is an object type object p; // Memory allocation on the stack bool flag = true; if (flag) { // Create 16 bytes on the stack memory char buffer; // Create 1000 bytes on the heap memory p = new object[1000]; } }} |
Points to Remember:
| 1 | It is stored in computer RAM memory just like the stack. |
| 2 | It has a slower allocation of variables in comparison to variables on the stack. |
| 3 | It works on the basis of using on-demand to allocate a block of data for use by the program. |
| 4 | It can have fragmentation when there are a lot of allocations and deallocations. |
| 5 | In C++, variables on the heap must be destroyed manually and never fall out of scope. The data is freed with delete, delete[], or free. |
| 6 | In C++ or C, data created on the heap will be pointed to by pointers and allocated with new or malloc respectively. |
| 7 | We can use heap memory if you don’t exactly know the actual size of data needed at run time or if you need to allocate a lot of data. |
| 8 | It is responsible for memory leaks. |
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
