How to Return Arrays from Functions in C++

Introduction

Returning arrays from functions is a common task that can be approached differently depending on your specific needs and constraints. In C++, returning C-style arrays directly by value isn’t allowed, but there are multiple ways to return an array or its contents effectively. This tutorial covers several techniques for managing this scenario in both classic and modern C++.

1. Understanding Arrays and Pointers

In C++, when you pass an array to a function, what is actually passed is a pointer to the first element of that array. The array type "decays" into a pointer type:

void exampleFunction(int arr[]); // Equivalent to void exampleFunction(int *arr);

Thus, returning arrays by value directly isn’t possible in C++; however, you can return pointers or references.

2. Returning Pointers

A straightforward way to "return an array" is to return a pointer to its first element:

int* fillArray(int arr[]) {
    // Perform operations on arr if needed.
    return arr;
}

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};
    int* result = fillArray(myArray);
    std::cout << result[0]; // Outputs: 1
}

3. Returning References to Arrays

You can return a reference to an array if you need to work with arrays of fixed size:

int (&fillArray(int (&arr)[5]))[5] {
    return arr; // No decay here, preserving the array type.
}

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};
    auto result = fillArray(myArray);
    std::cout << result[0]; // Outputs: 1
}

This technique is less common but useful when dealing with fixed-size arrays.

4. Using std::array (C++11 and Later)

For safer and more modern code, use the std::array template:

#include <array>
using namespace std;

array<int, 5> fillArray(int arr[]) {
    array<int, 5> newArr;
    for (int i = 0; i < 5; ++i) {
        newArr[i] = arr[i] * 2; // Example operation
    }
    return newArr;
}

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};
    array<int, 5> result = fillArray(myArray);
    std::cout << result[0]; // Outputs: 2 (since we multiplied by 2)
}

std::array behaves like a regular C++ class and benefits from copy semantics.

5. Using std::vector for Dynamic Arrays

For dynamic arrays, prefer using std::vector. It simplifies memory management:

#include <vector>
using namespace std;

vector<int> fillVector(vector<int>& arr) {
    for (auto& elem : arr) {
        elem *= 2; // Example operation
    }
    return arr;
}

int main() {
    vector<int> myArray = {1, 2, 3, 4, 5};
    auto result = fillVector(myArray);
    std::cout << result[0]; // Outputs: 2
}

You can modify the input vector directly to avoid unnecessary copies.

6. Using Smart Pointers

When returning dynamically allocated arrays or complex objects, use smart pointers:

#include <vector>
#include <memory>

std::unique_ptr<std::vector<int>> fillSmartVector(const std::vector<int>& arr) {
    auto myArr = std::make_unique<std::vector<int>>(arr);
    for (auto& elem : *myArr) {
        elem *= 2; // Example operation
    }
    return myArr;
}

int main() {
    std::vector<int> myArray = {1, 2, 3, 4, 5};
    auto result = fillSmartVector(myArray);
    std::cout << result->at(0); // Outputs: 2
}

Using std::unique_ptr ensures proper resource management.

7. Using Iterators

For flexibility across different container types, use iterators:

#include <vector>
#include <iostream>

template<typename Iterator>
Iterator fillArrayWithIterators(Iterator begin, Iterator end) {
    for (auto it = begin; it != end; ++it) {
        *it *= 2; // Example operation
    }
    return begin;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto startIt = fillArrayWithIterators(vec.begin(), vec.end());
    std::cout << *startIt; // Outputs: 2
}

This method is versatile and works with various data structures.

Conclusion

Depending on your needs—whether dealing with fixed-size arrays or requiring dynamic memory management—you have several tools in C++ to return array contents from functions effectively. Use pointers, references, std::array, std::vector, smart pointers, or iterators as appropriate for your situation. This flexibility is a key strength of C++, allowing you to write efficient and safe code.