C++ Programming 6. C++ Arrays and Strings 14 mins read 19,706 views

Passing C++ Arrays to Functions: Parameter Techniques and Examples

Arrays are used in C++ to store multiple values of the same data type in a single variable. When working with large programs, you may need to process an array i...
Published: Nov 1, 2026Last Updated: Nov 21, 2026Curriculum: Class 12 / AP Physics / JEE-NEETReviewed by: OperateTools Editorial Board
Quick Summary & Direct Answer (AEO / GEO Extraction)

What is Passing C++ Arrays to Functions: Parameter Techniques and Examples? Arrays are used in C++ to store multiple values of the same data type in a single variable. When working with large programs, you may need to process an array i...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
What are the techniques for passing arrays to functions using pointers, references, std::array, and std::span?
<p data-pm-slice="1 3 []">Arrays are used in C++ to store multiple values of the same data type in a single variable. When working with large programs, you may need to process an array in different parts of your application.</p><p>Instead of writing the same array-processing code repeatedly, you can pass an array to a function.</p><p>For example, you can create separate functions to:</p><ul data-spread="false"><li><p>Display array elements.</p></li><li><p>Calculate the sum and average.</p></li><li><p>Find the largest or smallest element.</p></li><li><p>Search for a particular value.</p></li><li><p>Update array elements.</p></li><li><p>Sort an array.</p></li></ul>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3"><span style="font-size: 1.15rem;">1. What Does Passing an Array to a Function Mean?</span></h2><p>Passing an array to a function means providing the function with access to the array elements so it can perform a particular operation.</p><p>Consider this 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">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">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">display</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">5</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></code></pre></div><p>Explanation:</p><ol start="1"><li><p>The <code>numbers</code> array is declared inside <code>main()</code>.</p></li><li><p>The <code>display()</code> function receives the array through its parameter <code>int arr[]</code>.</p></li><li><p>The <code>size</code> parameter tells the function how many elements to process.</p></li><li><p>The loop accesses each element and displays it.</p></li></ol><p><strong>Important:</strong> When a built-in array is passed to a function using an ordinary array parameter, the parameter is adjusted to a pointer type. The function does not receive a separate copy of the entire array.</p><h2>2. Syntax for Passing an Array to a Function</h2><p>The general syntax is:</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">return_type</span> <span class="js-id">function_name</span><span class="js-op">(</span><span class="js-id">data_type</span> <span class="js-id">array_name</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-cm">// Function body</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-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-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-cm">// Process array elements</span>
<span class="js-op">}</span></code></pre></div><p>Here:</p><ul><li><p><code>void</code> means the function does not return a value.</p></li><li><p><code>display</code> is the function name.</p></li><li><p><code>int arr[]</code> represents an integer array parameter.</p></li><li><p><code>size</code> represents the number of elements.</p></li></ul><p>You can also write the parameter using pointer notation:</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">arr</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">);</span></code></pre></div><p>For an ordinary function parameter, these declarations are equivalent:</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-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-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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-op">*</span> <span class="js-id">arr</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">);</span></code></pre></div><p>Both allow the function to access the elements through the pointer.</p><h2>3. Passing a One-Dimensional Array to a Function</h2><p>A one-dimensional array is the simplest type of array to pass to a function.</p><h3>Example 1: Display Array 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">displayArray</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Array elements: "</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">&lt;</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</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">&lt;&lt;</span> <span class="js-id">endl</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">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">displayArray</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">5</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">Array</span> <span class="js-id">elements</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-num">50</span></code></pre></div><p>The function receives access to the original array elements. It can read or modify them.</p><h3>Example 2: Calculate the Sum of Array 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">calculateSum</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;</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-id">sum</span> <span class="js-op">+=</span> <span class="js-id">arr</span>[<span class="js-id">i</span>]<span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-id">sum</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">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">int</span> <span class="js-id">result</span> <span class="js-op">=</span> <span class="js-id">calculateSum</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">);</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Sum: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">result</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">Sum</span><span class="js-op">:</span> <span class="js-num">150</span></code></pre></div><p>Explanation:</p><ul><li><p>The <code>calculateSum()</code> function receives the array and its size.</p></li><li><p>The loop adds every element to <code>sum</code>.</p></li><li><p>The function returns the calculated total.</p></li><li><p>The result is displayed in <code>main()</code>.</p></li></ul><h3>Example 3: Find the Largest Element</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">findLargest</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">largest</span> <span class="js-op">=</span> <span class="js-id">arr</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">1</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op">&lt;</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">if</span> <span class="js-op">(</span><span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&gt;</span> <span class="js-id">largest</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">largest</span> <span class="js-op">=</span> <span class="js-id">arr</span>[<span class="js-id">i</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-id">largest</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">numbers</span>[<span class="js-num">5</span>] <span class="js-op">=</span> <span class="js-op">{</span><span class="js-num">25</span><span class="js-op">,</span> <span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">75</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">60</span><span class="js-op">};</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Largest element: "</span>
<span class="js-op">&lt;&lt;</span> <span class="js-id">findLargest</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">5</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">Largest</span> <span class="js-id">element</span><span class="js-op">:</span> <span class="js-num">75</span></code></pre></div><p>The function starts with the first element as the largest value and compares the remaining elements against it.</p><p>This example assumes the array contains at least one element.</p><h2>4. Passing an Array Using Pointer Parameters</h2><p>In C++, an array parameter is adjusted to a pointer parameter. You can explicitly use pointer notation when declaring the function.</p><h3>Example: Access Array Elements Using Pointers</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">displayArray</span><span class="js-op">(</span><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">*(</span><span class="js-id">ptr</span> <span class="js-op">+</span> <span class="js-id">i</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">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">displayArray</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">5</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></code></pre></div><p>Explanation:</p><ul><li><p><code>int* ptr</code> declares a pointer parameter.</p></li><li><p><code>ptr</code> points to the first element when the array is passed.</p></li><li><p><code>*(ptr + i)</code> accesses the element at position <code>i</code>.</p></li><li><p><code>*(ptr + i)</code> is equivalent to <code>ptr[i]</code>.</p></li></ul><p>Pointer notation is useful when learning how arrays and memory addresses work in C++.</p><h2>5. Modifying an Array Inside a Function</h2><p>When a function receives a built-in array through an ordinary array parameter, it can modify the original elements.</p><h3>Example: Update Array 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">updateArray</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;</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-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">=</span> <span class="js-id">arr</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-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">numbers</span>[<span class="js-num">5</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-num">3</span><span class="js-op">,</span> <span class="js-num">4</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">};</span>

<span class="js-id">updateArray</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">);</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Updated array: "</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">&lt;</span> <span class="js-num">5</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">&lt;&lt;</span> <span class="js-id">numbers</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">Updated</span> <span class="js-id">array</span><span class="js-op">:</span> <span class="js-num">2</span> <span class="js-num">4</span> <span class="js-num">6</span> <span class="js-num">8</span> <span class="js-num">10</span></code></pre></div><p>The function changes the original array elements because the parameter provides access to the same underlying elements.</p><h3>Important: Passing an Array Does Not Copy Its Elements</h3><p>Compare these two situations:</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-kw">void</span> <span class="js-id">update</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">arr</span>[<span class="js-num">0</span>] <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>The function changes the original array's first element.</p><p>However, a normal pointer parameter is still passed by value. If you assign a different address to the local pointer parameter, the caller's pointer or array is not changed.</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-kw">void</span> <span class="js-id">changePointer</span><span class="js-op">(</span><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">temporary</span> <span class="js-op">=</span> <span class="js-num">500</span><span class="js-op">;</span>
<span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">temporary</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>This only changes the local pointer variable. It does not change the caller's array.</p><h2>6. Passing an Array as a Constant Parameter</h2><p>Sometimes you want a function to read array elements without modifying them.</p><p>You can use the <code>const</code> keyword.</p><h3>Syntax</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">);</span></code></pre></div><h3>Example: Read-Only Array 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">displayArray</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">numbers</span>[<span class="js-num">4</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-id">displayArray</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-num">4</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 <code>const</code> keyword prevents the function from modifying the elements through this parameter.</p><p>For example, the following assignment would cause a compilation error:</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">arr</span>[<span class="js-num">0</span>] <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span> <span class="js-cm">// Compilation error</span>
<span class="js-op">}</span></code></pre></div><p><strong>Best practice:</strong> Use <code>const</code> for functions that only need to read an array. This makes the function's intention clear and prevents accidental modification.</p><h2>7. Passing an Array by Reference</h2><p>C++ also allows you to pass an entire built-in array by reference.</p><p>Unlike an ordinary array parameter, a reference-to-array parameter retains the array's size as part of its type.</p><h3>Syntax</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-op">(&amp;</span><span class="js-id">arr</span><span class="js-op">)</span>[<span class="js-num">5</span>]<span class="js-op">);</span></code></pre></div><p>This parameter accepts an array containing exactly five integers.</p><h3>Example: Pass an Array by Reference</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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-op">(&amp;</span><span class="js-id">arr</span><span class="js-op">)</span>[<span class="js-num">5</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">&lt;</span> <span class="js-num">5</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">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">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">display</span><span class="js-op">(</span><span class="js-id">numbers</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></code></pre></div><p>Explanation:</p><ul><li><p><code>int (&amp;arr)[5]</code> declares a reference to an array of five integers.</p></li><li><p>The function receives the actual array without array-to-pointer adjustment.</p></li><li><p>The size is known from the parameter type.</p></li><li><p>The function can modify the original elements unless the reference is declared <code>const</code>.</p></li></ul><p>A read-only version is:</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-op">(&amp;</span><span class="js-id">arr</span><span class="js-op">)</span>[<span class="js-num">5</span>]<span class="js-op">);</span></code></pre></div><p>This approach is useful when the array size is fixed and you want the compiler to enforce that size.</p><h2>8. Passing an Array to a Function Using a Template</h2><p>Templates allow you to write functions that can work with arrays of different sizes without manually specifying the size in each function call.</p><h3>Example: Array Size Template</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">template</span> <span class="js-op">&lt;</span><span class="js-id">size_t</span> <span class="js-id">N</span><span class="js-op">&gt;</span>
<span class="js-kw">void</span> <span class="js-id">displayArray</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-op">(&amp;</span><span class="js-id">arr</span><span class="js-op">)</span>[<span class="js-id">N</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">size_t</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">&lt;</span> <span class="js-id">N</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">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">first</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-id">int</span> <span class="js-id">second</span>[<span class="js-num">5</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-num">3</span><span class="js-op">,</span> <span class="js-num">4</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">};</span>

<span class="js-id">displayArray</span><span class="js-op">(</span><span class="js-id">first</span><span class="js-op">);</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">displayArray</span><span class="js-op">(</span><span class="js-id">second</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">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></code></pre></div><p>Explanation:</p><ul><li><p><code>N</code> represents the array size.</p></li><li><p>The compiler determines <code>N</code> from the array passed to the function.</p></li><li><p>The array is passed by reference, so its size is preserved.</p></li><li><p>The same function works with both arrays.</p></li></ul><p>This technique is useful when working with fixed-size built-in arrays of different lengths.</p><h2>9. Passing a Two-Dimensional Array to a Function</h2><p>A two-dimensional array contains rows and columns. When passing a built-in 2D array to a function using an ordinary array parameter, the compiler must know the number of columns.</p><h3>Syntax</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-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></code></pre></div><p>Here:</p><ul><li><p><code>arr[][3]</code> represents a 2D integer array with three columns.</p></li><li><p><code>rows</code> represents the number of rows.</p></li></ul><h3>Example: Display 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">displayMatrix</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">&lt;</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">&lt;</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">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>][<span class="js-id">j</span>] <span class="js-op">&lt;&lt;</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">&lt;&lt;</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">displayMatrix</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 array and its row count. The column count is specified in the parameter type.</p><h3>Example: Calculate the Sum 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">calculateSum</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-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">&lt;</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">&lt;</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">arr</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-kw">return</span> <span class="js-id">sum</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">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Total sum: "</span>
<span class="js-op">&lt;&lt;</span> <span class="js-id">calculateSum</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-id">Total</span> <span class="js-id">sum</span><span class="js-op">:</span> <span class="js-num">210</span></code></pre></div><h2>10. Passing a Three-Dimensional Array to a Function</h2><p>A three-dimensional built-in array uses three indexes. As with a 2D array, the dimensions after the first must be specified in an ordinary function parameter.</p><h3>Syntax</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-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">2</span>][<span class="js-num">3</span>]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">layers</span><span class="js-op">);</span></code></pre></div><p>Here, the array contains two rows and three columns per layer. The number of layers is supplied separately.</p><h3>Example: Display 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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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">display3D</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">arr</span>[][<span class="js-num">2</span>][<span class="js-num">2</span>]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">layers</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">&lt;</span> <span class="js-id">layers</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">&lt;&lt;</span> <span class="js-str">"Layer "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">i</span> <span class="js-op">+</span> <span class="js-num">1</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">":"</span> <span class="js-op">&lt;&lt;</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">&lt;</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">&lt;</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">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>][<span class="js-id">j</span>][<span class="js-id">k</span>] <span class="js-op">&lt;&lt;</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">&lt;&lt;</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-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">display3D</span><span class="js-op">(</span><span class="js-id">data</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-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 function processes each layer, row, and column using three nested loops.</p><h2>11. Passing Array Size to a Function</h2><p>One important detail in C++ is that an ordinary built-in array parameter does not automatically retain the original array length.</p><p>Consider:</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-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-op">)</span> <span class="js-op">{</span>
<span class="js-cm">// The original array size is not available here.</span>
<span class="js-op">}</span></code></pre></div><p>Inside this function, <code>arr</code> is a pointer parameter. You cannot use <code>sizeof(arr)</code> to determine the size of the original array.</p><h3>Recommended Approach: Pass the Size Separately</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</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-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">numbers</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-id">int</span> <span class="js-id">size</span> <span class="js-op">=</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">)</span> <span class="js-op">/</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">numbers</span>[<span class="js-num">0</span>]<span class="js-op">);</span>

