2 Dimensional Array Dynamic Memory Allocation In C++

6 min read Jun 28, 2024

2 Dimensional Array Dynamic Memory Allocation in C++

Dynamic memory allocation in C++ allows you to create arrays whose size is determined at runtime. This is particularly useful when you don't know the array size beforehand or when you need a flexible data structure that can change size during program execution. This article will focus on dynamically allocating 2-dimensional arrays in C++.

Understanding the Concept

In C++, a 2-dimensional array is essentially an array of arrays. You can think of it as a table with rows and columns. To dynamically allocate a 2-dimensional array, we need to allocate memory for each row individually, effectively creating an array of pointers to rows.

Method 1: Using `new` operator

This method involves explicitly allocating memory for each row using the new operator.

#include 

int main() {
  int rows = 3;
  int cols = 4;

  // Allocate memory for rows (array of pointers)
  int** array = new int*[rows];

  // Allocate memory for each column in each row
  for (int i = 0; i < rows; ++i) {
    array[i] = new int[cols];
  }

  // Initialize the array with some values
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      array[i][j] = i * cols + j;
    }
  }

  // Access and print elements
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      std::cout << array[i][j] << " ";
    }
    std::cout << std::endl;
  }

  // Deallocate memory
  for (int i = 0; i < rows; ++i) {
    delete[] array[i];
  }
  delete[] array;

  return 0;
}

Explanation:

We first declare a double pointer array to store the pointers to the rows.
Then, we use new int*[rows] to allocate memory for rows pointers.
In a loop, we allocate memory for each row using new int[cols]. This creates an array of integers for each row.
We initialize the array elements within nested loops.
After using the array, it is important to deallocate the memory properly to avoid memory leaks. We use a loop to delete each row using delete[] and then delete the array of pointers using delete[].

Method 2: Using `std::vector`

std::vector offers a more convenient and safer way to work with dynamic arrays. It automatically handles memory management, including allocation, deallocation, and resizing.

#include 
#include 

int main() {
  int rows = 3;
  int cols = 4;

  // Create a vector of vectors
  std::vector> array(rows, std::vector(cols));

  // Initialize the array with some values
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      array[i][j] = i * cols + j;
    }
  }

  // Access and print elements
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      std::cout << array[i][j] << " ";
    }
    std::cout << std::endl;
  }

  return 0;
}

Explanation:

We create a vector of vectors, array, with rows number of elements.
Each element in array is a std::vector<int> with cols number of elements.
We initialize the array elements using nested loops.
std::vector automatically handles memory management, so no explicit deallocation is required.

Advantages of Using `std::vector`:

Automatic Memory Management: No need to manually manage memory allocation and deallocation.
Easier to Use: Simplifies array creation and manipulation compared to using new.
Safety: Reduces the risk of memory leaks and dangling pointers.

Conclusion

Dynamically allocating 2-dimensional arrays in C++ provides flexibility and control over data structures. While the new operator offers direct memory management, std::vector offers a convenient and safer alternative for working with dynamic arrays. Choosing the right approach depends on your specific requirements and coding style.

2 Dimensional Array Dynamic Memory Allocation In C++