Scribd
Upload
22 views

Dynamic Memory Allocation

Dynamic memory allocation in C uses pointers to allocate and free memory from the heap at runtime. The malloc() function allocates memory on the heap and returns a pointer to that memory. This allows arrays and structures to be created with sizes determined at runtime. The free() function deallocates or frees the memory previously allocated by malloc to avoid memory leaks. Examples demonstrate using malloc() to allocate memory for integer arrays and linked lists, and free() to release the memory.

Uploaded by

rohitggothi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
22 views

Dynamic Memory Allocation

Dynamic memory allocation in C uses pointers to allocate and free memory from the heap at runtime. The malloc() function allocates memory on the heap and returns a pointer to that memory. This allows arrays and structures to be created with sizes determined at runtime. The free() function deallocates or frees the memory previously allocated by malloc to avoid memory leaks. Examples demonstrate using malloc() to allocate memory for integer arrays and linked lists, and free() to release the memory.

Uploaded by

rohitggothi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 17

Dynamic memory allocation

C prog
Dynamic memory allocation When we declare a variable using a basic data
type, the C compiler automatically allocates
memory space for the variable in a pool of
memory called the stack.
For example, a float variable
takes 4 bytes in stack
#include <stdio.h>
int main() An array with a specified size is allocated in
contiguous blocks of memory ,the size of
{
this array is decide at design time .
float arr[10];
printf("The size of the float array is %d", sizeof(arr));
return 0;
}
when we declare a basic data type or an array,
the memory is automatically managed.

There is a process for allocating memory in C


which will permit to implement array size is
undecided until you run your program (runtime).
This process is called “Dynamic memory
allocation.”
Dynamic Memory Allocation in C

Dynamic Memory Allocation is manual allocation


and freeing of memory according to your
programming needs.

Dynamic memory is managed with pointers that


point to the newly allocated memory space in an
area which we call the heap.
We can create and destroy an array of elements dynamically at
runtime, the Automatic memory management uses the stack,
and the C Dynamic Memory Allocation uses the heap.

The <stdlib.h> library has functions responsible for Dynamic


Memory Management.
Function Purpose

Allocates the memory of requested


malloc() size and returns the pointer to the
first byte of allocated space.
Allocates the space for elements of
an array. Initializes the elements to
calloc() zero and returns a pointer to the
memory.
It is umodify the size of previously
realloc() allocated memory spacesed to.
Frees or empties the previously
Free() allocated memory space.
malloc() The C malloc() function stands for memory allocation.
function
It is a function which is used to allocate a block of
memory dynamically.

It reserves memory space of specified size and returns


the null pointer pointing to the memory location.

The pointer returned is usually of type void. It means that


we can assign C malloc() function to any pointer.

Syntax :

ptr = (cast_type *) malloc (byte_size);


Example of malloc():

ptr = (int *) malloc (40);

When this statement is successfully executed, a


memory space of 40 bytes is reserved.

The address of the first byte of reserved space is


assigned to the pointer ptr of type int.
#include <stdlib.h>

int main()
{
int *ptr;

ptr = (int*)malloc(4); /* a block of 1 integer */


if (ptr != NULL)
{
*(ptr) = 480; /* assign 480 to 1st integer */
printf("Value of the 1st integer is %d",*(ptr));
}
}
#include <stdlib.h>

int main()
{
int *ptr;
int i;
ptr = malloc(sizeof(int)); /* a block of 1 integer */
if (ptr != NULL)
{
*(ptr) = 480; /* assign 480 to 1st integer */
printf("Value of the 1st integer is %d",*(ptr));
}
}
#include <stdlib.h>

int main()
{
int *ptr;

ptr = (int*)malloc(2*4); /* a block of 2 integers */


if (ptr != NULL)
{
*(ptr+1) = 500; /* assign 500 to 2nd integer */
printf("Value of the 2nd integer is %d",*(ptr+1));
}
}
free() function The memory for variables is automatically deallocated at
compile time. In dynamic memory allocation, you have to
deallocate memory explicitly. If not done, you may encounter
out of memory error.

The free() function is called to release/deallocate memory in


C. By freeing memory in your program, you make more
available for use later.

free(ptr);
#include <stdlib.h>

struct node {
int data;
struct node *next;
}; head = n1;
n1->data = 1;
void main() n1->next = n2;
{ n2->data = 2;
n2->next = n3;
struct node *head = NULL; n3->data = 3;
struct node *n1, *n2, *n3; n3->next = NULL; /* <-- indicates end of list */
n1 = (struct node *) malloc(sizeof(struct node));
n2 = (struct node *) malloc(sizeof(struct node)); printf("\nValue of 1st node data = %d",head->data);
n3 = (struct node *) malloc(sizeof(struct node)); printf("\nValue of 1st node data = %d",n1->data);
printf("\nValue of 1st node data = %d",n2->data);
printf("\nValue of 1st node data = %d",n3->data);
}
#include <stdlib.h>

struct node { head = n1;


int data; n1->data = 1;
struct node *next; n1->next = n2;
}; n2->data = 2;
n2->next = n3;
void main() n3->data = 3;
{ n3->next = NULL; /* <-- indicates end of list */
int i=1;
struct node *head = NULL; tempptr=head;
struct node *n1, *n2, *n3,*tempptr;
n1 = (struct node *) malloc(sizeof(struct node)); while (tempptr != NULL)
n2 = (struct node *) malloc(sizeof(struct node)); {
n3 = (struct node *) malloc(sizeof(struct node)); printf("\nValue of %d node data = %d",i,tempptr->data);
tempptr=tempptr->next;
} i++;

}
#include <stdlib.h>
struct course {
int marks;
char subject[30]; for(i=0;i<noOfRecords;i++)
}; {
printf("Enter subject and marks:\n");
int main() scanf("%s %d", (ptr + i)->subject, &(ptr + i)->marks);
{ }
struct course *ptr;
int noOfRecords,i; printf("Displaying Information:\n");
printf("Enter the number of records: "); for (i = 0; i < noOfRecords; ++i)
scanf("%d",&noOfRecords); {
printf("%s\t%d\n", (ptr + i)->subject, (ptr + i)->marks);
/* Memory allocation for noOfRecords structures*/ }
ptr=(struct course *)malloc(noOfRecords*sizeof(struct course));
free(ptr);

return 0;
}

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy