Section 6: Memory Management

Lesson 1: Dynamic Memory Allocation in C

1.1 malloc, free, calloc, realloc Functions

Dynamic memory allocation in C involves using functions like malloc, free, calloc, and realloc to manage memory on the heap.

Example (Dynamic Memory Allocation in C): 

#include <stdio.h>

#include <stdlib.h>

int main() {

    // Allocating memory for an integer

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

    if (numPtr != NULL) {

        *numPtr = 42;

        printf("Dynamic Integer: %d\n", *numPtr);

        // Freeing allocated memory

        free(numPtr);

    }

    // Allocating memory for an array of integers

    int* arrPtr = (int*)calloc(3, sizeof(int));

    if (arrPtr != NULL) {

        arrPtr[0] = 1;

        arrPtr[1] = 2;

        arrPtr[2] = 3;

        // Reallocating memory for an expanded array

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

        // Freeing allocated memory

        free(arrPtr);

    }

    return 0;

}

1.2 Memory Leaks and Memory Management Practices

Memory leaks occur when allocated memory is not properly deallocated. Adopting best practices, such as freeing memory after use and checking for null pointers, helps prevent memory leaks.

Example (Memory Management Practices in C): 

#include <stdlib.h>

int main() {

    // Allocating memory for a string

    char* str = (char*)malloc(10 * sizeof(char));

    if (str != NULL) {

        // Use the allocated memory

        // Freeing allocated memory

        free(str);

    }

    // Check for null pointer after freeing

    if (str != NULL) {

        // Attempting to access str after freeing may lead to issues

    }

    return 0;

}

Lesson 2: Memory Management in C++

2.1 Introduction to new and delete Operators

C++ introduces the new and delete operators for dynamic memory allocation and deallocation, providing a more convenient and type-safe approach.

Example (Dynamic Memory Allocation in C++): 

#include <iostream>

int main() {

    // Allocating memory for an integer

    int* numPtr = new int;

    if (numPtr != nullptr) {

        *numPtr = 42;

        std::cout << "Dynamic Integer: " << *numPtr << std::endl;

        // Deallocating memory

        delete numPtr;

    }

    // Allocating memory for an array of integers

    int* arrPtr = new int[3];

    if (arrPtr != nullptr) {

        arrPtr[0] = 1;

        arrPtr[1] = 2;

        arrPtr[2] = 3;

        // Reallocating memory for an expanded array

        int* newArrPtr = new int[5];

        std::copy(arrPtr, arrPtr + 3, newArrPtr);

        delete[] arrPtr;

        arrPtr = newArrPtr;

        // Deallocating memory

        delete[] arrPtr;

    }

    return 0;

}

2.2 Smart Pointers in Modern C++

Modern C++ introduces smart pointers, like std::unique_ptr and std::shared_ptr, which automatically manage memory and help prevent memory leaks.

Example (Smart Pointers in C++): 

#include <iostream>

#include <memory>

int main() {

    // Using std::unique_ptr for single ownership

    std::unique_ptr<int> numPtr = std::make_unique<int>(42);

    std::cout << "Dynamic Integer: " << *numPtr << std::endl;

    // Using std::shared_ptr for shared ownership

    std::shared_ptr<int> sharedNumPtr = std::make_shared<int>(42);

    std::cout << "Shared Dynamic Integer: " << *sharedNumPtr << std::endl;

    // Memory management is automatic - no need for explicit deallocation

    return 0;

}

Understanding dynamic memory allocation and memory management practices is crucial for developing efficient and reliable C and C++ programs. Practice using appropriate functions/operators and adopt smart pointers when applicable to improve code safety.