C Allocate Memory

1. C Allocate Memory

In C Allocate Memory, dynamic memory allocation allows programs to request memory from the heap at runtime.
Unlike static memory (fixed at compile-time), dynamic memory can grow or shrink as needed.
Requires manual management using allocation and deallocation functions.

2. Memory Allocation Functions in C

Function	Description
`malloc(size_t size)`	Allocates memory of specified size in bytes. Content is uninitialized.
`calloc(size_t n, size_t size)`	Allocates memory for n elements, each of size bytes, and initializes to 0.
`realloc(void *ptr, size_t size)`	Resizes previously allocated memory. Preserves existing content.
`free(void *ptr)`	Frees previously allocated memory.

3. Using `malloc`

#include <stdio.h>
#include <stdlib.h>

int main() {
int *ptr;

// Allocate memory for 5 integers
ptr = (int*) malloc(5 * sizeof(int));

if (ptr == NULL) {
printf("Memory allocation failed!\n");
return 1;
}

for (int i = 0; i < 5; i++)
ptr[i] = i + 1; // Assign values

for (int i = 0; i < 5; i++)
printf("%d ", ptr[i]);

free(ptr); // Release memory
return 0;
}

#include <stdio.h>

#include <stdlib.h>

int main() {

int *ptr;

// Allocate memory for 5 integers

ptr = (int*) malloc(5 * sizeof(int));

if (ptr == NULL) {

printf("Memory allocation failed!\n");

return 1;

}

for (int i = 0; i < 5; i++)

ptr[i] = i + 1; // Assign values

for (int i = 0; i < 5; i++)

printf("%d ", ptr[i]);

free(ptr); // Release memory

return 0;

}

Output:

malloc does not initialize memory, so values could be garbage if not assigned.

4. Using `calloc`

#include <stdio.h>
#include <stdlib.h>int main() {
int *ptr;

// Allocate memory for 5 integers, initialized to 0
ptr = (int*) calloc(5, sizeof(int));

for (int i = 0; i < 5; i++)
printf("%d ", ptr[i]); // all zeros initially

free(ptr);
return 0;
}

#include <stdio.h>

#include <stdlib.h>int main() {

int *ptr;

// Allocate memory for 5 integers, initialized to 0

ptr = (int*) calloc(5, sizeof(int));

for (int i = 0; i < 5; i++)

printf("%d ", ptr[i]); // all zeros initially

free(ptr);

return 0;

}

Output:

calloc initializes allocated memory to zero.

5. Using `realloc`

#include <stdio.h>
#include <stdlib.h>int main() {
int *ptr = (int*) malloc(3 * sizeof(int));

for(int i=0; i<3; i++) ptr[i] = i + 1;

// Resize memory to hold 5 integers
ptr = (int*) realloc(ptr, 5 * sizeof(int));
ptr[3] = 4;
ptr[4] = 5;

for(int i=0; i<5; i++) printf("%d ", ptr[i]);

free(ptr);
return 0;
}

#include <stdio.h>

#include <stdlib.h>int main() {

int *ptr = (int*) malloc(3 * sizeof(int));

for(int i=0; i<3; i++) ptr[i] = i + 1;

// Resize memory to hold 5 integers

ptr = (int*) realloc(ptr, 5 * sizeof(int));

ptr[3] = 4;

ptr[4] = 5;

for(int i=0; i<5; i++) printf("%d ", ptr[i]);

free(ptr);

return 0;

}

Output:

realloc resizes memory, preserving existing values.

6. Important Notes

Always check if allocation succeeded:

Always free allocated memory to avoid memory leaks.
Use sizeof() to calculate memory size:

Dynamic memory is stored in the heap, not the stack.

7. Key Points

malloc → allocate uninitialized memory.
calloc → allocate zero-initialized memory.
realloc → resize previously allocated memory.
free → release memory back to the system.
Dynamic allocation is essential for flexible programs that need variable-size data structures like arrays, linked lists, or trees.

C Allocate Memory

1. C Allocate Memory

2. Memory Allocation Functions in C

3. Using malloc

4. Using calloc

5. Using realloc

6. Important Notes

7. Key Points

You may also like...

C Memory Management

C Structures and Dynamic Memory

C Access Memory

3. Using `malloc`

4. Using `calloc`

5. Using `realloc`