The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Malloc and Free

Next ►
►

In this section, we will delve into dynamic memory allocation in C using the malloc and free functions. These functions are essential for managing memory efficiently, especially when the size of the data structure is not known at compile time.

Key Concepts

  1. Dynamic Memory Allocation: Allocating memory during runtime using functions like malloc.
  2. Malloc: Allocates a specified number of bytes and returns a pointer to the first byte.
  3. Free: Deallocates the memory previously allocated by malloc.

Malloc

Syntax

void* malloc(size_t size);
  • size: The number of bytes to allocate.
  • Return Value: A pointer to the allocated memory, or NULL if the allocation fails.

Example

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

int main() {
    int *ptr;
    int n, i;

    // Number of elements
    n = 5;
    printf("Enter number of elements: %d\n", n);

    // Dynamically allocate memory using malloc
    ptr = (int*)malloc(n * sizeof(int));

    // Check if the memory has been successfully allocated by malloc
    if (ptr == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    } else {
        // Memory has been successfully allocated
        printf("Memory successfully allocated using malloc.\n");

        // Get the elements of the array
        for (i = 0; i < n; ++i) {
            ptr[i] = i + 1;
        }

        // Print the elements of the array
        printf("The elements of the array are: ");
        for (i = 0; i < n; ++i) {
            printf("%d ", ptr[i]);
        }
    }

    return 0;
}

Explanation

  1. Include Headers: #include <stdlib.h> for malloc and free, and #include <stdio.h> for input/output functions.
  2. Pointer Declaration: int *ptr; declares a pointer to an integer.
  3. Memory Allocation: ptr = (int*)malloc(n * sizeof(int)); allocates memory for n integers.
  4. Null Check: Checks if malloc returned NULL, indicating a failure to allocate memory.
  5. Using Allocated Memory: Assigns values to the allocated memory and prints them.

Free

Syntax

void free(void* ptr);
  • ptr: Pointer to the memory to be deallocated.

Example

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

int main() {
    int *ptr;
    int n, i;

    // Number of elements
    n = 5;
    printf("Enter number of elements: %d\n", n);

    // Dynamically allocate memory using malloc
    ptr = (int*)malloc(n * sizeof(int));

    // Check if the memory has been successfully allocated by malloc
    if (ptr == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    } else {
        // Memory has been successfully allocated
        printf("Memory successfully allocated using malloc.\n");

        // Get the elements of the array
        for (i = 0; i < n; ++i) {
            ptr[i] = i + 1;
        }

        // Print the elements of the array
        printf("The elements of the array are: ");
        for (i = 0; i < n; ++i) {
            printf("%d ", ptr[i]);
        }

        // Free the allocated memory
        free(ptr);
        printf("\nMemory successfully freed.\n");
    }

    return 0;
}

Explanation

  1. Memory Deallocation: free(ptr); deallocates the memory previously allocated by malloc.
  2. Good Practice: Always free dynamically allocated memory to avoid memory leaks.

Practical Exercises

Exercise 1: Allocate and Free Memory

Write a program that:

  1. Allocates memory for an array of 10 integers.
  2. Assigns values to the array.
  3. Prints the values.
  4. Frees the allocated memory.

Solution

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

int main() {
    int *arr;
    int i;

    // Allocate memory for 10 integers
    arr = (int*)malloc(10 * sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    // Assign values to the array
    for (i = 0; i < 10; i++) {
        arr[i] = i + 1;
    }

    // Print the values
    printf("Array values: ");
    for (i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // Free the allocated memory
    free(arr);

    return 0;
}

Common Mistakes and Tips

  • Not Checking for NULL: Always check if malloc returns NULL to handle memory allocation failures gracefully.
  • Double Freeing: Do not call free on the same pointer more than once.
  • Using Freed Memory: Avoid using memory after it has been freed.

Conclusion

In this section, we covered the basics of dynamic memory allocation using malloc and free. Understanding these functions is crucial for efficient memory management in C. Practice the exercises to reinforce your understanding and ensure you handle memory allocation and deallocation correctly.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved