Calloc

 //calloc

#include <stdio.h>

#include <stdlib.h> 

int main() {

    int *ptr;

    int n = 5;

    printf("Enter number of values:\n");

    scanf("%d",&n);

    

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

    if (ptr == NULL) {

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

        return 1; 

    }

   

    printf("\n");

   

    for (int i = 0; i < n; i++) {

        ptr[i] = i *10+10;

    }

    printf("After assigning values:\n");

    for (int i = 0; i < n; i++) {

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

    }

    printf("\n");

   

    free(ptr);

    ptr = NULL; 

    return 0;

}

🟦 Step 1 : Include Header Files

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

📖 Explanation

📚 Header File	🎯 Purpose
🟦 stdio.h	Used for input/output functions like printf() and scanf().
🟩 stdlib.h	Used for dynamic memory functions such as calloc(), malloc(), realloc(), and free().

---

🟦 Step 2 : Start the Program

int main()

📖 Explanation

Every C program begins execution from the main() function.

Program Starts
      │
      ▼
 int main()

---

🟦 Step 3 : Declare Variables

int *ptr;
int n = 5;

📖 Explanation

Variable	Meaning
🔹 ptr	Pointer that stores the address of dynamically allocated memory
🔹 n	Number of integer elements

Initially

ptr

↓

NULL

n = 5

No memory has been allocated yet.

---

🟦 Step 4 : Take User Input

printf("Enter number of values:\n");
scanf("%d",&n);

Example Input

Enter number of values:
5

Now,

n = 5

---

🟦 Step 5 : Allocate Memory Using calloc()

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

---

📌 Syntax

calloc(Number_of_Elements, Size_of_Each_Element)

Example

n = 5

sizeof(int)=4 bytes

Memory allocated

5 × 4 = 20 Bytes

---

🖼 Memory Before Allocation

ptr

↓

NULL

---

🖼 Memory After calloc()

ptr

↓

+------+------+------+------+------+
|  0   |  0   |  0   |  0   |  0   |
+------+------+------+------+------+

⭐ Important

calloc() initializes every element to 0 automatically.

---

🟦 Step 6 : Check Memory Allocation

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

📖 Explanation

If the operating system cannot allocate memory,

ptr

↓

NULL

The program prints

Memory allocation failed!

and terminates safely.

---

🟦 Step 7 : Store Values

for(int i=0;i<n;i++)
{
    ptr[i]=i*10+10;
}

---

📊 Value Calculation

🔢 i	Formula	Stored Value
0	0×10+10	✅ 10
1	1×10+10	✅ 20
2	2×10+10	✅ 30
3	3×10+10	✅ 40
4	4×10+10	✅ 50

---

🖼 Memory After Storing Values

ptr

↓

+------+------+------+------+------+
| 10   | 20   | 30   | 40   | 50   |
+------+------+------+------+------+

---

🟦 Step 8 : Print the Values

printf("After assigning values:\n");

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

---

Output

After assigning values:

10 20 30 40 50

---

🟦 Step 9 : Release Memory

free(ptr);

📖 Explanation

The free() function releases the allocated memory back to the operating system.

Before free()

ptr

↓

+------+------+------+------+------+
| 10   | 20   | 30   | 40   | 50   |
+------+------+------+------+------+

After free()

Memory Released

ptr

↓

(Dangling Pointer)

The memory no longer belongs to the program.

---

🟦 Step 10 : Assign NULL

ptr=NULL;

📖 Explanation

After freeing memory, the pointer still contains the old address.

Such a pointer is called a Dangling Pointer.

Assigning

ptr=NULL;

makes the pointer safe.

---

Before

ptr

↓

0x1000A520

After

ptr

↓

NULL

---

🌈 Complete Memory Flow

🔹 Before Allocation

ptr

↓

NULL

⬇

🔹 After calloc()

ptr

↓

+----+----+----+----+----+
| 0  | 0  | 0  | 0  | 0  |
+----+----+----+----+----+

⬇

🔹 After Assigning Values

ptr

↓

+----+----+----+----+----+
|10  |20  |30  |40  |50  |
+----+----+----+----+----+

⬇

🔹 After free()

Memory Released

ptr

↓

NULL

---

🖥 Sample Run

Input

Enter number of values:
5

Output

After assigning values:

10 20 30 40 50

---

🌟 Advantages of calloc()

✅ Allocates memory dynamically.

✅ Initializes all memory to 0.

✅ Prevents uninitialized (garbage) values.

✅ Useful when array size is known only during program execution.

Malloc

 #include <stdio.h>

#include <stdlib.h> 

int main() {

    int *ptr; 

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

    if (ptr == NULL) {

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

        return 1; 

    }

    printf("Memory successfully allocated using malloc.\n");

     printf("enter a value.\n");

    scanf("%d",ptr);   

        printf("value = %d ", *ptr);    

    printf("\n");

           return 0; 

}

🟦 Step 1 : Include Header Files

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

📖 Explanation

📚 Header File	🎯 Purpose
🟦 stdio.h	Used for input/output functions like printf() and scanf().
🟩 stdlib.h	Used for memory management functions such as malloc(), calloc(), realloc(), and free().

---

🟦 Step 2 : Start the Program

int main()

📖 Explanation

Every C program begins execution from the main() function.

Program Starts
      │
      ▼
 int main()

---

🟦 Step 3 : Declare a Pointer

int *ptr;

📖 Explanation

• ptr is an integer pointer.
• It will store the address of dynamically allocated memory.

Initially

ptr

↓

Garbage Address (Uninitialized)

---

🟦 Step 4 : Allocate Memory Using malloc()

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

---

📌 Syntax

malloc(Number_of_Bytes)

---

Example

sizeof(int) = 4 bytes

Memory allocated

4 Bytes

---

🖼 Memory Representation

Before Allocation

ptr

↓

?

After Allocation

ptr

↓

+---------+
| Garbage |
+---------+

⭐ Important

Unlike calloc(), malloc() does NOT initialize memory.

The allocated memory contains garbage (unpredictable) values until you assign a value.

---

🟦 Step 5 : Check Memory Allocation

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

📖 Explanation

If memory allocation fails,

ptr

↓

NULL

The program prints:

Memory allocation failed!

and terminates safely.

---

🟦 Step 6 : Display Success Message

printf("Memory successfully allocated using malloc.\n");

Output

Memory successfully allocated using malloc.

This confirms that memory allocation was successful.

---

🟦 Step 7 : Read a Value

printf("Enter a value:\n");
scanf("%d", ptr);

Suppose the user enters

25

The value 25 is stored in the allocated memory.

---

🖼 Memory Diagram

Before Input

ptr

↓

+---------+
| Garbage |
+---------+

After Input

ptr

↓

+------+
|  25  |
+------+

---

🟦 Step 8 : Print the Stored Value

printf("Value = %d", *ptr);

Explanation

*ptr means the value stored at the memory location pointed to by ptr.

If

ptr = 1000 (Address)

Memory

1000 → 25

Then

*ptr

returns

25

Output

Value = 25

---

🌈 Complete Memory Flow

🔹 Before Allocation

ptr

↓

Uninitialized

⬇

🔹 After malloc()

ptr

↓

+---------+
| Garbage |
+---------+

⬇

🔹 After User Input

ptr

↓

+------+
|  25  |
+------+

⬇

🔹 After Printing

Value = 25

---

🖥 Sample Execution

Input

Enter a value:
50

Output

Memory successfully allocated using malloc.
Enter a value:
50
Value = 50

---

📊 malloc() Memory Representation

            malloc(sizeof(int))

                  │
                  ▼

           +---------------+
ptr ------>|      25       |
           +---------------+

---

🌟 Advantages of malloc()

✅ Allocates memory during program execution.

✅ Useful when memory size is determined at runtime.

✅ Efficient because it does not initialize memory.

✅ Widely used for dynamic arrays, linked lists, trees, and other dynamic data structures.

---

⚠ Best Practices

✔ Always check if malloc() returns NULL.

✔ Initialize the allocated memory before using it.

✔ Release allocated memory using free().

✔ After free(), assign the pointer to NULL.

---

🟦 Improved Version of the Program

Your program allocates memory correctly, but it should also release it after use.

free(ptr);
ptr = NULL;

Add these lines before return 0;.

Malloc and free

  #include <stdio.h>

#include <stdlib.h> 

int main() {

    int *ptr; 

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

    if (ptr == NULL) {

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

        return 1; 

    }

    printf("Memory successfully allocated using malloc.\n");

     printf("enter a value.\n");

    scanf("%d",ptr);   

        printf("value = %d ", *ptr);    

    printf("\n");

free(ptr);

 printf("after free ptr new value = %d ", *ptr);    

           return 0; 

}

🟦 Step 1: Include Header Files

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

📖 Explanation

Header File	Purpose
📘 stdio.h	Used for printf() and scanf()
📗 stdlib.h	Used for malloc(), calloc(), realloc(), and free()

---

🟦 Step 2: Declare Pointer

int *ptr;

Explanation

• ptr is an integer pointer.
• It will store the address of dynamically allocated memory.

Initially

ptr

↓

Uninitialized

---

🟦 Step 3: Allocate Memory

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

Explanation

malloc() allocates memory for one integer.

If

sizeof(int) = 4 bytes

then

malloc(4)

allocates 4 bytes of memory.

---

Memory Diagram

ptr

↓

+---------+
| Garbage |
+---------+

Important: Unlike calloc(), malloc() does not initialize memory. The allocated memory contains a garbage value until you assign one.

---

🟦 Step 4: Check Memory Allocation

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

Explanation

If the operating system cannot allocate memory,

ptr

↓

NULL

The program terminates safely.

---

🟦 Step 5: Read User Input

scanf("%d", ptr);

Suppose the user enters

50

Memory becomes

ptr

↓

+------+
|  50  |
+------+

---

🟦 Step 6: Print the Value

printf("Value = %d", *ptr);

*ptr means:

The value stored at the memory location pointed to by ptr.

Output

Value = 50

---

🟦 Step 7: Free the Memory

free(ptr);

Explanation

The allocated memory is returned to the operating system.

Before free()

ptr

↓

+------+
|  50  |
+------+

After free()

Memory Released

ptr

↓

Dangling Pointer

The pointer still contains the old address, but the memory is no longer valid.

---

🟥 Step 8: Accessing Memory After free()

printf("After free ptr new value = %d", *ptr);

❌ This is Incorrect

After free(), the pointer refers to memory that has already been released.

Accessing it causes Undefined Behaviour.

Possible outputs:

After free ptr new value = 50

or

After free ptr new value = 0

or

After free ptr new value = -125678

or

Segmentation Fault

There is no guaranteed result.

---

🌈 Memory Flow

🔹 Before malloc()

ptr

↓

Uninitialized

⬇

🔹 After malloc()

ptr

↓

+---------+
| Garbage |
+---------+

⬇

🔹 After User Input

ptr

↓

+------+
|  50  |
+------+

⬇

🔹 After free()

Memory Released

ptr

↓

Dangling Pointer

⬇

🔹 Accessing *ptr

❌ Undefined Behaviour

---

🖥 Sample Execution

Input

Enter a value:
50

Possible Output

Memory successfully allocated using malloc.
Enter a value:
50
Value = 50
After free ptr new value = 50

On another system or another run, the last line may show a different value or the program may crash.

---

⚠ Problems in the Program

Problem

free(ptr);

printf("%d", *ptr);

The memory has already been released.

The pointer becomes a dangling pointer.

Reading from it is undefined behaviour according to the C standard.

---

✅ Correct Version

free(ptr);
ptr = NULL;

if(ptr != NULL)
{
    printf("%d", *ptr);
}
else
{
    printf("Pointer is NULL. Memory has been freed.");
}

Output

Memory successfully allocated using malloc.
Enter a value:
50
Value = 50
Pointer is NULL. Memory has been freed.

Dynamic memory allocation

📚 Dynamic Memory Allocation in C Programming

Click on any topic below to learn with examples and explanations.

---

Topic	Open Tutorial
🔹 1. malloc()	📖 CLICK HERE
🔹 2. free()	📖 CLICK HERE
🔹 3. calloc() - Part 1	📖 CLICK HERE
🔹 4. calloc() - Part 2	📖 CLICK HERE
🔹 5. calloc() + free()	📖 CLICK HERE
🔹 6. realloc()	📖 CLICK HERE

💡 Topics Covered

• ✅ malloc()
• ✅ free()
• ✅ calloc()
• ✅ calloc() with free()
• ✅ realloc()
• ✅ Dynamic Memory Allocation in C

🌟 Happy Coding! Keep Learning C Programming 🌟

👨‍🏫 Bijan Krishna Paul

Thank you for visiting my programming tutorials.
Keep Learning • Keep Coding • Keep Growing 🚀

---

© 2026 Bijan Krishna Paul
All Rights Reserved.