Dynamic Memory Allocation


Dynamic memory allocation in programming refers to the ability to allocate memory for variables or data structures during the runtime of a program. Unlike static memory allocation, where memory is assigned at compile time, dynamic memory allocation allows the program to request and release memory as needed while the program is running.

In languages like C, C++, and similar low-level languages, dynamic memory allocation is often performed using functions provided by the standard library, such as malloc, calloc, realloc, and free in the <stdlib.h> header.

Here's an overview of these functions with examples:

malloc (Memory Allocation):
Stands for "memory allocation."
Allocates a specified number of bytes of memory.
Returns a pointer to the first byte of the allocated memory.

#include <stdlib.h>
main()
{
int *arr;
int size = 5;

arr = (int*)malloc(size * sizeof(int));

if (arr == NULL) {
    // Memory allocation failed
    printf("Memory allocation failed.\n");
} else {
    // Memory allocation successful
    // Use the 'arr' pointer to access the allocated memory
    // Don't forget to free the memory when done
    free(arr);
}
}

calloc (Contiguous Allocation):
Stands for "contiguous allocation."
Allocates a specified number of blocks of memory, each with a specified number of bytes.
Initializes the allocated memory to zero.

#include <stdlib.h>
main()
{
int *arr;
int size = 5;

arr = (int*)calloc(size, sizeof(int));

if (arr == NULL) {
    // Memory allocation failed
    printf("Memory allocation failed.\n");
} else {
    // Memory allocation successful
    // Use the 'arr' pointer to access the allocated memory
    // Don't forget to free the memory when done
    free(arr);
}
}

realloc (Re-Allocation):
Stands for "re-allocation."
Changes the size of the previously allocated memory block.
Returns a pointer to the beginning of the reallocated memory block.

#include <stdlib.h>
main()
{
int *arr;
int size = 5;

arr = (int*)malloc(size * sizeof(int));

// Code to use the allocated memory

// Need more space
size = 10;
arr = (int*)realloc(arr, size * sizeof(int));

if (arr == NULL) {
    // Memory reallocation failed
    printf("Memory reallocation failed.\n");
} else {
    // Memory reallocation successful
    // Use the 'arr' pointer to access the reallocated memory
    // Don't forget to free the memory when done
    free(arr);
}
}

free:
Deallocates the memory previously allocated by malloc, calloc, or realloc.
It's essential to free dynamically allocated memory to prevent memory leaks.

#include <stdlib.h>
main()
{
int *arr;
int size = 5;

arr = (int*)malloc(size * sizeof(int));

// Code to use the allocated memory

// Free the allocated memory when done
free(arr);
}
Remember to check if memory allocation was successful by verifying if the returned pointer is NULL. Additionally, always free the allocated memory when it is no longer needed to avoid memory leaks in your program.

Dynamic memory allocation is particularly useful when the size of data structures is not known at compile time or when memory needs to be managed more flexibly. However, it requires careful handling to avoid memory leaks or accessing memory that has already been freed (dangling pointers). Memory allocated dynamically should be released using free when it's no longer needed to avoid memory leaks.

Comments

Post a Comment

Popular posts from this blog

Data Structures CST 201 KTU Third Semester Syllabus Notes and Solved Questions- Dr Binu V P 984739060

Dr BinuV P -About Me About The Course Syllabus Data Structures Lab CSL 201 ( Do the Programs to Understand the Concept Well) Model Question Paper CST 201 Data Structures University Question Papers CST 201 Data Structures Module-1 Basic Concepts of Data Structures 1.1 System Life Cycle 1.2 Algorithms , Performance Analysis  1.3 Space Complexity, Time Complexity  1.4 Asymptotic Analysis and Notations  1.5 Complexity Calculation of Simple Algorithms Module-2 Arrays and Searching  2.1 Polynomial representation using Arrays  2.2 Sparse matrix  2.3 Stacks  2.4 Queues 2.5 Circular Queues  2.6 Priority Queues 2.7 Double Ended Queues 2.8 Infix to  Postfix Conversion  2.9  Evaluation of Postfix Expression 2.10 Linear Search  2.11 Binary Search Module-3 Linked List and Memory Management 3.1 Linked List -Self Referential Structures  3.2 Dynamic Memory Allocation  3.3 Singly Linked List-Operations on Linked List 3.4 Doubly Linked List 3.5 Circular Linked List  3.6 Stack using Linked List  3.7 Queue
Read more

Depth First Search DFS

Image
Depth-First Search (DFS) is a fundamental graph traversal algorithm that explores as far as possible along each branch before backtracking. It's often used to explore and analyze the connectivity of graphs, find paths, and solve problems related to connected components. Algorithm: The DFS algorithm operates on a graph, starting from an initial vertex. It maintains a stack (or uses recursion) to keep track of the vertices to visit. Initialization: Create a boolean array to mark visited vertices. Initialize all vertices as not visited. DFS Function: Choose a starting vertex (if the graph is disconnected, this process is repeated for unvisited vertices). Mark the chosen vertex as visited. Explore the chosen vertex's neighbours: If a neighbour is not visited, recursively call the DFS function on that neighbour. Repeat until all reachable vertices are visited. Here's a simplified recursive implementation in pseudocode: procedure DFS(vertex): mark vertex as visited for ea
Read more

Binary Search Tree ( BST) and operations

Image
A binary search tree (BST) is a data structure that organizes elements in a hierarchical structure, allowing for efficient search, insertion, and deletion operations. Here are the key properties and operations associated with a binary search tree: Properties of a Binary Search Tree: Binary Tree Structure:      Each node in the tree has at most two children: a left child and a right child.      The left subtree of a node contains only nodes with values less than the node's value.      The right subtree of a node contains only nodes with values greater than the node's value. Ordering Property:      For any node n , all nodes in its left subtree have values less than n, and all nodes in its right subtree           have values greater than n . No Duplicates:     A binary search tree does not allow duplicate values. Example: Figure  shows a binary search tree. Notice that this tree is obtained by inserting the values 13, 3, 4, 12, 14, 10, 5, 1, 8, 2, 7, 9, 11, 6, 18 in that order,
Read more