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

Dynamic Memory Allocation

Next ►
►

Dynamic memory allocation in C++ allows you to allocate memory during runtime using pointers. This is essential for creating flexible and efficient programs that can handle varying amounts of data. In this section, we will cover the following topics:

  1. Introduction to Dynamic Memory Allocation
  2. Using new and delete Operators
  3. Dynamic Arrays
  4. Common Pitfalls and Best Practices
  5. Exercises

  1. Introduction to Dynamic Memory Allocation

Dynamic memory allocation is the process of allocating memory storage during the runtime of the program. This is in contrast to static memory allocation, where the memory size is fixed at compile time.

Key Concepts:

  • Heap Memory: Memory allocated dynamically is taken from the heap.
  • Pointers: Used to reference dynamically allocated memory.

  1. Using new and delete Operators

In C++, the new operator is used to allocate memory, and the delete operator is used to deallocate memory.

Syntax:

int* ptr = new int; // Allocates memory for an integer
*ptr = 10; // Assigns value to the allocated memory
delete ptr; // Deallocates the memory

Example:

#include <iostream>
using namespace std;

int main() {
    int* ptr = new int; // Allocate memory
    *ptr = 10; // Assign value
    cout << "Value: " << *ptr << endl; // Output the value
    delete ptr; // Deallocate memory
    return 0;
}

Explanation:

  • int* ptr = new int; allocates memory for an integer and returns a pointer to it.
  • *ptr = 10; assigns the value 10 to the allocated memory.
  • delete ptr; deallocates the memory, preventing memory leaks.

  1. Dynamic Arrays

Dynamic arrays can be created using the new operator to allocate memory for an array of elements.

Syntax:

int* arr = new int[5]; // Allocates memory for an array of 5 integers
delete[] arr; // Deallocates the memory for the array

Example:

#include <iostream>
using namespace std;

int main() {
    int size;
    cout << "Enter the size of the array: ";
    cin >> size;

    int* arr = new int[size]; // Allocate memory for the array

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

    // Output array elements
    for (int i = 0; i < size; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    delete[] arr; // Deallocate memory
    return 0;
}

Explanation:

  • int* arr = new int[size]; allocates memory for an array of integers of the specified size.
  • delete[] arr; deallocates the memory for the array.

  1. Common Pitfalls and Best Practices

Common Pitfalls:

  • Memory Leaks: Forgetting to deallocate memory using delete or delete[].
  • Dangling Pointers: Using pointers after the memory has been deallocated.
  • Double Deletion: Deallocating the same memory twice.

Best Practices:

  • Always pair new with delete and new[] with delete[].
  • Set pointers to nullptr after deleting them to avoid dangling pointers.
  • Use smart pointers (e.g., std::unique_ptr, std::shared_ptr) from the C++ Standard Library to manage dynamic memory automatically.

  1. Exercises

Exercise 1:

Write a program that dynamically allocates memory for an array of integers, initializes the array with values, and then deallocates the memory.

Solution:

#include <iostream>
using namespace std;

int main() {
    int size;
    cout << "Enter the size of the array: ";
    cin >> size;

    int* arr = new int[size]; // Allocate memory for the array

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

    // Output array elements
    for (int i = 0; i < size; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    delete[] arr; // Deallocate memory
    return 0;
}

Exercise 2:

Write a program that dynamically allocates memory for a single integer, assigns a value to it, and then deallocates the memory.

Solution:

#include <iostream>
using namespace std;

int main() {
    int* ptr = new int; // Allocate memory
    *ptr = 42; // Assign value
    cout << "Value: " << *ptr << endl; // Output the value
    delete ptr; // Deallocate memory
    return 0;
}

Conclusion

In this section, we covered the basics of dynamic memory allocation in C++, including how to use the new and delete operators, how to create dynamic arrays, and best practices to avoid common pitfalls. Understanding dynamic memory allocation is crucial for writing efficient and flexible C++ programs. In the next module, we will delve into Object-Oriented Programming (OOP) concepts, which will build on the knowledge gained here.

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