Two-Dimensional Arrays in C++

What Will You Learn in This Guide?

This guide will cover the most efficient way to organize data in tabular form in C++.
teaches the use of two-dimensional arrays (2D arrays / matrices) from start to finish.
Static and dynamic definition, populating with user input, matrix aggregation,
You will see step by step critical issues such as passing arrays to functions and CPU cache optimization.

• Also why use std::vector<std::vector<int>> in modern C++
  You will learn that it is safer and more practical than classical C-style dynamic arrays.

Technical Summary

This guide explains both static and dynamic usage of 2D arrays in C++.
Main steps:

• Defining an array and initializing it with nested parentheses
• Accessing and receiving data from the user with nested loops
• Matrix addition operations
• Passing rules to functions (column size specification)
• Dynamic memory management (new[] and delete[])
• row-major access for CPU cache

---

1. Introduction and Definition of Two-Dimensional Arrays

In C++, a 2D array is a basic data structure that organizes data into rows and columns.
Each element is accessed with the index [satır][sütun].

Static Definition and Initialization

Static arrays are arrays whose size is fixed at compile time.
The most readable method of definition is to separate each line with curly braces.

// 4 satır ve 2 sütundan oluşan bir ürün tablosu
int urun_katalogu[4][2] = {
    {1234, 56},  // Ürün ID, Stok Adedi
    {1212, 33},
    {1434, 80},
    {1312, 78}
};

• Attention: Column size must be specified in 2D arrays. Line size can be omitted from the initialization list by the compiler.

---

2. Accessing and Manipulating Array Elements

Printing the Array

#include <iostream>
using namespace std;

int main() {
    int matris[3][2] = {{10, 11}, {20, 21}, {30, 31}};

    cout << "2D Matris Yazdırılıyor:\n";
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            cout << "\t" << matris[i][j];
        }
        cout << endl;
    }
    return 0;
}

All rows and columns are accessed with nested for loops and output is obtained in table format.

Receiving Data from User

#include <iostream>
using namespace std;

int main() {
    int s[2][2];

    cout << "\n2x2 Matris için değer girin:\n";
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            cout << "s[" << i << "][" << j << "] = ";
            cin >> s[i][j];
        }
    }

    cout << "\nGirilen Matris:\n";
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            cout << "\t" << s[i][j];
        }
        cout << endl;
    }

    return 0;
}

This method stores the data received from the user in matrix form and prints it to the screen.

Matrix Addition Process

for (int i = 0; i < r; i++) {
    for (int j = 0; j < c; j++) {
        m3[i][j] = m1[i][j] + m2[i][j];
    }
}

A new result matrix (m3) is created by adding the elements of the two matrices with the same index.

---

3. Passing 2D Arrays to Functions

When a 2D array is passed to the function, it is mandatory to specify the column size so that the compiler can calculate the correct address.

void yazdir(int q[][4], int satir, int sutun) {
    for (int i = 0; i < satir; i++) {
        for (int j = 0; j < sutun; j++) {
            cout << "\t" << q[i][j];
        }
        cout << endl;
    }
}

int q[][4] notation allows accessing each element of a matrix with 4 columns as q[i][j]. Alternatively, a pointer-based definition can be made as int (*q)[4].

---

🔹 4. Dynamic 2D Arrays and Memory Management

Static arrays are fixed size. If you want to get size from user, you need to use dynamic heap.

int** matris = new int*[rows];
for (int i = 0; i < rows; ++i)
    matris[i] = new int[cols];

// Kullanım tamamlandıktan sonra bellek serbest bırakılır:
for (int i = 0; i < rows; ++i)
    delete[] matris[i];
delete[] matris;

Warning: If delete[] is not used in dynamic arrays, memory leak will occur.

Modern Alternative: std::vector

#include <vector>
using namespace std;

vector<vector<int>> matris(rows, vector<int>(cols, 0));

Using std::vector automatically prevents memory leaks, its dimensions can be changed dynamically, and it is safe thanks to bounds checks.

---

5. Performance Optimization and CPU Cache

C++ arrays are stored in memory as row-major. Therefore, for maximum performance, the row should be in the outer loop and the column should be in the inner loop.

for (int i = 0; i < satir; i++) {
    for (int j = 0; j < sutun; j++) {
        // matris[i][j] verimli erişim
    }
}

• This structure keeps the data ready in the cache line of the CPU and shortens the processing time.

Alternatively, you can further speed up data access by using a single contiguous memory block (int* matris = new int[ROWS * COLS];). Elements are accessed by the formula matris[i * COLS + j].

---

Performance Table

Method	Memory Management	Performance	Security
Static Array	Compile Time	High	Medium
Dynamic Array (new[])	Manual	Medium	Low
std::vector	Auto	High	High

---

Frequently Asked Questions (FAQ)

1. Why is column size mandatory when passing 2D array to functions?

Because the compiler has to know how many elements are in each row to calculate the row offsets of the array in memory.

2. What is the most common mistake in dynamic arrays?

It means forgetting the delete[] commands. This causes a memory leak.

3. What is the advantage of using std::vector?

It manages memory automatically, resizes easily and prevents out-of-bounds accesses.

4. How do I prevent the “Out-of-Bounds” error?

Always use the < operator in loop conditions (i < NUMBER OF ROWs).

5. Why is row priority access important?

Thanks to memory sequentialization, it increases CPU cache efficiency and cycles run up to 30% faster.

---

Result

In C++, two-dimensional arrays are the cornerstone of managing tabular data. Knowing the difference between static and dynamic methods is critical for memory safety and performance. You can increase both speed and security by using std::vector <std::vector<int>> in modern C++.