<span class="js-id">display</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">,</span> <span class="js-id">size</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 <code>sizeof</code> calculation works in <code>main()</code> because <code>numbers</code> is still an array there. The function receives the calculated size separately.</p><p>For fixed-size built-in arrays in C++17 and later, <code>std::size(numbers)</code> from the <code>&lt;iterator&gt;</code> header is another option.</p><h2>12. Passing Arrays Using std::array and std::vector</h2><p>Modern C++ provides standard containers that make array handling easier and safer.</p><h3>12.1 Passing std::array to a Function</h3><p><code>std::array</code> is a fixed-size container that retains its size and provides useful member functions.</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">array</span><span class="js-op">&gt;</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-kw">const</span> <span class="js-id">array</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">&gt;&amp;</span> <span class="js-id">numbers</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">value</span> <span class="js-op">:</span> <span class="js-id">numbers</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">array</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">&gt;</span> <span class="js-id">numbers</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">display</span><span class="js-op">(</span><span class="js-id">numbers</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></code></pre></div><p>The <code>const</code> reference avoids copying the container and prevents the function from modifying its elements.</p><h3>12.2 Passing std::vector to a Function</h3><p><code>std::vector</code> is a dynamic container that can grow or shrink during program execution.</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">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">vector</span><span class="js-op">&gt;</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-kw">const</span> <span class="js-id">vector</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">&gt;&amp;</span> <span class="js-id">numbers</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">value</span> <span class="js-op">:</span> <span class="js-id">numbers</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</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">vector</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">&gt;</span> <span class="js-id">numbers</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">display</span><span class="js-op">(</span><span class="js-id">numbers</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></code></pre></div><p>The function receives the vector by constant reference, avoiding a full copy.</p><p><strong>When should you use each approach?</strong></p><ul><li><p>Use built-in arrays when working with fixed-size low-level data.</p></li><li><p>Use <code>std::array</code> when the size is fixed and you want a standard container.</p></li><li><p>Use <code>std::vector</code> when the size may change at runtime.</p></li></ul><h2>13. Different Techniques for Passing Arrays to Functions</h2><p>The following table summarizes the most common techniques.</p><table><tbody><tr><th>Technique</th><th>Example parameter</th><th>Main characteristic</th></tr><tr><td>Array parameter</td><td><code>int arr[]</code></td><td>Adjusted to a pointer</td></tr><tr><td>Pointer parameter</td><td><code>int* arr</code></td><td>Provides access through a pointer</td></tr><tr><td>Constant array parameter</td><td><code>const int arr[]</code></td><td>Read-only access to elements</td></tr><tr><td>Array reference</td><td><code>int (&amp;arr)[5]</code></td><td>Preserves the array type and size</td></tr><tr><td>Template array reference</td><td><code>const int (&amp;arr)[N]</code></td><td>Preserves size for different arrays</td></tr><tr><td><code>std::array</code> reference</td><td><code>const array&lt;int, 5&gt;&amp;</code></td><td>Fixed-size standard container</td></tr><tr><td><code>std::vector</code> reference</td><td><code>const vector&lt;int&gt;&amp;</code></td><td>Dynamic-size standard container</td></tr></tbody></table><h2>14. Common Mistakes When Passing Arrays to Functions</h2><h3>Mistake 1: Forgetting to Pass the Array Size</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-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-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">numbers</span>[<span class="js-num">5</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-num">3</span><span class="js-op">,</span> <span class="js-num">4</span><span class="js-op">,</span> <span class="js-num">5</span><span class="js-op">};</span>

<span class="js-id">display</span><span class="js-op">(</span><span class="js-id">numbers</span><span class="js-op">);</span> <span class="js-cm">// Incorrect: missing size argument</span>
<span class="js-op">}</span></code></pre></div><p>The function expects two arguments. Pass both the array and its size.</p><h3>Mistake 2: Using sizeof() Inside the Function to Find Array Length</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-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-op">)</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">size</span> <span class="js-op">=</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">arr</span><span class="js-op">)</span> <span class="js-op">/</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">arr</span>[<span class="js-num">0</span>]<span class="js-op">);</span>
<span class="js-op">}</span></code></pre></div><p>This does not calculate the original array length because <code>arr</code> is a pointer parameter.</p><p>Pass the size separately or use an array-reference template.</p><h3>Mistake 3: Accessing Elements Outside the 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-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-op">,</span> <span class="js-id">int</span> <span class="js-id">size</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">&lt;=</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">arr</span>[<span class="js-id">i</span>]<span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span></code></pre></div><p>The loop condition should be <code>i &lt; size</code>, not <code>i &lt;= size</code>.</p><p>Accessing an element outside the valid range causes undefined behavior.</p><h3>Mistake 4: Trying to Modify a const 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-kw">void</span> <span class="js-id">update</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">arr</span>[<span class="js-num">0</span>] <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span> <span class="js-cm">// Compilation error</span>
<span class="js-op">}</span></code></pre></div><p>A <code>const</code> array parameter allows reading but not modifying elements through that parameter.</p><h3>Mistake 5: Passing a 2D Array With the Wrong Column Size</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-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></code></pre></div><p>This parameter expects three columns. A 2D array with a different column count cannot be passed as though it had three columns.</p><p>Make sure the parameter dimensions match the array type.</p><h3>Mistake 6: Passing an Empty Array to a Function That Reads Its First Element</h3><p>A function such as <code>findLargest()</code> that starts with <code>arr[0]</code> requires at least one element.</p><p>Check that the size is greater than zero before accessing the first element.</p><h2>15. Best Practices for Passing Arrays to Functions</h2><p>Follow these practices when designing array-processing functions:</p><ol start="1"><li><p>Pass the array size whenever using an ordinary built-in array parameter.</p></li><li><p>Use <code>const</code> when a function only needs to read elements.</p></li><li><p>Use a reference-to-array template when you need the built-in array size at compile time.</p></li><li><p>Use <code>std::array</code> for fixed-size collections.</p></li><li><p>Use <code>std::vector</code> for dynamically sized collections.</p></li><li><p>Avoid accessing elements outside the valid array range.</p></li><li><p>Keep array-processing functions focused on one task.</p></li><li><p>Validate sizes before accessing elements.</p></li><li><p>Use meaningful function and parameter names.</p></li><li><p>Prefer standard containers for general-purpose application development.</p></li></ol><h2>16. Frequently Asked Questions (FAQs)</h2><h3>1. Can we pass an array to a function in C++?</h3><p>Yes. You can pass a built-in array to a function using an array parameter, pointer parameter, or reference-to-array parameter.</p><h3>2. Does C++ pass an array by value or reference?</h3><p>An ordinary built-in array parameter is adjusted to a pointer parameter. The pointer is passed by value, but it provides access to the original array elements.</p><h3>3. How do you pass an array to a function using pointers?</h3><p>Declare the function parameter using pointer notation:</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">arr</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">);</span></code></pre></div><p>Pass the array name and its size when calling the function.</p><h3>4. Can a function modify an array passed to it?</h3><p>Yes. An ordinary array parameter provides access to the original elements, so changes made through that parameter affect the original array.</p><h3>5. How do you pass an array without allowing modification?</h3><p>Use a constant array parameter:</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-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">arr</span>[]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">size</span><span class="js-op">);</span></code></pre></div><h3>6. Why should we pass the array size separately?</h3><p>An ordinary built-in array parameter is adjusted to a pointer. The function does not automatically know the original array length.</p><h3>7. Can we pass a 2D array to a function?</h3><p>Yes. For an ordinary built-in 2D array parameter, specify the column dimension:</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-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></code></pre></div><h3>8. Can we pass a 3D array to a function?</h3><p>Yes. Specify the second and third dimensions in the parameter type:</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-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">2</span>][<span class="js-num">3</span>]<span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">layers</span><span class="js-op">);</span></code></pre></div><h3>9. What is the difference between int arr[] and int* arr in a function parameter?</h3><p>For an ordinary function parameter, both declarations are adjusted to the same pointer type.</p><h3>10. Is std::vector better than a built-in array?</h3><p>It depends on the requirement. <code>std::vector</code> is useful for dynamically sized data, while built-in arrays and <code>std::array</code> are useful for fixed-size data.</p><h3>11. Can we return an array directly from a C++ function?</h3><p>A built-in array cannot be returned directly by value as a function return type. You can return a suitable container such as <code>std::array</code> or <code>std::vector</code>, or use other designs involving references or pointers with careful lifetime management.</p><h3>12. What is the safest way to pass an array to a function in modern C++?</h3><p>For fixed-size data, consider passing <code>std::array</code> by constant reference. For dynamically sized data, consider passing <code>std::vector</code> by constant reference when the function only needs to read it.</p>

Code Example

#include <iostream>
#include <span>
#include <vector>

// Modern C++20 std::span accepts raw arrays, std::array, or std::vector
void printElements(std::span<const int> buffer) {
    std::cout << "Buffer (size: " << buffer.size() << "): ";
    for (int val : buffer) {
        std::cout << val << " ";
    }
    std::cout << "
";
}

int main() {
    int rawArray[] = {1, 2, 3, 4};
    std::vector<int> dynamicVec = {10, 20, 30, 40, 50};

    printElements(rawArray);   // Automatically creates span from raw array
    printElements(dynamicVec); // Automatically creates span from vector

    return 0;
}

Interview Question & Tips

Q: What is std::span in C++20 and why is it preferred for function parameters?
A: `std::span` is a lightweight, non-owning view over any contiguous sequence of objects (pointers + size). It accepts C-style arrays, `std::array`, and `std::vector` seamlessly without copying or memory allocations.

Q: Why does sizeof(arr) return pointer size inside a function taking int arr[]?
A: In function parameter declarations, `int arr[]` is syntactic sugar for `int* arr`. The array decays to a pointer, so `sizeof(arr)` evaluates to `sizeof(int*)` (typically 8 bytes on 64-bit systems).

Best Practices

1. Use `std::span<const T>` in C++20 for read-only array parameters.
2. In C++17 and earlier, pass `const std::vector<T>&` or `(const T* ptr, size_t size)`.
3. Never rely on `sizeof()` on array parameters inside functions due to pointer decay.
Academic Standards & Verified Citations

This study reference for Passing C++ Arrays to Functions: Parameter Techniques and Examples is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming