2D and 3D Arrays in C++: Managing Data Across Multiple Dimensions
What is 2D and 3D Arrays in C++: Managing Data Across Multiple Dimensions? In C++, arrays allow us to store multiple values of the same data type in a single variable. A one-dimensional array stores values in a simple sequence. However...
How are multidimensional arrays mapped to row-major linear memory in C++?
Explanation & In-Depth Details
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">numbers</span>[<span class="js-num">5</span>] <span class="js-op">=</span> <span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">};</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">numbers</span>[<span class="js-num">2</span>]<span class="js-op">;</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">30</span></code></pre></div><p>A two-dimensional array uses two indexes, while a three-dimensional array uses three indexes.</p><table><tbody><tr><th>Array type</th><th>Number of indexes</th><th>Example</th></tr><tr><td>1D array</td><td>1</td><td><code>numbers[2]</code></td></tr><tr><td>2D array</td><td>2</td><td><code>matrix[1][2]</code></td></tr><tr><td>3D array</td><td>3</td><td><code>data[1][2][3]</code></td></tr></tbody></table><p>Multidimensional arrays are useful when data naturally fits into tables, grids, or groups of tables.</p><h2>2. Two-Dimensional Arrays in C++</h2><p>A two-dimensional array (2D array) stores data in rows and columns. You can think of it as a table in which each element has a row position and a column position.</p><p>For example, consider this table:</p><table><tbody><tr><th></th><th>Column 0</th><th>Column 1</th><th>Column 2</th></tr><tr><td>Row 0</td><td>10</td><td>20</td><td>30</td></tr><tr><td>Row 1</td><td>40</td><td>50</td><td>60</td></tr><tr><td>Row 2</td><td>70</td><td>80</td><td>90</td></tr></tbody></table><p>The table can be represented using a 2D array in C++.</p><h3>2.1 Syntax of a 2D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">data_type</span> <span class="js-id">array_name</span>[<span class="js-id">rows</span>][<span class="js-id">columns</span>]<span class="js-op">;</span></code></pre></div><p>Here:</p><ul><li><p><code>data_type</code> specifies the type of values.</p></li><li><p><code>array_name</code> is the name of the array.</p></li><li><p><code>rows</code> specifies the number of rows.</p></li><li><p><code>columns</code> specifies the number of columns.</p></li></ul><p>Example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">3</span>][<span class="js-num">3</span>]<span class="js-op">;</span></code></pre></div><p>This creates an integer array containing 3 rows and 3 columns, with a total capacity of 9 elements.</p><h3>2.2 Declaring and Initializing a 2D Array</h3><p>You can initialize a 2D array when declaring it.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">0</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">1</span>][<span class="js-num">2</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">60</span></code></pre></div><p>Explanation:</p><ul><li><p><code>matrix[0][0]</code> accesses the first row and first column.</p></li><li><p><code>matrix[1][2]</code> accesses the second row and third column.</p></li><li><p>Array indexing starts from zero in C++.</p></li></ul><p>You can also write the initialization in a single line:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>The values are placed in row-major order: the first row is filled before the second row.</p><h3>2.3 Accessing Elements of a 2D Array</h3><p>To access an element, specify its row index and column index.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">0</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">0</span>][<span class="js-num">1</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">1</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">1</span>][<span class="js-num">1</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">20</span>
<span class="js-num">30</span>
<span class="js-num">40</span></code></pre></div><p>The expression <code>matrix[row][column]</code> identifies one specific element.</p><h3>2.4 Updating Elements in a 2D Array</h3><p>You can change an array element by assigning a new value to its position.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">matrix</span>[<span class="js-num">0</span>][<span class="js-num">1</span>] <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span>
<span class="js-id">matrix</span>[<span class="js-num">1</span>][<span class="js-num">0</span>] <span class="js-op">=</span> <span class="js-num">200</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">0</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-str">" "</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">0</span>][<span class="js-num">1</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">1</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-str">" "</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-num">1</span>][<span class="js-num">1</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">100</span>
<span class="js-num">200</span> <span class="js-num">40</span></code></pre></div><p>The values at row 0, column 1 and row 1, column 0 have been updated.</p><h2>3. Traversing a 2D Array Using Nested Loops</h2><p>Nested loops are commonly used to access every element of a 2D array.</p><p>The outer loop processes rows, while the inner loop processes columns.</p><h3>Example: Display All Elements of a 2D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">3</span>][<span class="js-num">3</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">70</span><span class="js-op">,</span> <span class="js-num">80</span><span class="js-op">,</span> <span class="js-num">90</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">3</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">3</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">20</span> <span class="js-num">30</span>
<span class="js-num">40</span> <span class="js-num">50</span> <span class="js-num">60</span>
<span class="js-num">70</span> <span class="js-num">80</span> <span class="js-num">90</span></code></pre></div><p>Explanation:</p><ol start="1"><li><p>The outer loop controls the row index <code>i</code>.</p></li><li><p>The inner loop controls the column index <code>j</code>.</p></li><li><p><code>matrix[i][j]</code> accesses each element.</p></li><li><p><code>endl</code> moves the output to the next line after each row.</p></li></ol><h3>Example: Taking User Input in a 2D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">2</span>]<span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Enter 4 numbers: "</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cin</span> <span class="js-op">>></span> <span class="js-id">matrix</span>[<span class="js-id">i</span>][<span class="js-id">j</span>]<span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Matrix:"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Sample input:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">20</span>
<span class="js-num">30</span> <span class="js-num">40</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Enter</span> <span class="js-num">4</span> <span class="js-id">numbers</span><span class="js-op">:</span>
<span class="js-id">Matrix</span><span class="js-op">:</span>
<span class="js-num">10</span> <span class="js-num">20</span>
<span class="js-num">30</span> <span class="js-num">40</span></code></pre></div><p>This approach is useful when the number of rows and columns is known before the program runs.</p><h2>4. Practical Operations on 2D Arrays</h2><p>2D arrays are commonly used in mathematical and data-processing operations.</p><h3>4.1 Addition of Two Matrices</h3><p>Two matrices with the same number of rows and columns can be added by adding their corresponding elements.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">a</span>[<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">1</span><span class="js-op">,</span> <span class="js-num">2</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">3</span><span class="js-op">,</span> <span class="js-num">4</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">int</span> <span class="js-id">b</span>[<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">5</span><span class="js-op">,</span> <span class="js-num">6</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">7</span><span class="js-op">,</span> <span class="js-num">8</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">int</span> <span class="js-id">result</span>[<span class="js-num">2</span>][<span class="js-num">2</span>]<span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">result</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op">=</span> <span class="js-id">a</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op">+</span> <span class="js-id">b</span>[<span class="js-id">i</span>][<span class="js-id">j</span>]<span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Addition result:"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">result</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Addition</span> <span class="js-id">result</span><span class="js-op">:</span>
<span class="js-num">6</span> <span class="js-num">8</span>
<span class="js-num">10</span> <span class="js-num">12</span></code></pre></div><h3>4.2 Finding the Sum of All Elements</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">int</span> <span class="js-id">sum</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">3</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">sum</span> <span class="js-op">+=</span> <span class="js-id">matrix</span>[<span class="js-id">i</span>][<span class="js-id">j</span>]<span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Total sum: "</span> <span class="js-op"><<</span> <span class="js-id">sum</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Total</span> <span class="js-id">sum</span><span class="js-op">:</span> <span class="js-num">210</span></code></pre></div><h2>5. Three-Dimensional Arrays in C++</h2><p>A three-dimensional array (3D array) stores values across three indexes. It can be understood as a collection of two-dimensional tables.</p><p>For example, imagine a school that stores marks for multiple classes, students, and subjects. A 3D array can represent these three dimensions.</p><p>A 3D array uses:</p><ol start="1"><li><p>First index: identifies a group or layer.</p></li><li><p>Second index: identifies a row.</p></li><li><p>Third index: identifies a column.</p></li></ol><h3>5.1 Syntax of a 3D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">data_type</span> <span class="js-id">array_name</span>[<span class="js-id">depth</span>][<span class="js-id">rows</span>][<span class="js-id">columns</span>]<span class="js-op">;</span></code></pre></div><p>Example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">data</span>[<span class="js-num">2</span>][<span class="js-num">3</span>][<span class="js-num">4</span>]<span class="js-op">;</span></code></pre></div><p>This creates an array with:</p><ul><li><p>2 layers</p></li><li><p>3 rows per layer</p></li><li><p>4 columns per row</p></li><li><p>24 total integer elements</p></li></ul><h3>5.2 Declaring and Initializing a 3D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">data</span>[<span class="js-num">2</span>][<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">}</span>
<span class="js-op">},</span>
<span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">70</span><span class="js-op">,</span> <span class="js-num">80</span><span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-num">0</span>][<span class="js-num">0</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-num">0</span>][<span class="js-num">1</span>][<span class="js-num">1</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-num">1</span>][<span class="js-num">0</span>][<span class="js-num">0</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-num">1</span>][<span class="js-num">1</span>][<span class="js-num">1</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">40</span>
<span class="js-num">50</span>
<span class="js-num">80</span></code></pre></div><p>Explanation:</p><ul><li><p><code>data[0][0][0]</code> accesses the first layer, first row, first column.</p></li><li><p><code>data[0][1][1]</code> accesses the first layer, second row, second column.</p></li><li><p><code>data[1][0][0]</code> accesses the second layer, first row, first column.</p></li><li><p><code>data[1][1][1]</code> accesses the second layer, second row, second column.</p></li></ul><h3>5.3 Accessing and Updating 3D Array Elements</h3><p>A 3D array element is accessed using three indexes.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">data</span>[<span class="js-num">2</span>][<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">1</span><span class="js-op">,</span> <span class="js-num">2</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">3</span><span class="js-op">,</span> <span class="js-num">4</span><span class="js-op">}</span>
<span class="js-op">},</span>
<span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">5</span><span class="js-op">,</span> <span class="js-num">6</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">7</span><span class="js-op">,</span> <span class="js-num">8</span><span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">data</span>[<span class="js-num">1</span>][<span class="js-num">0</span>][<span class="js-num">1</span>] <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Updated value: "</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-num">1</span>][<span class="js-num">0</span>][<span class="js-num">1</span>]<span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Updated</span> <span class="js-id">value</span><span class="js-op">:</span> <span class="js-num">100</span></code></pre></div><p>The value at the second layer, first row, and second column has been changed to <code>100</code>.</p><h2>6. Traversing a 3D Array Using Three Nested Loops</h2><p>Three nested loops are used to process every element in a 3D array.</p><ul><li><p>The first loop controls the layer.</p></li><li><p>The second loop controls the row.</p></li><li><p>The third loop controls the column.</p></li></ul><h3>Example: Display All Elements of a 3D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">data</span>[<span class="js-num">2</span>][<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">}</span>
<span class="js-op">},</span>
<span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">70</span><span class="js-op">,</span> <span class="js-num">80</span><span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Layer "</span> <span class="js-op"><<</span> <span class="js-id">i</span> <span class="js-op">+</span> <span class="js-num">1</span> <span class="js-op"><<</span> <span class="js-str">":"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">k</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">k</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">k</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-id">i</span>][<span class="js-id">j</span>][<span class="js-id">k</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Layer</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-num">10</span> <span class="js-num">20</span>
<span class="js-num">30</span> <span class="js-num">40</span>
<span class="js-id">Layer</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-num">50</span> <span class="js-num">60</span>
<span class="js-num">70</span> <span class="js-num">80</span></code></pre></div><p>The three loops ensure that every element is visited exactly once.</p><h3>Example: Taking User Input in a 3D Array</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">data</span>[<span class="js-num">2</span>][<span class="js-num">2</span>][<span class="js-num">2</span>]<span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Enter 8 numbers:"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">k</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">k</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">k</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cin</span> <span class="js-op">>></span> <span class="js-id">data</span>[<span class="js-id">i</span>][<span class="js-id">j</span>][<span class="js-id">k</span>]<span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Stored values:"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Layer "</span> <span class="js-op"><<</span> <span class="js-id">i</span> <span class="js-op">+</span> <span class="js-num">1</span> <span class="js-op"><<</span> <span class="js-str">":"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">k</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">k</span> <span class="js-op"><</span> <span class="js-num">2</span><span class="js-op">;</span> <span class="js-id">k</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">data</span>[<span class="js-id">i</span>][<span class="js-id">j</span>][<span class="js-id">k</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Sample input:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">1</span> <span class="js-num">2</span> <span class="js-num">3</span> <span class="js-num">4</span> <span class="js-num">5</span> <span class="js-num">6</span> <span class="js-num">7</span> <span class="js-num">8</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Stored</span> <span class="js-id">values</span><span class="js-op">:</span>
<span class="js-id">Layer</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-num">1</span> <span class="js-num">2</span>
<span class="js-num">3</span> <span class="js-num">4</span>
<span class="js-id">Layer</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-num">5</span> <span class="js-num">6</span>
<span class="js-num">7</span> <span class="js-num">8</span></code></pre></div><h2>7. Difference Between 2D and 3D Arrays in C++</h2><p>Both array types store multiple values, but they organize information differently.</p><table><tbody><tr><th>Feature</th><th>2D Array</th><th>3D Array</th></tr><tr><td>Dimensions</td><td>Two</td><td>Three</td></tr><tr><td>Indexes</td><td>2</td><td>3</td></tr><tr><td>Structure</td><td>Rows and columns</td><td>Layers, rows, and columns</td></tr><tr><td>Example</td><td><code>int a[3][4];</code></td><td><code>int a[2][3][4];</code></td></tr><tr><td>Number of elements</td><td>12</td><td>24</td></tr><tr><td>Common use</td><td>Tables and matrices</td><td>Groups of tables and 3D data</td></tr><tr><td>Traversal</td><td>Two nested loops</td><td>Three nested loops</td></tr></tbody></table><p>Use a 2D array when data fits into a table. Use a 3D array when the data needs an additional dimension, such as multiple tables or layers.</p><h2>8. How Multidimensional Arrays Are Stored in Memory</h2><p>C++ built-in multidimensional arrays are stored in contiguous memory using <strong>row-major order</strong>.</p><p>This means that elements in the last dimension are stored next to each other.</p><p>For example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">}</span>
<span class="js-op">};</span></code></pre></div><p>The elements are stored in this order:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">20</span> <span class="js-num">30</span> <span class="js-num">40</span> <span class="js-num">50</span> <span class="js-num">60</span></code></pre></div><p>The first row is stored before the second row.</p><p>For a 3D array, the last index changes fastest, followed by the middle index and then the first index.</p><p>Understanding this memory layout is useful when working with pointers, performance optimization, and multidimensional data processing.</p><h2>9. Passing Multidimensional Arrays to Functions</h2><p>You can pass a multidimensional array to a function. However, for a built-in array, the compiler needs to know the sizes of the dimensions after the first one.</p><h3>Example: Passing a 2D Array to a Function</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[][<span class="js-num">3</span>]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">rows</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-id">rows</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-num">3</span><span class="js-op">;</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">arr</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-id">display</span><span class="js-op">(</span><span class="js-id">matrix</span><span class="js-op">,</span> <span class="js-num">2</span><span class="js-op">);</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">20</span> <span class="js-num">30</span>
<span class="js-num">40</span> <span class="js-num">50</span> <span class="js-num">60</span></code></pre></div><p>The function receives the row count separately. The column count is specified as <code>3</code> in the parameter type.</p><p>For 3D arrays, the same principle applies: the dimensions after the first must be specified in the function parameter type.</p><h2>10. Real-World Applications of 2D and 3D Arrays</h2><p>Multidimensional arrays are useful in many areas of software development.</p><h3>Applications of 2D Arrays</h3><ul><li><p><strong>Student management systems:</strong> Store marks for students and subjects.</p></li><li><p><strong>Matrix calculations:</strong> Perform mathematical operations on matrices.</p></li><li><p><strong>Games:</strong> Represent chessboards, grids, and maps.</p></li><li><p><strong>Image processing:</strong> Store pixel values in a two-dimensional grid.</p></li><li><p><strong>Seating arrangements:</strong> Represent seats in rows and columns.</p></li></ul><h3>Applications of 3D Arrays</h3><ul><li><p><strong>3D graphics:</strong> Represent data across width, height, and depth.</p></li><li><p><strong>Scientific computing:</strong> Store measurements across multiple dimensions.</p></li><li><p><strong>Medical imaging:</strong> Represent voxel-based image data.</p></li><li><p><strong>Weather applications:</strong> Store measurements across locations, heights, and time periods.</p></li><li><p><strong>Simulation software:</strong> Organize data across multiple layers and dimensions.</p></li></ul><h2>11. Common Mistakes When Using Multidimensional Arrays</h2><p>Beginners sometimes make mistakes while declaring or accessing multidimensional arrays.</p><h3>Mistake 1: Using an Invalid Index</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>]<span class="js-op">;</span>
<span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">1</span>] <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span> <span class="js-cm">// Incorrect</span></code></pre></div><p>Valid row indexes are <code>0</code> and <code>1</code>. Valid column indexes are <code>0</code>, <code>1</code>, and <code>2</code>.</p><p>C++ does not automatically check built-in array bounds. Accessing an element outside the array's valid range causes undefined behavior.</p><h3>Mistake 2: Confusing Rows and Columns</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">3</span>]<span class="js-op">;</span></code></pre></div><p>This array has 2 rows and 3 columns, not 3 rows and 2 columns.</p><p>Always check the order of dimensions.</p><h3>Mistake 3: Using the Wrong Number of Loops</h3><p>A 2D array normally requires two nested loops for full traversal. A 3D array normally requires three.</p><p>Using incorrect loop limits can skip elements or access memory outside the array.</p><h3>Mistake 4: Forgetting to Initialize Elements</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">2</span>]<span class="js-op">;</span></code></pre></div><p>If this is a local array, its elements are not automatically initialized to zero. Reading them before assigning values results in undefined behavior.</p><p>Initialize the array when appropriate:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">matrix</span>[<span class="js-num">2</span>][<span class="js-num">2</span>] <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>This initializes all elements to zero.</p><h3>Mistake 5: Allocating an Array That Is Too Large</h3><p>Large built-in arrays declared as local variables can exceed available automatic storage. Consider dynamic containers such as <code>std::vector</code> for large or runtime-sized data.</p><h2>12. Best Practices for Using 2D and 3D Arrays</h2><p>Follow these practices to write reliable and readable C++ programs:</p><ol start="1"><li><p>Choose the number of dimensions based on how the data is organized.</p></li><li><p>Use meaningful array names such as <code>studentMarks</code> or <code>temperatureData</code>.</p></li><li><p>Keep loop limits consistent with the array dimensions.</p></li><li><p>Initialize elements before reading them.</p></li><li><p>Avoid accessing elements outside valid indexes.</p></li><li><p>Use constants for fixed dimensions to reduce repeated numbers.</p></li><li><p>Consider <code>std::vector</code> when dimensions or sizes need to be determined at runtime.</p></li><li><p>Consider <code>std::array</code> for fixed-size arrays when you want a standard container interface.</p></li><li><p>Use functions to separate array processing from the main program.</p></li><li><p>Prefer readable code over unnecessarily complicated nested loops.</p></li></ol><h2>13. Built-in Multidimensional Arrays vs std::vector</h2><p>Built-in arrays are useful when dimensions are fixed. However, modern C++ provides containers that are often more flexible.</p><table><tbody><tr><th>Feature</th><th>Built-in Array</th><th><code>std::vector</code></th></tr><tr><td>Size</td><td>Fixed</td><td>Can grow or shrink</td></tr><tr><td>Dynamic sizing</td><td>Not directly</td><td>Supported</td></tr><tr><td>Memory management</td><td>Automatic for local arrays</td><td>Managed by the container</td></tr><tr><td>Bounds checking</td><td>No automatic checking</td><td><code>at()</code> provides bounds checking</td></tr><tr><td>Nested dimensions</td><td>Built-in multidimensional syntax</td><td>Nested vectors can represent multiple dimensions</td></tr><tr><td>Suitable for</td><td>Small, fixed-size data</td><td>Dynamic collections</td></tr></tbody></table><p>Example of a 2D vector:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">vector</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">vector</span><span class="js-op"><</span><span class="js-id">vector</span><span class="js-op"><</span><span class="js-id">int</span><span class="js-op">>></span> <span class="js-id">matrix</span> <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">},</span>
<span class="js-op">{</span><span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">}</span>
<span class="js-op">};</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op"><</span> <span class="js-id">matrix</span><span class="js-op">.</span><span class="js-id">size</span><span class="js-op">();</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">j</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">j</span> <span class="js-op"><</span> <span class="js-id">matrix</span>[<span class="js-id">i</span>]<span class="js-op">.</span><span class="js-id">size</span><span class="js-op">();</span> <span class="js-id">j</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">matrix</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op"><<</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Output:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">20</span> <span class="js-num">30</span>
<span class="js-num">40</span> <span class="js-num">50</span> <span class="js-num">60</span></code></pre></div><p>A nested vector is flexible, but its rows are separate vector objects and are not necessarily stored as one contiguous rectangular block. Choose the data structure according to your requirements.</p><h2>14. Frequently Asked Questions (FAQs)</h2><h3>1. What is a 2D array in C++?</h3><p>A 2D array is an array that stores elements in rows and columns. Each element is accessed using two indexes.</p><h3>2. What is a 3D array in C++?</h3><p>A 3D array stores elements using three indexes, representing layers, rows, and columns.</p><h3>3. How many elements can a 2D array store?</h3><p>The total number of elements is the number of rows multiplied by the number of columns.</p><p>For example, <code>int arr[3][4]</code> can store 12 elements.</p><h3>4. How many elements can a 3D array store?</h3><p>Multiply all three dimensions.</p><p>For example, <code>int arr[2][3][4]</code> can store 24 elements.</p><h3>5. How do you access an element in a 2D array?</h3><p>Use the syntax:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">array_name</span>[<span class="js-id">row</span>][<span class="js-id">column</span>]<span class="js-op">;</span></code></pre></div><h3>6. How do you access an element in a 3D array?</h3><p>Use the syntax:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">array_name</span>[<span class="js-id">layer</span>][<span class="js-id">row</span>][<span class="js-id">column</span>]<span class="js-op">;</span></code></pre></div><h3>7. Which loops are used to traverse a 2D array?</h3><p>Two nested loops are commonly used: an outer loop for rows and an inner loop for columns.</p><h3>8. Which loops are used to traverse a 3D array?</h3><p>Three nested loops are commonly used to process layers, rows, and columns.</p><h3>9. Are multidimensional arrays stored continuously in memory?</h3><p>Yes. Built-in C++ multidimensional arrays use contiguous memory and row-major order.</p><h3>10. Can we pass a 2D array to a function in C++?</h3><p>Yes. The dimensions after the first must be specified in the function parameter type for a built-in multidimensional array.</p><h3>11. Can we use vectors instead of multidimensional arrays?</h3><p>Yes. Nested <code>std::vector</code> objects can represent 2D or higher-dimensional collections and support runtime sizing.</p><h3>12. What is the difference between a 2D and a 3D array?</h3><p>A 2D array uses two indexes to organize data into rows and columns. A 3D array uses three indexes to organize data into layers, rows, and columns.</p>
Code Example
#include <iostream>
int main() {
const int ROWS = 3;
const int COLS = 4;
int grid[ROWS][COLS] = {
{10, 20, 30, 40},
{50, 60, 70, 80},
{90, 100, 110, 120}
};
std::cout << "2D Grid Visualization:
";
for (int r = 0; r < ROWS; ++r) {
for (int c = 0; c < COLS; ++c) {
std::cout << grid[r][c] << " ";
}
std::cout << "
";
}
return 0;
}Interview Question & Tips
A: Row-major iteration accesses contiguous memory addresses sequentially, loading full CPU cache lines (64 bytes). Column-major access jumps across rows, causing frequent CPU cache misses and memory bus stalls.
Q: How do you declare a dynamically sized 2D matrix in modern C++?
A: Use a flattened 1D `std::vector<T>` of size `rows * cols` and index via `vec[r * cols + c]` to preserve contiguous memory layout, or use `std::vector<std::vector<T>>` for ragged arrays.
Best Practices
2. Prefer flattened 1D vectors `vector<int>(rows * cols)` over `vector<vector<int>>` for high-performance matrix computing.
3. Pass multidimensional array parameters with explicit column dimensions.
This study reference for 2D and 3D Arrays in C++: Managing Data Across Multiple Dimensions is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation: