Heap overflow and Stack overflow - GeeksforGeeks

25 Feb, 2018
Heap Overflow:
Heap is a region of process’s memory which is used to store dynamic variables. These variables are allocated using malloc() and calloc() functions and resize using realloc() function, which are inbuilt functions of C. These variables can be accessed globally and once we allocate memory on heap it is our responsibility to free that memory space after use. There are two situations which can result in heap overflow:
If we continuously allocate memory and we do not free that memory space after use it may result in memory leakage – memory is still being used but not available for other processes.// C program to demonstrate heap overflow// by continuously allocating memory#include<stdio.h>  int main(){    for (int i=0; i<10000000; i++)    {       // Allocating memory without freeing it       int *ptr = (int *)malloc(sizeof(int));    }}If we dynamically allocate large number of variables.// C program to demonstrate heap overflow// by allocating large memory#include<stdio.h>  int main(){    int *ptr = (int *)malloc(sizeof(int)*10000000));}
If we continuously allocate memory and we do not free that memory space after use it may result in memory leakage – memory is still being used but not available for other processes.// C program to demonstrate heap overflow// by continuously allocating memory#include<stdio.h>  int main(){    for (int i=0; i<10000000; i++)    {       // Allocating memory without freeing it       int *ptr = (int *)malloc(sizeof(int));    }}
// C program to demonstrate heap overflow// by continuously allocating memory#include<stdio.h>  int main(){    for (int i=0; i<10000000; i++)    {       // Allocating memory without freeing it       int *ptr = (int *)malloc(sizeof(int));    }}
If we dynamically allocate large number of variables.// C program to demonstrate heap overflow// by allocating large memory#include<stdio.h>  int main(){    int *ptr = (int *)malloc(sizeof(int)*10000000));}
// C program to demonstrate heap overflow// by allocating large memory#include<stdio.h>  int main(){    int *ptr = (int *)malloc(sizeof(int)*10000000));}
Stack Overflow:
Stack is a special region of our process’s memory which is used to store local variables used inside the function, parameters passed through a function and their return addresses. Whenever a new local variable is declared it is pushed onto the stack. All the variables associated with a function are deleted and memory they use is freed up, after the function finishes running. The user does not have any need to free up stack space manually. Stack is Last-In-First-Out data structure.
In our computer’s memory, stack size is limited. If a program uses more memory space than the stack size then stack overflow will occur and can result in a program crash. There are two cases in which stack overflow can occur:
If we declare large number of local variables or declare an array or matrix or any higher dimensional array of large size can result in overflow of stack.// C program to demonstrate stack overflow// by allocating a large local memory#include<stdio.h>  int main() {     // Creating a matrix of size 10^5 x 10^5   // which may result in stack overflow.   int mat[100000][100000];}If function recursively call itself infinite times then the stack is unable to store large number of local variables used by every function call and will result in overflow of stack.// C program to demonstrate stack overflow// by creating a non-terminating recursive// function.#include<stdio.h>  void fun(int x){    if (x == 1)       return;    x = 6;    fun(x);}  int main(){   int x = 5;   fun(x);}
If we declare large number of local variables or declare an array or matrix or any higher dimensional array of large size can result in overflow of stack.// C program to demonstrate stack overflow// by allocating a large local memory#include<stdio.h>  int main() {     // Creating a matrix of size 10^5 x 10^5   // which may result in stack overflow.   int mat[100000][100000];}
// C program to demonstrate stack overflow// by allocating a large local memory#include<stdio.h>  int main() {     // Creating a matrix of size 10^5 x 10^5   // which may result in stack overflow.   int mat[100000][100000];}
If function recursively call itself infinite times then the stack is unable to store large number of local variables used by every function call and will result in overflow of stack.// C program to demonstrate stack overflow// by creating a non-terminating recursive// function.#include<stdio.h>  void fun(int x){    if (x == 1)       return;    x = 6;    fun(x);}  int main(){   int x = 5;   fun(x);}
// C program to demonstrate stack overflow// by creating a non-terminating recursive// function.#include<stdio.h>  void fun(int x){    if (x == 1)       return;    x = 6;    fun(x);}  int main(){   int x = 5;   fun(x);}
Please refer Memory Layout of C Programs for details.
system-programming
C Language
C++
CPP
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Function Pointer in C
Substring in C++
rand() and srand() in C/C++
fork() in C
std::string class in C++
Inheritance in C++
Initialize a vector in C++ (6 different ways)
Map in C++ Standard Template Library (STL)
C++ Classes and Objects
Virtual Function in C++