How to pass an array to a function in C++

Arrays are useful data types for data structures in C++ programming and beyond. In simple terms, arrays allow you to store data as an ordered list. You can use arrays to easily sort or calculate information about a collection of data using a single array name.

Today, we’ll discuss how to pass arrays to functions in C++. Along the way, we’ll cover why we use C++ arrays, as well as how to declare and initialize them. We’ll then pass them to functions and discuss important distinctions about arrays in C++. This article includes tutorials for both one-dimensional and two-dimensional arrays.

As illustrated in the diagram, C++ has the following data types:

• Primitive (or fundamental) data types
• Derived data types
• User-defined data types

Arrays are derived data types. Derived data types are composed of primitive or built-in data types. Derived data types have some of the abilities that primitive data types lack. For instance, primitive data types can’t store more than one value at a time, while arrays can.

Arrays allow you to store and access multiple values of the same data type under a single name. Arrays are useful when you’re dealing with a large amount of data. For instance, given data on 100 students and their grades, it would be tedious to declare 100 variables to store each student’s grade. Instead, we’d use an array to store all the data under a single name.

Basic terms associated with arrays are elements of the array, index of the array, and size of the array.

• Element: Refers to values stored in an array (at neighboring memory locations)
• Index: Refers to an array element’s position, starting from 0 and increasing incrementally by one for each additional element
• Size: Refers to the total number of elements stored in an array

Here’s an illustration of an array with six elements. The array size is six according to the number of elements. Each of the six elements are stored at their respective indexes (e.g. the first element of the array, 10, is stored in index zero).

A two-dimensional array (or 2-d array) is an array of arrays. Two-dimensional arrays represent a matrix. They are the most commonly used multidimensional arrays. We can access the elements in a two-dimensional array by specifying their row and column index, which start at zero and increase incrementally with each added element.

This matrix illustration represents an array of size nine. Each of the nine elements are stored at a respective row and column index.

A pointer is another derived data type that’s relevant to today’s discussion. We’ll discuss more about pointers toward the end of this article.

How to declare a two-dimensional array#

The general syntax for declaring a two-dimensional array involves specifying the data type, array name, row index, and column index:

DataType ArrayName [RowSize] [ColumnSize];

In this code, we declare a two-dimensional array Student[10][5] that can hold 10 arrays of Student[5]. Each Student[5] array can store five integer values. The compiler reserves space for 50 elements (10*5) of the int data type consecutively in memory.

How to initialize a two-dimensional array#

The general syntax for initializing a two-dimensional array is:

ArrayName [RowIndex] [ColumnIndex] = Value;

This code initializes a two-dimensional array that stores: 100 at row index 0 and column index 0, 134 at row index 0 and column index 1, and so on.

How to declare and initialize two-dimensional arrays#

The general syntax to initialize and declare a two-dimensional array is:

DataType ArrayName [] [] = {{value1,…,valueN},…{value1,…,valueN}}

In this example, we initialize the Student[][3] array in the declaration step. Specifying the first dimension is optional when initializing two-dimensional arrays. The compiler will infer the number of rows from your statement. That’s why the code in this example is written with Student[][3] instead of Student[3][3].

Passing array along with its size (safe parameterization)#

When you pass an array to a function in C++, it’s almost always necessary to also pass the size (or length) of the array so the function knows how many elements it can safely access. A common pattern:

void process(int arr[], int n) {
    for (int i = 0; i < n; ++i) {
        // safe access arr[i]
    }
}

Call it like:

int data[5] = {1, 2, 3, 4, 5};
process(data, 5);

Alternatively:

void process(int *arr, size_t n);

Note: inside process, sizeof(arr) will not yield the full array size because arr decays to a pointer. That’s why passing explicit n is essential. Many bugs arise when code assumes a global constant size or miscalculates bounds.

Using const and read-only arrays#

When a function does not need to modify the array, express that intention using const. This helps with safety and clarity:

void print(const int arr[], int n) {
    for (int i = 0; i < n; ++i) {
        std::cout << arr[i] << " ";
    }
}

Because arr is const, any attempt to write arr[i] = 5; will be a compile error. If you’re passing an entire buffer for read-only purposes, this is best practice when using pass array to function in C++.

You can also use:

void print(const int *arr, size_t n);

Or:

void print(const int arr[/*n*/], size_t n);

All three are equivalent in meaning thanks to pointer decay, but including const is a strong documentation aid.

Passing two-dimensional arrays to functions#

In this example, we’ll pass the two-dimensional array int n[][2] to a function we define as display() and print the array’s elements. For the function call, we only pass the array’s name as the function argument display(num).

Dynamic and jagged arrays, vectors, and std::array#

Static arrays suffer from fixed size limitations. In modern C++ development, you’ll often use:

• Dynamic 2D arrays (pointer of pointers):

  int **grid = new int*[rows];
  for (int i = 0; i < rows; ++i)
      grid[i] = new int[cols];
  // pass grid and sizes
  void process(int** arr, int r, int c);
  

• std::vector<vector<int>> or flat vector<int> with stride:

  void process(const std::vector<std::vector<int>>& mat);
  

• std::array<T, N>: a fixed-size array that behaves like a value object:

  void f(std::array<int, 5> arr);
  

When you use these modern container types, you shift from raw pointer arithmetic and make your code safer and more idiomatic. They also integrate well with memory management and RAII.

Returning arrays or array-like results from functions#

Sometimes you want a function not just to consume but to produce an array-like result. You can’t directly return a built-in C-style array from a function, but you can do:

• Return a pointer (heap-allocated), with careful ownership contract:

  int* createArray(int n) {
      int* arr = new int[n];
      // fill arr
      return arr;
  }
  

  The caller must delete[] it.

• Return std::vector<T>:

  std::vector<int> makeVec(int n) {
      std::vector<int> v(n);
      // fill v
      return v;
  }
  

  The standard library handles memory safely and efficiently.

• Return std::array<T, N> if size is compile-time known.

Returning container types is usually safer and easier to maintain than raw arrays. When teaching pass array to function in C++, including return strategies rounds out the concept.