2D array vs array of arrays – c++

In C++, 2D arrays and array of arrays may seem similar but differ in their structure, behavior, and use cases. Let’s break them down:

1. 2D Array

A 2D array is a single block of memory organized in a grid-like structure with rows and columns. It is defined as:

data_type array_name[rows][columns];

Characteristics of 2D Arrays

1. Contiguous Memory:
   • All elements are stored in contiguous memory blocks.
   • For example, in int arr[3][4], all 12 elements (3 rows * 4 columns) are stored sequentially in memory.
2. Fixed Dimensions:
   • Dimensions (number of rows and columns) must be known at compile time unless dynamically allocated.
3. Access Elements:
   • Accessed using two indices: array[row][column].
4. Example:

   int arr[3][4] = {
       {1, 2, 3, 4},
       {5, 6, 7, 8},
       {9, 10, 11, 12}
   };
   cout << arr[1][2]; // Outputs 7
   

5. Row-Major Storage:
   • Elements are stored row-by-row in memory.
   • Example: In int arr[2][3] = {{1, 2, 3}, {4, 5, 6}}, memory layout is:

     [1, 2, 3, 4, 5, 6]
     

2. Array of Arrays

An array of arrays is a collection of arrays where each “row” is a separate array. It is created using pointers:

data_type* array_name[rows];

Characteristics of Array of Arrays

1. Non-Contiguous Memory:
   • Each row can point to a different array, which may reside in non-contiguous memory blocks.
2. Dynamic Rows:
   • Rows can have different lengths, making it suitable for jagged arrays.
3. Access Elements:
   • Accessed similarly using two indices: array[row][column].
4. Example:

   int* arr[3];
   arr[0] = new int[4]{1, 2, 3, 4};
   arr[1] = new int[3]{5, 6, 7};
   arr[2] = new int[2]{8, 9};
   
   cout << arr[1][2]; // Outputs 7
   

5. Custom Memory Layout:
   • Memory for rows can be allocated independently.

Comparison Table

When to Use

• Use 2D arrays when:
  • Dimensions are fixed.
  • Performance is critical.
  • Contiguous memory layout is important.
• Use array of arrays when:
  • Rows can have varying lengths (jagged arrays).
  • More flexibility is required in memory allocation.

Code Comparison

2D Array

#include <iostream>
using namespace std;

int main() {
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    cout << arr[1][2] << endl; // Outputs 6
    return 0;
}

Array of Arrays

#include <iostream>
using namespace std;

int main() {
    int* arr[2];
    arr[0] = new int[3]{1, 2, 3};
    arr[1] = new int[2]{4, 5};

    cout << arr[0][1] << endl; // Outputs 2
    cout << arr[1][1] << endl; // Outputs 5

    // Free memory
    delete[] arr[0];
    delete[] arr[1];

    return 0;
}

Summary

• A 2D array is simpler and faster when dimensions are fixed and memory needs to be contiguous.
• An array of arrays is more flexible and allows dynamic and jagged structures but requires careful memory management.