Cpp Programming Dynamic Memory Allocation Complete Guide

Example 1: Using new and delete with single variables

Step by Step:

1. Include Necessary Headers: The only header needed here is <iostream> for input/output.

2. Declare Pointers: You need a pointer to hold the address of the dynamically allocated memory.

3. Allocate Memory: Use the new operator to allocate memory on the heap.

4. Deallocate Memory: Use the delete operator to free the allocated memory once it's no longer needed.

5. Program Execution: Run the program and observe how dynamic allocation works.

Code Example:

#include <iostream>

int main() {
    // Step 2: Declare a pointer for an integer
    int* ptr = nullptr;

    // Step 3: Allocate memory for one integer using new
    ptr = new int;

    // Check if memory allocation was successful
    if (ptr == nullptr) {
        std::cout << "Memory allocation failed!" << std::endl;
        return 1;
    }

    // Assign a value to the dynamically allocated memory
    *ptr = 5;

    // Step 5: Output the value stored at the allocated memory location
    std::cout << "Value at dynamically allocated memory location: " << *ptr << std::endl;

    // Step 4: Deallocate memory once we're done using it
    delete ptr;

    // Set pointer to nullptr after deleting memory
    ptr = nullptr;

    return 0;
}

Explanation:

• Step 2: Declares a pointer ptr that will hold an integer.
• Step 3: Allocates memory for a single integer and assigns the address to ptr. The allocated memory is uninitialized, so you can set it to any value.
• Memory Check: It's good practice to check if the memory allocation succeeded.
• Step 5: Dereferences ptr to access and print the integer value stored at that memory location.
• Step 4: Deallocates the memory pointed by ptr using delete. This prevents memory leaks.
• Nullify Pointer: After deletion, it is good to set the pointer to nullptr to indicate that it no longer points to valid memory.

Example 2: Using new[] and delete[] for arrays

Step by Step:

1. Include Necessary Headers: Include <iostream> and optionally <vector> or other headers for more complex examples not covered here.

2. Declare Pointers: A pointer is needed to hold the base address of the dynamically allocated array.

3. Determine Array Size: Decide the size of the array that needs to be created at runtime.

4. Allocate Memory: Use new[] to allocate memory for an array of objects.

5. Use the Array: Assign and access elements like you would with a regular static array.

6. Deallocate Memory: Use delete[] to deallocate memory after usage.

7. Program Execution: Run the program and observe dynamic array allocation.

Code Example:

#include <iostream>

int main() {
    // Step 3: Determine the size of the array at runtime
    int size;
    std::cout << "Enter size of the array: ";
    std::cin >> size;

    // Step 2: Declare a pointer for an array of integers
    int* arr = nullptr;

    // Step 4: Allocate memory for the array using new[]
    arr = new int[size];

    // Check if memory allocation was successful
    if (arr == nullptr) {
        std::cout << "Memory allocation failed!" << std::endl;
        return 1;
    }

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

    // Step 5: Print the values of the array elements
    std::cout << "Array contents: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // Step 6: Deallocate memory once we're done using it
    delete[] arr;

    // Set pointer to nullptr after deleting memory
    arr = nullptr;

    return 0;
}

Explanation:

• Step 3: Determines the size of the array dynamically based on user input.
• Step 2: Declares a pointer arr to an array of integers.
• Step 4: Allocates memory for an array of given size size.
• Allocation Check: Similar check as before to ensure memory allocation succeeded.
• Step 5: Uses a loop to assign values to each element of the array and prints them.
• Step 6: Releases the memory space allocated for the array using delete[]. This is crucial to prevent memory leaks, especially in larger applications.
• Nullify Pointer: Finally sets the array pointer arr to nullptr to avoid dangling pointers.

Example 3: Dynamically Allocating Memory for Objects

Step by Step:

1. Define a Class: Create a class Person with attributes and functions.

2. Create Objects Dynamically: Use new to allocate memory for an object of Person.

3. Access and Modify Object: Access and modify the object using the pointer.

4. Deallocate Memory: Use delete to deallocate the memory.

Code Example: